debian-mirror-gitlab/doc/development/logging.md

401 lines
16 KiB
Markdown
Raw Normal View History

2020-10-24 23:57:45 +05:30
---
stage: Monitor
2021-04-29 21:17:54 +05:30
group: Monitor
2021-02-22 17:27:13 +05:30
info: To determine the technical writer assigned to the Stage/Group associated with this page, see https://about.gitlab.com/handbook/engineering/ux/technical-writing/#assignments
2020-10-24 23:57:45 +05:30
---
2021-03-11 19:13:27 +05:30
# GitLab Developers Guide to Logging **(FREE)**
2019-02-15 15:39:39 +05:30
[GitLab Logs](../administration/logs.md) play a critical role for both
administrators and GitLab team members to diagnose problems in the field.
## Don't use `Rails.logger`
Currently `Rails.logger` calls all get saved into `production.log`, which contains
2021-02-22 17:27:13 +05:30
a mix of Rails' logs and other calls developers have inserted in the codebase.
2019-02-15 15:39:39 +05:30
For example:
2020-03-13 15:44:24 +05:30
```plaintext
2019-02-15 15:39:39 +05:30
Started GET "/gitlabhq/yaml_db/tree/master" for 168.111.56.1 at 2015-02-12 19:34:53 +0200
Processing by Projects::TreeController#show as HTML
Parameters: {"project_id"=>"gitlabhq/yaml_db", "id"=>"master"}
...
Namespaces"."created_at" DESC, "namespaces"."id" DESC LIMIT 1 [["id", 26]]
CACHE (0.0ms) SELECT "members".* FROM "members" WHERE "members"."source_type" = 'Project' AND "members"."type" IN ('ProjectMember') AND "members"."source_id" = $1 AND "members"."source_type" = $2 AND "members"."user_id" = 1 ORDER BY "members"."created_at" DESC, "members"."id" DESC LIMIT 1 [["source_id", 18], ["source_type", "Project"]]
CACHE (0.0ms) SELECT "members".* FROM "members" WHERE "members"."source_type" = 'Project' AND "members".
(1.4ms) SELECT COUNT(*) FROM "merge_requests" WHERE "merge_requests"."target_project_id" = $1 AND ("merge_requests"."state" IN ('opened','reopened')) [["target_project_id", 18]]
Rendered layouts/nav/_project.html.haml (28.0ms)
Rendered layouts/_collapse_button.html.haml (0.2ms)
Rendered layouts/_flash.html.haml (0.1ms)
Rendered layouts/_page.html.haml (32.9ms)
Completed 200 OK in 166ms (Views: 117.4ms | ActiveRecord: 27.2ms)
```
These logs suffer from a number of problems:
2021-02-22 17:27:13 +05:30
1. They often lack timestamps or other contextual information (for example, project ID or user)
2019-09-30 21:07:59 +05:30
1. They may span multiple lines, which make them hard to find via Elasticsearch.
1. They lack a common structure, which make them hard to parse by log
2019-07-07 11:18:12 +05:30
forwarders, such as Logstash or Fluentd. This also makes them hard to
search.
2019-02-15 15:39:39 +05:30
2021-02-22 17:27:13 +05:30
Note that currently on GitLab.com, any messages in `production.log` aren't
indexed by Elasticsearch due to the sheer volume and noise. They
2019-02-15 15:39:39 +05:30
do end up in Google Stackdriver, but it is still harder to search for
logs there. See the [GitLab.com logging
2021-10-27 15:23:28 +05:30
documentation](https://gitlab.com/gitlab-com/runbooks/-/tree/master/docs/logging)
2019-02-15 15:39:39 +05:30
for more details.
## Use structured (JSON) logging
Structured logging solves these problems. Consider the example from an API request:
```json
{"time":"2018-10-29T12:49:42.123Z","severity":"INFO","duration":709.08,"db":14.59,"view":694.49,"status":200,"method":"GET","path":"/api/v4/projects","params":[{"key":"action","value":"git-upload-pack"},{"key":"changes","value":"_any"},{"key":"key_id","value":"secret"},{"key":"secret_token","value":"[FILTERED]"}],"host":"localhost","ip":"::1","ua":"Ruby","route":"/api/:version/projects","user_id":1,"username":"root","queue_duration":100.31,"gitaly_calls":30}
```
In a single line, we've included all the information that a user needs
to understand what happened: the timestamp, HTTP method and path, user
2021-09-30 23:02:18 +05:30
ID, and so on.
2019-02-15 15:39:39 +05:30
### How to use JSON logging
Suppose you want to log the events that happen in a project
2021-09-30 23:02:18 +05:30
importer. You want to log issues created, merge requests, and so on, as the
2019-02-15 15:39:39 +05:30
importer progresses. Here's what to do:
1. Look at [the list of GitLab Logs](../administration/logs.md) to see
2019-07-07 11:18:12 +05:30
if your log message might belong with one of the existing log files.
2019-02-15 15:39:39 +05:30
1. If there isn't a good place, consider creating a new filename, but
2019-07-07 11:18:12 +05:30
check with a maintainer if it makes sense to do so. A log file should
make it easy for people to search pertinent logs in one place. For
example, `geo.log` contains all logs pertaining to GitLab Geo.
To create a new file:
2021-02-22 17:27:13 +05:30
1. Choose a filename (for example, `importer_json.log`).
2019-09-30 21:07:59 +05:30
1. Create a new subclass of `Gitlab::JsonLogger`:
```ruby
module Gitlab
module Import
class Logger < ::Gitlab::JsonLogger
def self.file_name_noext
'importer'
2019-02-15 15:39:39 +05:30
end
2019-09-30 21:07:59 +05:30
end
end
end
```
2019-02-15 15:39:39 +05:30
2019-09-30 21:07:59 +05:30
1. In your class where you want to log, you might initialize the logger as an instance variable:
2019-02-15 15:39:39 +05:30
2019-09-30 21:07:59 +05:30
```ruby
attr_accessor :logger
2019-02-15 15:39:39 +05:30
2019-09-30 21:07:59 +05:30
def initialize
@logger = Gitlab::Import::Logger.build
end
```
2019-02-15 15:39:39 +05:30
2019-09-30 21:07:59 +05:30
Note that it's useful to memoize this because creating a new logger
2021-02-22 17:27:13 +05:30
each time you log opens a file, adding unnecessary overhead.
2019-02-15 15:39:39 +05:30
1. Now insert log messages into your code. When adding logs,
make sure to include all the context as key-value pairs:
2019-09-30 21:07:59 +05:30
```ruby
# BAD
logger.info("Unable to create project #{project.id}")
```
2019-02-15 15:39:39 +05:30
2019-09-30 21:07:59 +05:30
```ruby
# GOOD
logger.info(message: "Unable to create project", project_id: project.id)
```
2019-02-15 15:39:39 +05:30
1. Be sure to create a common base structure of your log messages. For example,
all messages might have `current_user_id` and `project_id` to make it easier
to search for activities by user for a given time.
2020-04-08 14:13:33 +05:30
#### Implicit schema for JSON logging
When using something like Elasticsearch to index structured logs, there is a
schema for the types of each log field (even if that schema is implicit /
inferred). It's important to be consistent with the types of your field values,
otherwise this might break the ability to search/filter on these fields, or even
cause whole log events to be dropped. While much of this section is phrased in
an Elasticsearch-specific way, the concepts should translate to many systems you
might use to index structured logs. GitLab.com uses Elasticsearch to index log
data.
2021-02-22 17:27:13 +05:30
Unless a field type is explicitly mapped, Elasticsearch infers the type from
2020-04-08 14:13:33 +05:30
the first instance of that field value it sees. Subsequent instances of that
2021-02-22 17:27:13 +05:30
field value with different types either fail to be indexed, or in some
cases (scalar/object conflict), the whole log line is dropped.
2020-04-08 14:13:33 +05:30
GitLab.com's logging Elasticsearch sets
[`ignore_malformed`](https://www.elastic.co/guide/en/elasticsearch/reference/current/ignore-malformed.html),
which allows documents to be indexed even when there are simpler sorts of
mapping conflict (for example, number / string), although indexing on the affected fields
2021-02-22 17:27:13 +05:30
breaks.
2020-04-08 14:13:33 +05:30
Examples:
2019-02-15 15:39:39 +05:30
2020-04-08 14:13:33 +05:30
```ruby
# GOOD
logger.info(message: "Import error", error_code: 1, error: "I/O failure")
2019-02-15 15:39:39 +05:30
2020-04-08 14:13:33 +05:30
# BAD
logger.info(message: "Import error", error: 1)
logger.info(message: "Import error", error: "I/O failure")
# WORST
logger.info(message: "Import error", error: "I/O failure")
logger.info(message: "Import error", error: { message: "I/O failure" })
```
List elements must be the same type:
```ruby
# GOOD
logger.info(a_list: ["foo", "1", "true"])
# BAD
logger.info(a_list: ["foo", 1, true])
```
Resources:
- [Elasticsearch mapping - avoiding type gotchas](https://www.elastic.co/guide/en/elasticsearch/guide/current/mapping.html#_avoiding_type_gotchas)
- [Elasticsearch mapping types]( https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-types.html)
2019-02-15 15:39:39 +05:30
2020-04-22 19:07:51 +05:30
#### Logging durations
Similar to timezones, choosing the right time unit to log can impose avoidable overhead. So, whenever
2020-05-24 23:13:21 +05:30
challenged to choose between seconds, milliseconds or any other unit, lean towards _seconds_ as float
2021-09-30 23:02:18 +05:30
(with microseconds precision, that is, `Gitlab::InstrumentationHelper::DURATION_PRECISION`).
2020-04-22 19:07:51 +05:30
In order to make it easier to track timings in the logs, make sure the log key has `_s` as
2021-02-22 17:27:13 +05:30
suffix and `duration` within its name (for example, `view_duration_s`).
2020-04-22 19:07:51 +05:30
2020-03-13 15:44:24 +05:30
## Multi-destination Logging
2021-02-22 17:27:13 +05:30
GitLab is transitioning from unstructured/plaintext logs to structured/JSON logs. During this transition period some logs are recorded in multiple formats through multi-destination logging.
2020-03-13 15:44:24 +05:30
### How to use multi-destination logging
2021-02-22 17:27:13 +05:30
Create a new logger class, inheriting from `MultiDestinationLogger` and add an
array of loggers to a `LOGGERS` constant. The loggers should be classes that
descend from `Gitlab::Logger`. For example, the user-defined loggers in the
following examples could be inheriting from `Gitlab::Logger` and
`Gitlab::JsonLogger`, respectively.
2020-03-13 15:44:24 +05:30
2021-02-22 17:27:13 +05:30
You must specify one of the loggers as the `primary_logger`. The
`primary_logger` is used when information about this multi-destination logger is
displayed in the application (for example, using the `Gitlab::Logger.read_latest`
method).
2020-03-13 15:44:24 +05:30
The following example sets one of the defined `LOGGERS` as a `primary_logger`.
```ruby
module Gitlab
class FancyMultiLogger < Gitlab::MultiDestinationLogger
LOGGERS = [UnstructuredLogger, StructuredLogger].freeze
def self.loggers
LOGGERS
end
def primary_logger
UnstructuredLogger
end
end
end
```
2021-02-22 17:27:13 +05:30
You can now call the usual logging methods on this multi-logger. For example:
2020-03-13 15:44:24 +05:30
```ruby
FancyMultiLogger.info(message: "Information")
```
2021-02-22 17:27:13 +05:30
This message is logged by each logger registered in `FancyMultiLogger.loggers`.
2020-03-13 15:44:24 +05:30
### Passing a string or hash for logging
When passing a string or hash to a `MultiDestinationLogger`, the log lines could be formatted differently, depending on the kinds of `LOGGERS` set.
2021-02-22 17:27:13 +05:30
For example, let's partially define the loggers from the previous example:
2020-03-13 15:44:24 +05:30
```ruby
module Gitlab
# Similar to AppTextLogger
class UnstructuredLogger < Gitlab::Logger
...
end
# Similar to AppJsonLogger
class StructuredLogger < Gitlab::JsonLogger
...
end
end
```
Here are some examples of how messages would be handled by both the loggers.
1. When passing a string
```ruby
FancyMultiLogger.info("Information")
# UnstructuredLogger
I, [2020-01-13T18:48:49.201Z #5647] INFO -- : Information
# StructuredLogger
{:severity=>"INFO", :time=>"2020-01-13T11:02:41.559Z", :correlation_id=>"b1701f7ecc4be4bcd4c2d123b214e65a", :message=>"Information"}
```
1. When passing a hash
```ruby
FancyMultiLogger.info({:message=>"This is my message", :project_id=>123})
# UnstructuredLogger
I, [2020-01-13T19:01:17.091Z #11056] INFO -- : {"message"=>"Message", "project_id"=>"123"}
# StructuredLogger
{:severity=>"INFO", :time=>"2020-01-13T11:06:09.851Z", :correlation_id=>"d7e0886f096db9a8526a4f89da0e45f6", :message=>"This is my message", :project_id=>123}
```
### Logging context metadata (through Rails or Grape requests)
`Gitlab::ApplicationContext` stores metadata in a request
lifecycle, which can then be added to the web request
or Sidekiq logs.
2020-05-24 23:13:21 +05:30
The API, Rails and Sidekiq logs contain fields starting with `meta.` with this context information.
2020-03-13 15:44:24 +05:30
Entry points can be seen at:
2021-09-04 01:27:46 +05:30
- [`ApplicationController`](https://gitlab.com/gitlab-org/gitlab/-/blob/master/app/controllers/application_controller.rb)
- [External API](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/api/api.rb)
- [Internal API](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/api/internal/base.rb)
2020-03-13 15:44:24 +05:30
#### Adding attributes
When adding new attributes, make sure they're exposed within the context of the entry points above and:
- Pass them within the hash to the `with_context` (or `push`) method (make sure to pass a Proc if the
method or variable shouldn't be evaluated right away)
- Change `Gitlab::ApplicationContext` to accept these new values
- Make sure the new attributes are accepted at [`Labkit::Context`](https://gitlab.com/gitlab-org/labkit-ruby/blob/master/lib/labkit/context.rb)
2021-03-11 19:13:27 +05:30
See our <i class="fa fa-youtube-play youtube" aria-hidden="true"></i> [HOWTO: Use Sidekiq metadata logs](https://www.youtube.com/watch?v=_wDllvO_IY0) for further knowledge on
2020-03-13 15:44:24 +05:30
creating visualizations in Kibana.
The fields of the context are currently only logged for Sidekiq jobs triggered
through web requests. See the
2020-06-23 00:09:42 +05:30
[follow-up work](https://gitlab.com/gitlab-com/gl-infra/scalability/-/issues/68)
2020-03-13 15:44:24 +05:30
for more information.
2021-03-11 19:13:27 +05:30
### Logging context metadata (through workers)
Additional metadata can be attached to a worker through the use of the [`ApplicationWorker#log_extra_metadata_on_done`](https://gitlab.com/gitlab-org/gitlab/-/blob/16ecc33341a3f6b6bebdf78d863c5bce76b040d3/app/workers/concerns/application_worker.rb#L31-34)
method. Using this method adds metadata that is later logged to Kibana with the done job payload.
```ruby
class MyExampleWorker
include ApplicationWorker
def perform(*args)
# Worker performs work
# ...
# The contents of value will appear in Kibana under `json.extra.my_example_worker.my_key`
log_extra_metadata_on_done(:my_key, value)
end
end
```
Please see [this example](https://gitlab.com/gitlab-org/gitlab/-/blob/16ecc33341a3f6b6bebdf78d863c5bce76b040d3/app/workers/ci/pipeline_artifacts/expire_artifacts_worker.rb#L20-21)
which logs a count of how many artifacts are destroyed per run of the `ExpireArtifactsWorker`.
2020-01-01 13:55:28 +05:30
## Exception Handling
It often happens that you catch the exception and want to track it.
It should be noted that manual logging of exceptions is not allowed, as:
1. Manual logged exceptions can leak confidential data,
1. Manual logged exception very often require to clean backtrace
which reduces the boilerplate,
1. Very often manually logged exception needs to be tracked to Sentry as well,
1. Manually logged exceptions does not use `correlation_id`, which makes hard
to pin them to request, user and context in which this exception was raised,
2021-02-22 17:27:13 +05:30
1. Manually logged exceptions often end up across
2020-01-01 13:55:28 +05:30
multiple files, which increases burden scraping all logging files.
To avoid duplicating and having consistent behavior the `Gitlab::ErrorTracking`
provides helper methods to track exceptions:
1. `Gitlab::ErrorTracking.track_and_raise_exception`: this method logs,
sends exception to Sentry (if configured) and re-raises the exception,
1. `Gitlab::ErrorTracking.track_exception`: this method only logs
and sends exception to Sentry (if configured),
1. `Gitlab::ErrorTracking.log_exception`: this method only logs the exception,
and DOES NOT send the exception to Sentry,
1. `Gitlab::ErrorTracking.track_and_raise_for_dev_exception`: this method logs,
sends exception to Sentry (if configured) and re-raises the exception
2020-03-13 15:44:24 +05:30
for development and test environments.
2020-01-01 13:55:28 +05:30
It is advised to only use `Gitlab::ErrorTracking.track_and_raise_exception`
and `Gitlab::ErrorTracking.track_exception` as presented on below examples.
Consider adding additional extra parameters to provide more context
for each tracked exception.
### Example
```ruby
class MyService < ::BaseService
def execute
project.perform_expensive_operation
success
rescue => e
Gitlab::ErrorTracking.track_exception(e, project_id: project.id)
error('Exception occurred')
end
end
```
```ruby
class MyService < ::BaseService
def execute
project.perform_expensive_operation
success
rescue => e
Gitlab::ErrorTracking.track_and_raise_exception(e, project_id: project.id)
end
end
```
2019-02-15 15:39:39 +05:30
## Additional steps with new log files
2021-02-22 17:27:13 +05:30
1. Consider log retention settings. By default, Omnibus rotates any
2019-07-07 11:18:12 +05:30
logs in `/var/log/gitlab/gitlab-rails/*.log` every hour and [keep at
most 30 compressed files](https://docs.gitlab.com/omnibus/settings/logs.html#logrotate).
On GitLab.com, that setting is only 6 compressed files. These settings should suffice
2019-12-04 20:38:33 +05:30
for most users, but you may need to tweak them in [Omnibus GitLab](https://gitlab.com/gitlab-org/omnibus-gitlab).
2019-02-15 15:39:39 +05:30
1. If you add a new file, submit an issue to the [production
2020-06-23 00:09:42 +05:30
tracker](https://gitlab.com/gitlab-com/gl-infra/production/-/issues) or
a merge request to the [`gitlab_fluentd`](https://gitlab.com/gitlab-cookbooks/gitlab_fluentd)
2020-03-13 15:44:24 +05:30
project. See [this example](https://gitlab.com/gitlab-cookbooks/gitlab_fluentd/-/merge_requests/51/diffs).
2019-02-15 15:39:39 +05:30
1. Be sure to update the [GitLab CE/EE documentation](../administration/logs.md) and the [GitLab.com
2020-05-24 23:13:21 +05:30
runbooks](https://gitlab.com/gitlab-com/runbooks/blob/master/docs/logging/README.md).