View Source LoggerExporter (LoggerExporter v0.4.0)

LoggerExporter

Export your logs to the service of your choice.

I created this library because I wanted to export logs to a different service in Heroku. There is no simple way to export your logs.

supported-exporters

Supported exporters:

  • Loki
  • Mezmo (LogDNA)

Implement your own exporter using LoggerExporter.Exporters.Exporter behaviour.

supported-formatters

Supported formatters:

  • Basic

Implement your own formatter using LoggerExporter.Formatters.Formatter behaviour.

plug-logger

Plug Logger

A plug for logging request information. It will log the method, path, params, status and duration.

You can add it to your MyApp.Endpoint:

  # Log level defaults to :info
  plug LoggerExporter.Loggers.Plug

  # Dynamic log
  plug LoggerExporter.Loggers.Plug, log: {__MODULE__, :log_level, []}

  # Disables logging for routes like /health_check
  def log_level(%{path_info: ["health_check"]}), do: false
  def log_level(_), do: :info

installation

Installation

Add logger_exporter to your list of dependencies in mix.exs:

def deps do
  [
    {:logger_exporter, "~> 0.4.0"}
  ]
end

configuration

Configuration

By default, the timestamp sent for each log to the external service is in utc: System.os_time(:nanosecond)

optiondescriptiondefault
levelThe logger level to report.:info
formatterAllows the selection of a formatter implementation.LoggerExporter.Formatters.BasicFormatter
metadataMetadata to log.[]
exporterAllows selection of a exporter implementation.LoggerExporter.Exporters.LokiExporter
hostThe host of the service without the path. The path is inferred by the exporter.No default. Required
app_nameThe name of the app to use as label.No default. Required
environment_nameThe name of the app to use as label.No default. Required
send_to_httpIf set to false, the library will not make any actual API calls. This is useful for test or dev environments.true
http_authhSee below for configurationNo default

htpp-auth

HTPP Auth

Supported authentication methods:

  • Basic
  • Bearer
  • Custom
authusageexamplesresult
basic{:basic, username, password}{:basic, "user", "pxIsldPlwty"}"Authorization: Basic CshL2XlkX57cww=="
bearer{:bearer, token}{:bearer, "WmRUuBOnTjDwP6jo3bno"}"Authorization: Bearer WmRUuBOnTjDwP6jo3bno"
custom{:header, header, value}{:header, "apiKey", "dAWQvRQQkZCc2A=="}"apiKey: dAWQvRQQkZCc2A=="

usage-in-phoenix

Usage in Phoenix

  1. Add the following to deps section of your mix.exs: {:logger_exporter, "~> 0.4.0"} and then mix deps.get

  2. Add LoggerExporter.Backend to your logger's backends configuration

    config :logger,
      backends: [:console, LoggerExporter.Backend]
  3. Add config related to the exporter and other fields. ie. for LokiExporter

    config :logger, LoggerExporter,
      host: "http://localhost:3100",
      app_name: "my_app",
      environment_name: Mix.env(),
      http_auth: {:basic, System.fetch_env!("LOKI_USER"), System.fetch_env!("LOKI_PASSWORD")},
      metadata: [:request_id]
  4. Start the LoggerExporter GenServer in the supervised children list. In application.ex add to the children list:

    children [
      ...
      LoggerExporter
    ]
  5. (Optional) Add custom Plug logger. In MyApp.Endpoint add the plug after Plug.Parsers. If you see duplicate logs, remove Plug.Telemetry from your endpoint.

     plug Plug.Parsers,
       ...
    
     plug LoggerExporter.Loggers.Plug

json-formatter-example

JSON Formatter Example

If you want to log in JSON format, you can use the formatter of another library: logger_json

You can configure it like this:

config :logger, LoggerExporter,
  formatter: LoggerJSON.Formatters.BasicLogger

And it will work out of the box :)

telemetry

Telemetry

Telemetry integration for logging and error reporting.

There is a default logger for you to attach. It logs when the status is :error

In your application.ex

:ok = LoggerExporter.Telemetry.attach_default_logger()

http-post-batch-events

HTTP Post batch events

LoggerExporter emits the following events for processing each batch (sending it through http)

  • [:logger_exporter, :batch, :start] -- starting to process the events
  • [:logger_exporter, :batch, :stop] -- after the events is processed
  • [:logger_exporter, :batch, :exception] -- after the events are processed

The following chart shows which metadata you can expect for each event:

eventmeasuresmetadata
:start:system_time:events
:stop:duration:events, :status, :response
:exception:duration:events, :kind, :reason, :stacktrace

Metadata

Link to this section Summary

Link to this section Functions

Link to this function

take_metadata(log_metadata, keys)

View Source
@spec take_metadata(
  keyword(),
  :all | [atom()]
) :: keyword()

Take specified keys from the metadata