loggun 0.1.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a8a4d4015105e9d55b653cab3305ab2b1ddeeda0e1429bd5e2449c5841771fe
-  data.tar.gz: e6a84389338458849f87dfb2ffcdea13403537553fa547b170c4debb5901f433
+  metadata.gz: cfd41231567df2c15cca3c6ba500fc8228dcf03ac808b2adb452385be59d4217
+  data.tar.gz: 86c26424200b7c443a4160770d7b3f0d22490db5e0ac3c41fffdd2dadd795d9e
 SHA512:
-  metadata.gz: f10eb810cb421dde460b1c97c777496447d22197dfdbf35bf6eae341a1b9b2a6270044135887a062882c0f8bf4ccc21efbfe3231598ee7f060ca5be220385a6f
-  data.tar.gz: 3362704777d4d6814ba58e1a72aee945d5f1f8105d03ff20930e3ecd02d559d5878f90681a77aefd14231aef67dbb79b41cd1883a5cbc6e54a8fa3817c1a49c9
+  metadata.gz: '058933cfb04111fe6f0f106e97efde068932b575bfc2be6bdfee0f419db586b07e0a11025eba01b65d12f71a9ef8121dc88e4c53dc39037cd95d5ee6d1ccd90b'
+  data.tar.gz: ebd06ae4867bb4b8cc03fa0ef1815ca73f58af294fab484f3f1207c01d3b4c305cfaa442a6b82771524a909fdb88cb68a8421c760ba8099731957a158c910858

data/.travis.yml

@@ -3,8 +3,6 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.3.8
-  - 2.4.6
   - 2.5.5
   - 2.6.5
 before_install: gem install bundler

data/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+## 0.4.1 - 2020-07-28
+* fixes
+  * fill type with class name for empty `log_entity_name`
+
+## 0.4.0 - 2020-06-02
+* fixes
+  * fix key_value join character to space
+  * fix dummy dependency alerts
+* features
+  * add new const MESSAGE_FORMATS and test for checking the value of message_format
+  * add check message_format
+  * boolean flag replace with a whitelist and create method for generating a message
+  * added ability to log messages format k=v
+
+## 0.3.1 - 2020-04-21
+* fixes
+  * fix error "modify frozen String" for class name in helpers
+
+## 0.3.0 - 2020-04-17
+* fixes
+  * make public #generate_log_transaction_id in helper
+  * removed incoming http modifier
+
+## 0.2.0 - 2020-04-13
+* fixes
+  * fix Readme with active_record modifier
+  * fix except option for helper #log_options
+  * refactor helpers #log_type
+  * fix helper define log_methods caller
+  * improve stability of helpers
+* features
+  * remove legacy agent from default log pattern
+  * new active record modifier
+  * improve sidekiq modifier for difference versions

data/README.md

@@ -1,37 +1,70 @@
 # Loggun
 
