loggun 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8815d61a25fc71e36d6648e2e65fd7d6d73ebffd56e0b4631c95e589a5b9ced4
-  data.tar.gz: a6d4aea0a8971708fc3eb78eb42c50d99afb6fcbfec1e4dad5753c6552865566
+  metadata.gz: 3a78f3c782857269e283aa2f00ef6f5a2002e57c1e0d2fe5d43284a54d5aa106
+  data.tar.gz: fb9d8dad64af86d1f43c510dc34c1fd3acb9a515441315973ab0a5b72d493099
 SHA512:
-  metadata.gz: aa4ee9f1f9d4a2fe3dae09083a9554c30d28d3821a5de8230db81efeef204e36e075c79335d4e7b587ead7a20da17cdf81b695acd6f00d27c751109ea2753902
-  data.tar.gz: 52768e02e7021307b455d5c5b7e2a55cda78152e61d387a2eff6cb1878060ea9b885d09b09c6b5f3c586eb9d33a0e8b6724e2827769f98d8c241f69920d16034
+  metadata.gz: e0d93bbbe8ed26b5c5decc4d88c16876d4db185d5ae415b07fb47a23848149183e56fb0be6128f8c321410d205d19778228888f9cdb7ce57414ba29c380f22db
+  data.tar.gz: '08d78b02426b5b3da9a31b90bf3715c9728de0eaeb40ed9d5b55ccfeab76c3e241146fcdaa9f052b11ee233a40fdb07e68be5f33ff4a104467cbd08b959fe07a'

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 ниже.
 
 ### Конфигурация
 Для успешной конфигурации гема необходимо подгружать файл при инициализации вашего приложения.
@@ -32,6 +49,7 @@ 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
@@ -42,14 +60,15 @@ 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`. 
+- `message_format` - формат переменной message в шаблоне pattern. Доступны два формата: 
+  - `:json` - `message` логгируется как json строка
+  - `:key_value` - `message` логгируется в формате `key1=value1 key2=value2` 
+- `modifiers` - модификаторы для переопределения формата логирования указанного компонента. См. далее.
 
 #### Модификаторы
 Каждый модифкатор может быть активирован двумя равнозначными способами:
@@ -61,16 +80,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`
+
+- `payload_keys` - необходимые ключи в полезной нарзуке. Используется в дефолтном классе. Доступные
+ключи: ```%i[sql name duration source]```.
 
-`clockwork` - модифицирует форматирование логгера Clockwork.
+##### Sidekiq модификатор 
+`config.modifiers.sidekiq` - модифицирует форматирование логгера Sidekiq.
 
-`outgoing_http` - добавляет логирование исходящих http запросов. 
+##### Clockwork модификатор
+`config.modifiers.clockwork` - модифицирует форматирование логгера Clockwork.
+
+##### Модификатор исходящих HTTP запросово
+`config.modifiers.outgoing_http` - добавляет логирование исходящих http запросов. 
 На данный момент поддерживаются только запросы посредством гема `HTTP`.
 
-`incoming_http` - добавляет логирование входящих http запросов для контроллеров Rails.
+##### Модификатор входящих запросов в Rails
+ `config.modifiers.incoming_http` - добавляет логирование входящих http запросов для контроллеров Rails.
 Данный модификатор может иметь дополнительные настройки, которые устанавливаются следующим образом 
 (приведены значения по умолчанию):
 
@@ -84,14 +130,24 @@ 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 и выше данный модификатор может работать некорректно.** 
+В этом случае можно указать в требуемом базовом контроллере строку:
+```ruby
+include Loggun::HttpHelpers
+```
+Это делает настройки `enable` и `controllers` модификатора безсполезными, 
+однако позволяет гарантированно логировать входящие http запросы.
+
+Настройки `success_condition` и `error_info` продолжают использоваться и могут быть установлены требуемым образом.
+
+##### Персональные модификаторы
 Помимо указанных модификаторов существует возможность добавить собственный. 
 Необходимо уснаследовать его от `Loggun::Modifiers::Base` и указать в методе `apply` все необходимые действия.
 ```ruby
@@ -122,24 +178,35 @@ end
 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}
 ```
 
+**Важно**, что с хелпером 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.rb

@@ -5,6 +5,7 @@ require 'loggun/config'
 require 'loggun/modifiers'
 require 'loggun/modifiers/base'
 require 'loggun/helpers'
+require 'logger'
 
 module Loggun
   class Error < StandardError; end
@@ -12,10 +13,22 @@ module Loggun
   class << self
     include Loggun::Helpers
 
-    attr_accessor :application
+    attr_writer :logger
 
     %i[unknown fatal error warn info debug].each do |method|
       alias_method method, "log_#{method}"
     end
+
+    def logger
+      @logger ||= default_logger
+    end
+
+    private
+
+    def default_logger
+      logger = Logger.new(STDOUT)
+      logger.formatter = Config.instance.formatter
+      logger
+    end
   end
 end

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)
-        Loggun.application = app
-        Loggun.application.logger.formatter = instance.formatter
+      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 = 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

@@ -1,10 +1,11 @@
-require 'date'
+require 'time'
+require 'json'
 
 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
@@ -13,17 +14,18 @@ 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&.present? ? severity.to_s : 'INFO'
+      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
 
-      if data[:transaction_id]&.to_i != Process.pid && data[:type] != DEFAULT_VALUE
+      if data[:transaction_id] && data[:type] != DEFAULT_VALUE &&
+         data[:transaction_id].to_i != Process.pid
         data[:type] = "#{data[:type]}##{data[:transaction_id]}"
       end
 
@@ -76,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 ||= []
 
-        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 application.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 if args.present?
+        attrs[:message] = args unless args.empty?
 
-        with_type(type) do
-          application.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,30 @@ 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.respond_to?(:log_entity_name) ? klass.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,17 +178,8 @@ 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 application
-      Loggun.application
+    def logger
+      Loggun.logger
     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/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.0'.freeze
+  VERSION = '0.4.0'.freeze
 end

data/loggun.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'clockwork', '~> 2.0'
   spec.add_development_dependency 'http', '~> 4.0'
   spec.add_development_dependency 'rails', '~> 6.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rspec-rails', '~> 3.0'
   spec.add_development_dependency 'sidekiq', '~> 6.0'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: loggun
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Aleksandr Noskov
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-29 00:00:00.000000000 Z
+date: 2020-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,14 +73,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -145,17 +145,19 @@ files:
 - lib/loggun/formatter.rb
 - lib/loggun/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/incoming_http/log_http_actions.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

data/lib/loggun/modifiers/incoming_http.rb

@@ -1,19 +0,0 @@
-require_relative 'incoming_http/log_http_actions'
-
-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 LogHttpActions
-            around_action :log_http_actions
-          end
-        end
-      end
-    end
-  end
-end

data/lib/loggun/modifiers/incoming_http/log_http_actions.rb

@@ -1,36 +0,0 @@
-module LogHttpActions
-
-  private
-
-  def log_http_actions
-    log_action :start
-    yield
-    log_action :response
-  end
-
-  def log_action(action = :start)
-    api = request.path[/\w+/]
-    api_version = request.path[/v./]
-    type = "http_request.#{api}.#{action}"
-    data = { path: clean_pathname, api_version: api_version }
-    return Loggun.info type, data if action == :start
-
-    success = 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