loggun 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a8a4d4015105e9d55b653cab3305ab2b1ddeeda0e1429bd5e2449c5841771fe
-  data.tar.gz: e6a84389338458849f87dfb2ffcdea13403537553fa547b170c4debb5901f433
+  metadata.gz: 756771ea707f7cbaafd88da80dc72afd4311702718de31a087711b258f68d47a
+  data.tar.gz: b2a00e34692488e289888c9f3d7aa433fc30f66828a160762cf2fe80aa5ea46b
 SHA512:
-  metadata.gz: f10eb810cb421dde460b1c97c777496447d22197dfdbf35bf6eae341a1b9b2a6270044135887a062882c0f8bf4ccc21efbfe3231598ee7f060ca5be220385a6f
-  data.tar.gz: 3362704777d4d6814ba58e1a72aee945d5f1f8105d03ff20930e3ecd02d559d5878f90681a77aefd14231aef67dbb79b41cd1883a5cbc6e54a8fa3817c1a49c9
+  metadata.gz: c797ff8ce8de7a5e2da28b95c9e498c1f78b827e5596f0bf1923fe87a3c5376fa5eef46c9169208225c262dc58bc846f05f4d5eefaa11ef8bd75c7e76f7ea2ee
+  data.tar.gz: 94d4d7bc950a938e82ab17b76fd4e387a169b90f16adeae8199958876847905d28ce698ee47ef4fc17d34102c3e619796cc9e8e03b27dc67b55f36ec34af5f6b

data/README.md

@@ -21,6 +21,23 @@ gem 'loggun'
     $ 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} 
+``` 
+
+Подробнее об конфигурации и использовании Loggun ниже.
 
 ### Конфигурация
 Для успешной конфигурации гема необходимо подгружать файл при инициализации вашего приложения.
@@ -42,14 +59,12 @@ end
 ```
 Все настройки являются опциональными.
 #### Настройки
-`precision` - точность отметок времени. По умолчанию - `milliseconds`. Может принимать одно из следующих значений: `sec`, `seconds`, `ms`, `millis`, `milliseconds`, `us`, `micros`, `microseconds`, `ns`, `nanos`, `nanoseconds`
-
-`pattern` - шаблон для формата вывода данных в лог. Доступные ключи: `time`, `pid`, `severity`, `type`, `tags_text`, `message`, `parent_transaction`
-
-`parent_transaction_to_message` - признак необходимости добавлять значение `parent_transaction` в тело логируемого сообщения. 
-Вне зависимости от данной настройки можно использовать ключ `parent_transaction` в шаблоне `pattern`.
-
-`modifiers` - модификаторы для переопределения формата логирования указанного компонента. См. далее.
+- `precision` - точность отметок времени. По умолчанию - `milliseconds`. Может принимать одно из следующих значений: `sec`, `seconds`, `ms`, `millis`, `milliseconds`, `us`, `micros`, `microseconds`, `ns`, `nanos`, `nanoseconds`
+- `pattern` - текстовый шаблон для формата вывода данных в лог. 
+Доступные ключи: `time`, `pid`, `severity`, `type`, `tags_text`, `message`, `parent_transaction`
+- `parent_transaction_to_message` - признак необходимости добавлять значение `parent_transaction` в тело логируемого сообщения. 
+Вне зависимости от данной настройки можно использовать ключ `parent_transaction` в шаблоне `pattern`. 
+- `modifiers` - модификаторы для переопределения формата логирования указанного компонента. См. далее.
 
 #### Модификаторы
 Каждый модифкатор может быть активирован двумя равнозначными способами:
@@ -61,16 +76,43 @@ config.modifiers.rails = true
 config.modifiers.rails.enable = true
 ```
 
-`rails` - модифицирует форматирование логгера Rails.
+##### Rails модификатор 
+`config.modifier.rails` - модифицирует форматирование логгера Rails.
 
-`sidekiq` - модифицирует форматирование логгера Sidekiq.
+##### 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}
+```
+Пример настроек:
+```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
+```
+- `log_subscriber_class_name` - имя класса, реализующего логирование sql события.
+Необходим метод `#sql`. По-умолчанию `::Loggun::Modifiers::ActiveRecord::LoggunLogSubscriber`
 
-`clockwork` - модифицирует форматирование логгера Clockwork.
+- `payload_keys` - необходимые ключи в полезной нарзуке. Используется в дефолтном классе. Доступные
+ключи: ```%i[sql name duration source]```.
 