-[![Sponsored by FunBox](https://funbox.ru/badges/sponsored_by_funbox_compact.svg)](https://funbox.ru)
-
 [![Gem Version](https://badge.fury.io/rb/loggun.svg)](https://badge.fury.io/rb/loggun)
 [![Build Status](https://travis-ci.org/funbox/loggun.svg?branch=master)](https://travis-ci.org/funbox/loggun)
 
-## Описание
-Loggun - это гем, позволяющий привести все логи приложения к единому формату
+Приводит логи приложения к единому формату.
+
+## Содержание
+
+- [Установка](#установка)
+- [Использование](#использование)
+- [Конфигурация](#конфигурация)
+  - [Настройки](#настройки)
+  - [Модификаторы](#модификаторы)
+    - [Rails модификатор](#rails-модификатор)
+    - [Active Record модификатор](#active-record-модификатор)
+    - [Sidekiq модификатор](#sidekiq-модификатор)
+    - [Clockwork модификатор](#clockwork-модификатор)
+    - [Модификатор исходящих HTTP-запросов](#модификатор-исходящих-http-запросов)
+    - [Модификатор входящих запросов в Rails](#модификатор-входящих-запросов-в-rails)
+    - [Пользовательские модификаторы](#пользовательские-модификаторы)
+  - [Хелперы](#хелперы)
 
 ## Установка
 
-Чтобы установить гем, добавьте в ваш Gemfile:
+Чтобы установить гем, добавьте его в Gemfile:
 
 ```ruby
 gem 'loggun'
 ```
 
-И выполните команду :
+И выполните команду:
 
-    $ bundle
+```bash
+$ bundle
+```
 
 ## Использование
 
-### Конфигурация
-Для успешной конфигурации гема необходимо подгружать файл при инициализации вашего приложения.
+Loggun можно использовать как обертку для вашего `logger`. Для этого необходимо передать
+ему инстанс логгера и настроить его `formatter`:
+
+```ruby
+Loggun.logger = Rails.logger
+Loggun.logger.formatter = Loggun::Formatter.new
+```
+
+Теперь можно использовать Loggun для логирования в стандартизированном формате:
+
+```ruby
+Loggun.info('http_request.api.request', user_id: current_user.id)
+#=> 2020-04-11T22:35:04.225+03:00 - 170715 INFO http_request.api.request - {"user_id": 5465}
+...
+Loggun.info('http_request.api.response', user_id: current_user.id, success: true)
+#=> 2020-04-11T22:35:04.225+03:00 - 170715 INFO http_request.api.response - {"user_id": 5465, "success": true} 
+``` 
+
+## Конфигурация
 
-`config/initializers/loggun.rb`
+Конфигурацию гема необходимо производить при инициализации приложения. Например, так:
 
 ```ruby
 Loggun::Config.configure do |config|
   config.precision = :milliseconds
   config.pattern = '%{time} - %{pid} %{severity} %{type} %{tags_text} %{message}'
   config.parent_transaction_to_message = false
+  config.message_format = :json
 
   config.modifiers.rails = true
   config.modifiers.sidekiq = false
@@ -40,39 +73,130 @@ Loggun::Config.configure do |config|
   config.modifiers.outgoing_http = false
 end
 ```
-Все настройки являются опциональными.
-#### Настройки
-`precision` - точность отметок времени. По умолчанию - `milliseconds`. Может принимать одно из следующих значений: `sec`, `seconds`, `ms`, `millis`, `milliseconds`, `us`, `micros`, `microseconds`, `ns`, `nanos`, `nanoseconds`
 
-`pattern` - шаблон для формата вывода данных в лог. Доступные ключи: `time`, `pid`, `severity`, `type`, `tags_text`, `message`, `parent_transaction`
+### Настройки
+
+Все настройки опциональны.
+
+- `precision` — точность отметок времени.
+
+  Может принимать одно из следующих значений:
+  `sec`, `seconds`, `ms`, `millis`, `milliseconds`, `us`, `micros`, `microseconds`, `ns`, `nanos`, `nanoseconds`.
+  
+  По умолчанию `milliseconds`.
+
+- `pattern` — текстовый шаблон для формата вывода данных в лог.   
+
+  Доступные ключи внутри шаблона: `time`, `pid`, `severity`, `type`, `tags_text`, `message`, `parent_transaction`.
+
+- `parent_transaction_to_message` — если `true`, то значение `parent_transaction` будет добавлено в тело логируемого сообщения.
+ 
+  Ключ `parent_transaction` в шаблоне `pattern` можно использовать вне зависимости от значения этой настройки. 
+
+- `message_format` — формат переменной `message` в шаблоне `pattern`. 
 
-`parent_transaction_to_message` - признак необходимости добавлять значение `parent_transaction` в тело логируемого сообщения. 
-Вне зависимости от данной настройки можно использовать ключ `parent_transaction` в шаблоне `pattern`.
+  Доступные значения:
+   
+  - `:json` — `message` логируется как JSON-строка;
+  - `:key_value` — `message` логируется в формате `key1=value1 key2=value2`.
+ 
+- `modifiers` — модификаторы для переопределения формата логирования указанного компонента. См. «[Модификаторы](#модификаторы)».
 
-`modifiers` - модификаторы для переопределения формата логирования указанного компонента. См. далее.
+### Модификаторы
 
-#### Модификаторы
 Каждый модифкатор может быть активирован двумя равнозначными способами:
+
 ```ruby
 config.modifiers.rails = true
 ```
+
 или
+
 ```ruby
 config.modifiers.rails.enable = true
 ```
 
-`rails` - модифицирует форматирование логгера Rails.
+(В качестве примера активируется Rails модификатор, но может быть любой другой.)
+
+#### Rails модификатор 
+
+`config.modifier.rails`
+
+Модифицирует форматирование логгера Rails.
+
+#### Active Record модификатор
+
+`config.modifier.active_record`
+
+Добавляет (именно добавляет, а не модифицирует) нового подписчика на SQL-события.
+
+SQL начинает дополнительно логироваться в Loggun формате, `severity` — `info`. Например:
+
+```text
+2020-04-12T20:08:52.913+03:00 - 487257 INFO storage.sql.query - {"sql":"SELECT 1","name":null,"duration":0.837}
+```
+
+Дополнительные настройки:
+
+- `log_subscriber_class_name` — имя класса, реализующего логирование SQL-события.
+
+  Необходим метод `#sql`. По умолчанию: `::Loggun::Modifiers::ActiveRecord::LoggunLogSubscriber`.
+
+- `payload_keys` — необходимые ключи в полезной нарзуке. Используется в классе по умолчанию. 
+   
+  Доступные ключи: `%i[sql name duration source]`.
+
+Пример:
+
+```ruby
+Loggun::Config.configure do |config|
+  #...
+  config.modifiers.active_record.enable = true
+  config.modifiers.active_record.log_subscriber_class_name = 'MyApp::MyLogSubscriber'
+  config.modifiers.active_record.payload_keys = %i[sql duration]
+  #...
+end
+```
+
+#### Sidekiq модификатор 
+
+`config.modifiers.sidekiq`
+
+Модифицирует форматирование логгера Sidekiq.
+
+#### Clockwork модификатор
+
+`config.modifiers.clockwork`
+ 
+Модифицирует форматирование логгера Clockwork.
+
+#### Модификатор исходящих HTTP-запросов
+
+`config.modifiers.outgoing_http`
+
+Добавляет логирование исходящих HTTP-запросов. 
+На данный момент поддерживаются только запросы, выполненные с помощью гема `HTTP`.
+
+#### Модификатор входящих запросов в Rails
+
+ `config.modifiers.incoming_http`
+ 
+Добавляет логирование входящих HTTP-запросов для контроллеров Rails.
+
+Может иметь дополнительные настройки:
 
-`sidekiq` - модифицирует форматирование логгера Sidekiq.
+- `controllers` — массив имён базовых контроллеров, для которых необходимо добавить указанное логирование.
 
-`clockwork` - модифицирует форматирование логгера Clockwork.
+- `success_condition` — лямбда, определяющая, содержит ли успех ответ экшена.
 
-`outgoing_http` - добавляет логирование исходящих http запросов. 
-На данный момент поддерживаются только запросы посредством гема `HTTP`.
+  Например: `-> { JSON.parse(response.body)['result'] == 'ok' }`
 
-`incoming_http` - добавляет логирование входящих http запросов для контроллеров Rails.
-Данный модификатор может иметь дополнительные настройки, которые устанавливаются следующим образом 
-(приведены значения по умолчанию):
+- `error_info` — лямбда, позволяющая добавить в лог информацию об ошибке, содержащейся в неуспешном ответе экшена. 
+
+  Например: `-> { JSON.parse(response.body)['error_code'] }`
+
+
+Пример (приведены значения по умолчанию):
 
 ```ruby
 Loggun::Config.configure do |config|
@@ -85,25 +209,24 @@ Loggun::Config.configure do |config|
 end
 ```
 
-`controllers` - массив имён базовых контроллеров, для которых необходимо добавить указанное логирование.
+**Для Rails 6 и выше данный модификатор может работать некорректно.** 
 
-`success_condition` - лямбда, определяющая, содержит ли успех ответ экшена. Например `-> { JSON.parse(response.body)['result'] == 'ok' }`
+В этом случае можно добавить в требуемый базовый контроллер строку:
 
-`error_info` - лямбда, позволяющая добавить в лог информацию об ошибке, содержащейся в неуспешном ответе экшена. 
-Например `-> { JSON.parse(response.body)['error_code'] }`
-
-Для Rails 6 и выше данный модификатор может работать некорректно. 
-В этом случае можно указать в требуемом базовом контроллере строку:
 ```ruby
 include Loggun::HttpHelpers
 ```
+
 Это делает настройки `enable` и `controllers` модификатора безсполезными, 
-однако позволяет гарантированно логировать входящие http запросы.
+однако позволяет гарантированно логировать входящие HTTP-запросы.
 
-Настройки `success_condition` и `error_info` продолжают использоваться и могу быть установлены требуемым образом.
+Настройки `success_condition` и `error_info` продолжают использоваться и могут быть установлены требуемым образом.
+
+#### Пользовательские модификаторы
 
 Помимо указанных модификаторов существует возможность добавить собственный. 
-Необходимо уснаследовать его от `Loggun::Modifiers::Base` и указать в методе `apply` все необходимые действия.
+Необходимо уснаследовать его от `Loggun::Modifiers::Base` и указать в методе `apply` все необходимые действия:
+
 ```ruby
 require 'sinatra/custom_logger'
 
@@ -113,7 +236,9 @@ class NewModifier < Loggun::Modifiers::Base
   end
 end
 ```
-Затем необходимо добавить его при конфигурации гема.
+
+Затем необходимо добавить его при конфигурации гема:
+
 
 ```ruby
 Loggun::Config.configure do |config|
@@ -124,32 +249,45 @@ end
 ```
 
 ### Хелперы
-Подключение хелперов в класс позволяет использовать методы логирования `log_info` и `log_error`, 
+
+Подключение хэлперов в класс позволяет использовать методы логирования `log_info` и `log_error`, 
 а также генерировать идентификатор транзации для каждого метода класса.
 
 Например:
+
 ```ruby
 class SomeClass
   include Loggun::Helpers
 
-  log_options entity_action: :method_name, as_transaction: true
-
-  def some_action
-    log_info 'type_for_action', 'Information'
-    bar
-  end
+  log_options entity_action: :method_name, as_transaction: true, only: %i[download_data]
 
-  def bar
-    log_info 'type_for_bar', 'Bar information'
+  def download_data
+    log_info 'http_request', 'Information'
+    # ... make http request here
+    log_info 'http_response', success: true
   end
 end
 ```
-Даёт подобный вывод в лог:
+
+При вызове `#download_data` будет следующий вывод в лог:
+
 ```
-2020-03-04T16:58:38.207+05:00 - 28476 INFO type_for_action.some_class.some_action#msg_id_1583323118203 - {"value":["Information"]}
-2020-03-04T16:58:38.208+05:00 - 28476 INFO type_for_bar.some_class.bar#msg_id_1583323118207 - {"value":["Bar information"],"parent_transaction":"class.geo_location__actual_location.fetch_input#msg_id_1583323118203"}
+2020-03-04T16:58:38.207+05:00 - 28476 INFO http_request.some_class.download_data#ffg5431_1583323118203 - {"message":["Information"]}
+2020-03-04T16:58:38.208+05:00 - 28476 INFO http_response.some_class.download_data#ffg5431_1583323118203 - {"success": true}
 ```
 
-## License
+**Важно**, что с хэлпером `log_options` необходимо использовать только методы вида `log_<severity>`. 
+Методы модуля `Loggun` не будут работать.
+
+Список всех опций хэлпера `log_options`:
+
+- `entity_name` — имя сущности метода, `string`;
+- `entity_action` — действие сущности метода, `string`;
+- `as_transaction` — добавлять ли уникальный ID транзакции для метода, `boolean`;
+- `transaction_generator` — собственный генератор ID транзакции, `lambda`;
+- `log_all_methods` — применять ли хэлпер ко всем методам, `boolean`;
+- `only` — список методов, для которых необходимо применить хэлпер (работает только когда `log_all_methods = false`), `Array{Symbol}`;
+- `except` — список методов, которые надо исключить для хэлпера, `Array{Symbol}`;
+- `log_transaction_except` — список методов, логирование которых не нужно обогащать ID транзакции, `Array{Symbol}`.
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+[![Sponsored by FunBox](https://funbox.ru/badges/sponsored_by_funbox_centered.svg)](https://funbox.ru)

data/lib/loggun.rb

@@ -5,7 +5,6 @@ require 'loggun/config'
 require 'loggun/modifiers'
 require 'loggun/modifiers/base'
 require 'loggun/helpers'
-require 'loggun/http_helpers'
 require 'logger'
 
 module Loggun

data/lib/loggun/config.rb

@@ -6,21 +6,28 @@ module Loggun
     include Singleton
 
     DEFAULTS = {
-      pattern: '%{time} - %{pid} %{severity} %{type} %{tags_text}%{agent} %{message}',
+      pattern: '%{time} - %{pid} %{severity} %{type} %{tags_text} %{message}',
       parent_transaction_to_message: true,
+      message_format: :json,
       precision: :milliseconds,
       incoming_http: {
         controllers: %w[ApplicationController],
         success_condition: -> { response.code == '200' },
         error_info: -> { nil }
+      },
+      active_record: {
+        log_subscriber_class_name: '::Loggun::Modifiers::ActiveRecord::LoggunLogSubscriber',
+        payload_keys: %i[sql name duration source]
       }
     }.freeze
-    DEFAULT_MODIFIERS = %i[rails sidekiq clockwork incoming_http outgoing_http].freeze
+    DEFAULT_MODIFIERS = %i[rails active_record sidekiq clockwork outgoing_http].freeze
+    MESSAGE_FORMATS = %i[json key_value].freeze
 
     attr_accessor(
       :formatter,
       :pattern,
       :parent_transaction_to_message,
+      :message_format,
       :precision,
       :modifiers,
       :custom_modifiers
@@ -31,6 +38,7 @@ module Loggun
       @precision = DEFAULTS[:precision]
       @pattern = DEFAULTS[:pattern]
       @parent_transaction_to_message = DEFAULTS[:parent_transaction_to_message]
+      @message_format = DEFAULTS[:message_format]
       @modifiers = Loggun::OrderedOptions.new
       @custom_modifiers = []
       set_default_modifiers
@@ -40,6 +48,7 @@ module Loggun
       def configure(&block)
         block.call(instance)
         use_modifiers
+        check_config
         instance
       end
 
@@ -55,9 +64,15 @@ module Loggun
         instance.custom_modifiers.each(&:use)
       end
 
-      def setup_formatter(app)
+      def check_config
+        return if MESSAGE_FORMATS.include? instance.message_format
+
+        raise FailureConfiguration, 'Unknown value for message_format'
+      end
+
+      def setup_formatter(app, formatter = nil)
         Loggun.logger = app.logger
-        Loggun.logger.formatter = instance.formatter
+        Loggun.logger.formatter = formatter || instance.formatter
       end
     end
 
@@ -87,5 +102,7 @@ module Loggun
         3 # milliseconds
       end
     end
+
+    class FailureConfiguration < StandardError; end
   end
 end

data/lib/loggun/formatter.rb

@@ -5,7 +5,7 @@ module Loggun
   class Formatter
     DEFAULT_VALUE = '-'.freeze
 
-    def call(severity, time, _program_name, message)
+    def call(severity, time, _program_name, message, loggun_type: nil)
       data = Hash.new(DEFAULT_VALUE)
       data[:time] = time.iso8601(config.timestamp_precision)
       data[:pid] = Process.pid
@@ -14,13 +14,13 @@ module Loggun
         if config.parent_transaction_to_message && parent_transaction
           message[:parent_transaction] = parent_transaction
         end
-        message = JSON.generate(message)
+        message = format_message(message)
       end
 
       data[:message] = message.to_s.tr("\r\n", ' ').strip
       data[:severity] = severity&.to_s || 'INFO'
       data[:tags_text] = tags_text
-      data[:type] = Loggun.type || DEFAULT_VALUE.dup
+      data[:type] = loggun_type || Loggun.type || DEFAULT_VALUE.dup
       data[:transaction_id] = Loggun.transaction_id
       data[:parent_transaction] = parent_transaction if parent_transaction
 
@@ -78,5 +78,16 @@ module Loggun
     def config
       Loggun::Config.instance
     end
+
+    def format_message(message)
+      if config.message_format == :json
+        JSON.generate(message)
+      elsif config.message_format == :key_value
+        message.map { |key, value| "#{key}=#{value}" }.join(' ')
+      else
+        warn('Unknown value for message_format')
+        JSON.generate(message)
+      end
+    end
   end
 end

data/lib/loggun/helpers.rb

@@ -3,53 +3,65 @@ require 'securerandom'
 module Loggun
   module Helpers
     SKIPPED_METHODS = %i[
-      initialize loggun logger modified_methods
+      initialize loggun logger log_modified_methods loggun_init in_log_transaction with_log_type
     ].freeze
     DEFAULT_TYPE = 'class'.freeze
 
     def self.included(klass)
+      klass.extend(InitMethods)
+      klass.loggun_init
       klass.extend(ClassMethods)
-      klass.init
     end
 
-    module ClassMethods
+    module InitMethods
       attr_accessor(
         :with_log_transaction_id,
         :log_transaction_generator,
         :log_entity_name,
         :log_entity_action,
-        :modified_methods,
-        :generate_transaction_except
+        :log_modified_methods,
+        :log_skip_methods,
+        :log_only_methods,
+        :log_all_methods,
+        :log_transaction_except
       )
 
+      def loggun_init
+        @log_modified_methods = []
+        @log_all_methods = false
+      end
+    end
+
+    module ClassMethods
       def log_options(**options)
         @log_entity_name = options[:entity_name]
         @log_entity_action = options[:entity_action]
         @with_log_transaction_id = options[:as_transaction]
         @log_transaction_generator = options[:transaction_generator]
-        @generate_transaction_except = options[:generate_transaction_except]&.map(&:to_sym)
-      end
-
-      def init
-        @modified_methods = []
+        @log_transaction_except = options[:log_transaction_except]&.map(&:to_sym)
+        @log_skip_methods = options[:except]&.map(&:to_sym)
+        @log_only_methods = options[:only]&.map(&:to_sym)
+        @log_all_methods = options[:log_all_methods]
       end
 
       def method_added(method_name)
         super
-        @modified_methods ||= []
-        return if SKIPPED_METHODS.include?(method_name) ||
-                  modified_methods.include?(method_name)
+        @log_modified_methods ||= []
+
+        return if !log_all_methods && !log_only_methods&.include?(method_name)
+        return if log_skip_methods&.include?(method_name)
+        return if SKIPPED_METHODS.include?(method_name) || log_modified_methods.include?(method_name)
 
-        modified_methods << method_name
+        log_modified_methods << method_name
         method = instance_method(method_name)
         undef_method(method_name)
 
         define_method(method_name) do |*args, &block|
-          if self.class.generate_transaction_except&.include?(method_name.to_sym)
+          if self.class.log_transaction_except&.include?(method_name.to_sym)
             method.bind(self).call(*args, &block)
           else
             type = log_type(nil, method_name)
-            in_transaction(type) do
+            in_log_transaction(type) do
               method.bind(self).call(*args, &block)
             end
           end
@@ -57,19 +69,15 @@ module Loggun
       end
     end
 
-    %i[unknown fatal error warn info debug].each do |method|
-      define_method("log_#{method}") do |*args, **attrs, &block|
+    %i[unknown fatal error warn info debug].each do |method_name|
+      define_method("log_#{method_name}") do |*args, **attrs, &block|
         type = args.shift
-        next logger.send(method, type, &block) if args.empty? &&
-                                                  attrs.empty?
+        next logger.send(method_name, type, &block) if args.empty? && attrs.empty?
 
-        method_name = caller_locations.first.label.split(' ').last
-        type = log_type(type, method_name)
-
-        if %i[fatal error].include?(method)
-          methods = args.first.methods
-          next unless methods.include?(:message) && methods.include?(:backtrace)
+        caller_method_name = caller_locations.first.label.split(' ').last
+        type = log_type(type, caller_method_name)
 
+        if %i[fatal error].include?(method_name) && %i[backtrace message].all? { |m| args.first.respond_to?(m) }
           error = args.shift
           attrs[:error] = { class: error.class, msg: error.message }
           if attrs[:hidden]
@@ -78,10 +86,10 @@ module Loggun
             attrs[:hidden] = { error: { backtrace: error.backtrace } }
           end
         end
-        attrs[:value] = args unless args.empty?
+        attrs[:message] = args unless args.empty?
 
-        with_type(type) do
-          logger.send(method, **attrs, &block)
+        with_log_type(type) do
+          logger.send(method_name, **attrs, &block)
         end
       end
     end
@@ -98,7 +106,7 @@ module Loggun
       end
     end
 
-    def in_transaction(current_type = nil, current_transaction_id = nil)
+    def in_log_transaction(current_type = nil, current_transaction_id = nil)
       current_transaction_id ||= generate_log_transaction_id
       previous_transaction_id = self.parent_transaction_id
       previous_type = self.parent_type
@@ -117,7 +125,7 @@ module Loggun
       self.parent_type = previous_type
     end
 
-    def with_type(current_type)
+    def with_log_type(current_type)
       previous_type = self.type
       self.type = current_type
       yield
@@ -126,22 +134,32 @@ module Loggun
     end
 
     def log_type(type, method_name)
+      klass = self.class
       type ||= DEFAULT_TYPE.dup
       type_as_arr = type.split('.')
-      klass = self.class
-      log_entity_name = klass.log_entity_name if klass.respond_to?(:log_entity_name)
-      log_entity_name ||= underscore(klass.name)
-      type << ".#{log_entity_name}" if type_as_arr.size == 1
+
+      if type_as_arr.size == 1
+        log_entity_name = klass.log_entity_name if klass.respond_to?(:log_entity_name)
+
+        log_entity_name ||= underscore(klass.name.dup)
+        type_as_arr << log_entity_name
+      end
 
       return type unless klass.respond_to?(:log_entity_action)
 
-      if klass.log_entity_action && type_as_arr.size < 3
-        if klass.log_entity_action == :method_name && method_name
-          type << ".#{method_name}"
-        end
+      if klass.log_entity_action && klass.log_entity_action == :method_name && type_as_arr.size < 3 && method_name
+        type_as_arr << method_name
       end
 
-      type
+      type_as_arr.join('.')
+    end
+
+    def generate_log_transaction_id
+      if self.class.log_transaction_generator
+        return self.class.log_transaction_generator.call(self)
+      end
+
+      "#{SecureRandom.uuid[0..7]}_#{DateTime.now.strftime('%Q')}"
     end
 
     private
@@ -162,15 +180,6 @@ module Loggun
       word
     end
 
-    def generate_log_transaction_id
-      return unless self.class.with_log_transaction_id
-      if self.class.log_transaction_generator
-        return self.class.log_transaction_generator.call
-      end
-
-      "#{SecureRandom.uuid[0..7]}_#{DateTime.now.strftime('%Q')}"
-    end
-
     def logger
       Loggun.logger
     end

data/lib/loggun/modifiers/active_record.rb

@@ -0,0 +1,22 @@
+module Loggun
+  module Modifiers
+    class ActiveRecord < Loggun::Modifiers::Base
+      def apply
+        return unless defined?(::ActiveRecord) && defined?(::ActiveRecord::LogSubscriber)
+
+        subscriber_class_name = config.modifiers.active_record.log_subscriber_class_name
+        if subscriber_class_name == ::Loggun::Config::DEFAULTS[:active_record][:log_subscriber_class_name]
+          require 'loggun/modifiers/active_record/loggun_log_subscriber'
+        end
+        klass = Object.const_get(subscriber_class_name)
+
+        return klass.attach_to :active_record if klass.respond_to?(:attach_to)
+
+        Loggun.warn(
+          "Loggun: passed active_record.log_subscriber_class_name `#{subscriber_class_name}`" \
+          "must respond to #attached_to method"
+        )
+      end
+    end
+  end
+end

data/lib/loggun/modifiers/active_record/loggun_log_subscriber.rb

@@ -0,0 +1,22 @@
+module Loggun
+  module Modifiers
+    class ActiveRecord
+      class LoggunLogSubscriber < ::ActiveRecord::LogSubscriber
+        def sql(event)
+          payload = event.payload
+          return if IGNORE_PAYLOAD_NAMES.include?(payload[:name]) || payload[:cached]
+
+          available_keys = ::Loggun::Config.instance.modifiers.active_record.payload_keys&.map { |k| k.downcase.to_sym }
+          data = { sql: payload[:sql], name: payload[:name], duration: event.duration.round(4) }
+          source = respond_to?(:extract_query_source_location) ? extract_query_source_location(caller) : nil
+          data.merge!(source: source.gsub(/(?<=\.rb)(.*)$/, '')) if source
+          if available_keys&.any?
+            data.each { |k, _| data.delete(k) unless available_keys.include?(k) }
+          end
+
+          Loggun.info 'storage.sql.query', data
+        end
+      end
+    end
+  end
+end

data/lib/loggun/modifiers/base.rb

@@ -14,6 +14,10 @@ module Loggun
       def apply
         raise NotImplementedError, 'You must implement #apply in your modifier.'
       end
+
+      def config
+        Loggun::Config.instance
+      end
     end
   end
 end

data/lib/loggun/modifiers/sidekiq.rb

@@ -3,11 +3,21 @@ require 'sidekiq' if defined?(::Sidekiq)
 module Loggun
   module Modifiers
     class Sidekiq < Loggun::Modifiers::Base
+      MIN_SIDEKIQ_V = '4.0.0'.freeze
+
       def apply
-        return unless defined?(::Sidekiq)
+        return unless defined?(::Sidekiq) && ::Sidekiq::VERSION >= MIN_SIDEKIQ_V
 
         ::Sidekiq.configure_server do |config|
-          Loggun::Config.setup_formatter(config)
+          Loggun::Config.setup_formatter(config, LoggunFormatter.new)
+        end
+      end
+
+      if defined?(::Sidekiq)
+        if ::Sidekiq::VERSION >= '6.0.0'
+          require 'loggun/modifiers/sidekiq/sidekiq6'
+        else
+          require 'loggun/modifiers/sidekiq/sidekiq4'
         end
       end
     end

data/lib/loggun/modifiers/sidekiq/sidekiq4.rb

@@ -0,0 +1,39 @@
+module Loggun
+  module Modifiers
+    class Sidekiq
+      class LoggunFormatter < ::Sidekiq::Logging::Pretty
+        def call(severity, time, _program_name, message)
+          message, loggun_type = prepared_message(message)
+          Loggun::Formatter.new.call(severity, time.utc, nil, message, loggun_type: loggun_type)
+        end
+
+        def prepared_message(message)
+          if %w[start].include?(message) || message[/^(done|fail):\s(.*)\ssec$/]
+            message, elapsed = split_msg_and_time(message)
+            loggun_type = "sidekiq.job.#{message}"
+            message = { tid: "#{Thread.current.object_id.to_s(36)}", context: context.strip }
+            message[:elapsed] = elapsed if elapsed
+          else
+            loggun_type = 'app.sidekiq.control'
+            message = { tid: Thread.current.object_id.to_s(36), message: message }
+            message.merge!(context: context) if context
+          end
+
+          [message, loggun_type]
+        end
+
+        def split_msg_and_time(message)
+          unless message[/^done:\s(.*)\ssec$/] || message[/^fail:\s(.*)\ssec$/]
+            return [message, nil]
+          end
+
+          msg_type = message[/^done:\s(.*)\ssec$/] ? 'done' : 'fail'
+
+          msg = message[/#{msg_type}:\s(.*)\ssec/] ? msg_type : message
+          elapsed = message.gsub(/#{msg_type}:\s/, '').gsub('sec', '').strip
+          [msg, elapsed]
+        end
+      end
+    end
+  end
+end

data/lib/loggun/modifiers/sidekiq/sidekiq6.rb

@@ -0,0 +1,25 @@
+module Loggun
+  module Modifiers
+    class Sidekiq
+      class LoggunFormatter < ::Sidekiq::Logger::Formatters::Base
+        def call(severity, time, _program_name, message)
+          message, loggun_type = prepared_message(message)
+          Loggun::Formatter.new.call(severity, time.utc, nil, message, loggun_type: loggun_type)
+        end
+
+        def prepared_message(message)
+          if %w[start done fail].include?(message)
+            loggun_type = "sidekiq.job.#{message}"
+            message = "#{::Sidekiq.dump_json(ctx)}"
+          else
+            loggun_type = 'app.sidekiq.control'
+            message = { tid: tid, message: message }
+            message.merge!(context: format_context) if format_context
+          end
+
+          [message, loggun_type]
+        end
+      end
+    end
+  end
+end

data/lib/loggun/version.rb

@@ -1,3 +1,3 @@
 module Loggun
-  VERSION = '0.1.1'.freeze
+  VERSION = '0.4.1'.freeze
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: loggun
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Aleksandr Noskov
 - Sergey Nesterov
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-04-06 00:00:00.000000000 Z
+date: 2020-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -134,6 +134,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -144,18 +145,20 @@ files:
 - lib/loggun/config.rb
 - lib/loggun/formatter.rb
 - lib/loggun/helpers.rb
-- lib/loggun/http_helpers.rb
 - lib/loggun/modifiers.rb
+- lib/loggun/modifiers/active_record.rb
+- lib/loggun/modifiers/active_record/loggun_log_subscriber.rb
 - lib/loggun/modifiers/base.rb
 - lib/loggun/modifiers/clockwork.rb
 - lib/loggun/modifiers/clockwork/manager.rb
 - lib/loggun/modifiers/clockwork/methods.rb
-- lib/loggun/modifiers/incoming_http.rb
 - lib/loggun/modifiers/outgoing_http.rb
 - lib/loggun/modifiers/outgoing_http/block_logger.rb
 - lib/loggun/modifiers/rails.rb
 - lib/loggun/modifiers/rails/railtie.rb
 - lib/loggun/modifiers/sidekiq.rb
+- lib/loggun/modifiers/sidekiq/sidekiq4.rb
+- lib/loggun/modifiers/sidekiq/sidekiq6.rb
 - lib/loggun/ordered_options.rb
 - lib/loggun/version.rb
 - loggun.gemspec
@@ -165,7 +168,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/funbox/loggun
   source_code_uri: https://github.com/funbox/loggun
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -181,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.6
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Loggun
 test_files: []

data/lib/loggun/http_helpers.rb

@@ -1,48 +0,0 @@
-module Loggun
-  module HttpHelpers
-    def self.included(klass)
-      klass.class_eval do
-        around_action :log_http_actions
-      end
-    end
-
-    private
-
-    def log_http_actions
-      log_action :start
-      yield
-      log_action :response
-    rescue StandardError => e
-      log_action :response, fail: e
-      raise e
-    end
-
-    def log_action(action = :start, fail: nil)
-      api = request.path[/\w+/]
-      api_version = request.path[/v./]
-      type = "http_request.#{api}.#{action}"
-      data = { path: clean_pathname }
-      data[:api_version] = api_version if api_version
-
-      return Loggun.info type, data if action == :start
-
-      success = fail.nil? && instance_exec(&modifier_config.success_condition)
-      data[:success] = success
-      unless success
-        error = instance_exec(&modifier_config.error_info)
-        data[:error] = error if error
-      end
-      Loggun.info type, data
-    end
-
-    def clean_pathname
-      filtered_params = params.to_unsafe_h
-      filtered_params.delete('action')
-      request.path.gsub(/(#{filtered_params.values.join('|')})/, '').gsub(/\/api\/v./, '')
-    end
-
-    def modifier_config
-      Loggun::Config.instance.modifiers.incoming_http
-    end
-  end
-end

data/lib/loggun/modifiers/incoming_http.rb

@@ -1,16 +0,0 @@
-module Loggun
-  module Modifiers
-    class IncomingHttp < Loggun::Modifiers::Base
-      def apply
-        return unless defined?(ActionPack)
-
-        controllers = Loggun::Config.instance.modifiers.incoming_http.controllers
-        controllers.each do |controller|
-          controller.constantize.class_eval do
-            include Loggun::HttpHelpers
-          end
-        end
-      end
-    end
-  end
-end