-`outgoing_http` - добавляет логирование исходящих http запросов. 
+##### Sidekiq модификатор 
+`config.modifiers.sidekiq` - модифицирует форматирование логгера Sidekiq.
+
+##### Clockwork модификатор
+`config.modifiers.clockwork` - модифицирует форматирование логгера Clockwork.
+
+##### Модификатор исходящих HTTP запросово
+`config.modifiers.outgoing_http` - добавляет логирование исходящих http запросов. 
 На данный момент поддерживаются только запросы посредством гема `HTTP`.
 
-`incoming_http` - добавляет логирование входящих http запросов для контроллеров Rails.
+##### Модификатор входящих запросов в Rails
+ `config.modifiers.incoming_http` - добавляет логирование входящих http запросов для контроллеров Rails.
 Данный модификатор может иметь дополнительные настройки, которые устанавливаются следующим образом 
 (приведены значения по умолчанию):
 
@@ -84,15 +126,14 @@ Loggun::Config.configure do |config|
   #...
 end
 ```
+- `controllers` - массив имён базовых контроллеров, для которых необходимо добавить указанное логирование.
 
-`controllers` - массив имён базовых контроллеров, для которых необходимо добавить указанное логирование.
-
-`success_condition` - лямбда, определяющая, содержит ли успех ответ экшена. Например `-> { JSON.parse(response.body)['result'] == 'ok' }`
+- `success_condition` - лямбда, определяющая, содержит ли успех ответ экшена. Например `-> { JSON.parse(response.body)['result'] == 'ok' }`
 
-`error_info` - лямбда, позволяющая добавить в лог информацию об ошибке, содержащейся в неуспешном ответе экшена. 
+- `error_info` - лямбда, позволяющая добавить в лог информацию об ошибке, содержащейся в неуспешном ответе экшена. 
 Например `-> { JSON.parse(response.body)['error_code'] }`
 
-Для Rails 6 и выше данный модификатор может работать некорректно. 
+**Для Rails 6 и выше данный модификатор может работать некорректно.** 
 В этом случае можно указать в требуемом базовом контроллере строку:
 ```ruby
 include Loggun::HttpHelpers
@@ -100,8 +141,9 @@ include Loggun::HttpHelpers
 Это делает настройки `enable` и `controllers` модификатора безсполезными, 
 однако позволяет гарантированно логировать входящие http запросы.
 
-Настройки `success_condition` и `error_info` продолжают использоваться и могу быть установлены требуемым образом.
+Настройки `success_condition` и `error_info` продолжают использоваться и могут быть установлены требуемым образом.
 
+##### Персональные модификаторы
 Помимо указанных модификаторов существует возможность добавить собственный. 
 Необходимо уснаследовать его от `Loggun::Modifiers::Base` и указать в методе `apply` все необходимые действия.
 ```ruby
@@ -132,24 +174,35 @@ end
 class SomeClass
   include Loggun::Helpers
 
-  log_options entity_action: :method_name, as_transaction: true
+  log_options entity_action: :method_name, as_transaction: true, only: %i[download_data]
 
-  def some_action
-    log_info 'type_for_action', 'Information'
-    bar
-  end
-
-  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}
 ```
 
+**Важно**, что с хелпером 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}
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/loggun/config.rb

@@ -6,16 +6,20 @@ 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,
       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 incoming_http outgoing_http].freeze
 
     attr_accessor(
       :formatter,
@@ -55,9 +59,9 @@ module Loggun
         instance.custom_modifiers.each(&:use)
       end
 
-      def setup_formatter(app)
+      def setup_formatter(app, formatter = nil)
         Loggun.logger = app.logger
-        Loggun.logger.formatter = instance.formatter
+        Loggun.logger.formatter = formatter || instance.formatter
       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
@@ -20,7 +20,7 @@ module Loggun
       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
 

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 ||= []
 
-        modified_methods << method_name
+        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)
+
+        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?
-
-        method_name = caller_locations.first.label.split(' ').last
-        type = log_type(type, method_name)
+        next logger.send(method_name, type, &block) if args.empty? && attrs.empty?
 
-        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,20 @@ 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
+
+      log_entity_name = klass.respond_to?(:log_entity_name) ? klass.log_entity_name : underscore(klass.name)
+      type_as_arr << log_entity_name if type_as_arr.size == 1
 
       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
 
     private
@@ -163,7 +169,6 @@ module Loggun
     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

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/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/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/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/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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: loggun
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Aleksandr Noskov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-06 00:00:00.000000000 Z
+date: 2020-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -146,6 +146,8 @@ files:
 - 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
@@ -156,6 +158,8 @@ files:
 - 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