super-pure-pkg 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 384fa284408b5105c65bfbc1e371040eddcffa16afb88bfb2f16cd2311f9ba3d
+  data.tar.gz: 54b232e0493e0142a1054ced155c9d94f94e1d36822af1a7be2d597e23ae8857
+SHA512:
+  metadata.gz: 2a3a79bf422d4d069d68f427c12697c9763cf206c6559e5272d5119e9a7750f14550adb142a4ce2a4f132591ba67b79d851dd974ff2615c727f9b3dab3fc7218
+  data.tar.gz: 42db663616cb18ec8b6e750acf83e1c4dc6e1c91fdea7aac9b8c926afd602b65ff9dd55b37ab3e6bd15dc4a6f8b647822d51e18c1d52aa20f54fb4486605f7b7

data/lograge-0.14.0/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Mathias Meyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lograge-0.14.0/lib/lograge/formatters/cee.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lograge
+  module Formatters
+    class Cee
+      def call(data)
+        "@cee: #{JSON.dump(data)}"
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/formatters/graylog2.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lograge
+  module Formatters
+    class Graylog2
+      include Lograge::Formatters::Helpers::MethodAndPath
+
+      def call(data)
+        # Add underscore to every key to follow GELF additional field syntax.
+        data.transform_keys { |k| underscore_prefix(k) }.merge(
+          short_message: short_message(data)
+        )
+      end
+
+      def underscore_prefix(key)
+        "_#{key}".to_sym
+      end
+
+      def short_message(data)
+        "[#{data[:status]}]#{method_and_path_string(data)}(#{data[:controller]}##{data[:action]})"
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/formatters/helpers/method_and_path.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lograge
+  module Formatters
+    module Helpers
+      module MethodAndPath
+        def method_and_path_string(data)
+          method_and_path = [data[:method], data[:path]].compact
+          method_and_path.any?(&:present?) ? " #{method_and_path.join(' ')} " : ' '
+        end
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/formatters/json.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'json'
+module Lograge
+  module Formatters
+    class Json
+      def call(data)
+        ::JSON.dump(data)
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/formatters/key_value.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lograge
+  module Formatters
+    class KeyValue
+      def call(data)
+        fields_to_display(data)
+          .map { |key| format(key, data[key]) }
+          .join(' ')
+      end
+
+      protected
+
+      def fields_to_display(data)
+        data.keys
+      end
+
+      def format(key, value)
+        "#{key}=#{parse_value(key, value)}"
+      end
+
+      def parse_value(key, value)
+        # Exactly preserve the previous output
+        # Parsing this can be ambigious if the error messages contains
+        # a single quote
+        return "'#{value}'" if key == :error
+        return Kernel.format('%.2f', value) if value.is_a? Float
+
+        value
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/formatters/key_value_deep.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Lograge
+  module Formatters
+    class KeyValueDeep < KeyValue
+      def call(data)
+        super flatten_keys(data)
+      end
+
+      protected
+
+      def flatten_keys(data, prefix = '')
+        return flatten_object(data, prefix) if [Hash, Array].include? data.class
+
+        data
+      end
+
+      def flatten_object(data, prefix)
+        result = {}
+        loop_on_object(data) do |key, value|
+          key = "#{prefix}_#{key}" unless prefix.empty?
+          if [Hash, Array].include? value.class
+            result.merge!(flatten_keys(value, key))
+          else
+            result[key] = value
+          end
+        end
+        result
+      end
+
+      def loop_on_object(data, &block)
+        if data.instance_of? Array
+          data.each_with_index do |value, index|
+            yield index, value
+          end
+          return
+        end
+        data.each(&block)
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/formatters/l2met.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'lograge/formatters/key_value'
+
+module Lograge
+  module Formatters
+    class L2met < KeyValue
+      L2MET_FIELDS = %i[
+        method
+        path
+        format
+        source
+        status
+        error
+        duration
+        view
+        db
+        location
+      ].freeze
+
+      UNWANTED_FIELDS = %i[
+        controller
+        action
+      ].freeze
+
+      def call(data)
+        super(modify_payload(data))
+      end
+
+      protected
+
+      def fields_to_display(data)
+        L2MET_FIELDS + additional_fields(data)
+      end
+
+      def additional_fields(data)
+        (data.keys - L2MET_FIELDS) - UNWANTED_FIELDS
+      end
+
+      def format(key, value)
+        key = "measure#page.#{key}" if value.is_a?(Float)
+
+        super(key, value)
+      end
+
+      def modify_payload(data)
+        data[:source] = source_field(data) if data[:controller] && data[:action]
+
+        data
+      end
+
+      def source_field(data)
+        "#{data[:controller].to_s.tr('/', '-')}:#{data[:action]}"
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/formatters/lines.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lograge
+  module Formatters
+    class Lines
+      def call(data)
+        load_dependencies
+
+        ::Lines.dump(data)
+      end
+
+      def load_dependencies
+        require 'lines'
+      rescue LoadError
+        puts 'You need to install the lines gem to use this output.'
+        raise
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/formatters/logstash.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Lograge
+  module Formatters
+    class Logstash
+      include Lograge::Formatters::Helpers::MethodAndPath
+
+      def call(data)
+        load_dependencies
+        event = LogStash::Event.new(data)
+
+        event['message'] = "[#{data[:status]}]#{method_and_path_string(data)}(#{data[:controller]}##{data[:action]})"
+        event.to_json
+      end
+
+      def load_dependencies
+        require 'logstash-event'
+      rescue LoadError
+        puts 'You need to install the logstash-event gem to use the logstash output.'
+        raise
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/formatters/ltsv.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lograge
+  module Formatters
+    class LTSV
+      def call(data)
+        fields = fields_to_display(data)
+
+        event = fields.map { |key| format(key, data[key]) }
+        event.join("\t")
+      end
+
+      def fields_to_display(data)
+        data.keys
+      end
+
+      def format(key, value)
+        if key == :error
+          # Exactly preserve the previous output
+          # Parsing this can be ambigious if the error messages contains
+          # a single quote
+          value = "'#{escape value}'"
+        elsif value.is_a? Float
+          value = Kernel.format('%.2f', value)
+        end
+
+        "#{key}:#{value}"
+      end
+
+      private
+
+      def escape(string)
+        value = string.is_a?(String) ? string.dup : string.to_s
+
+        value.gsub!('\\', '\\\\')
+        value.gsub!('\n', '\\n')
+        value.gsub!('\r', '\\r')
+        value.gsub!('\t', '\\t')
+
+        value
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/formatters/raw.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lograge
+  module Formatters
+    class Raw
+      def call(data)
+        data
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/log_subscribers/action_cable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Lograge
+  module LogSubscribers
+    class ActionCable < Base
+      %i[perform_action subscribe unsubscribe connect disconnect].each do |method_name|
+        define_method(method_name) do |event|
+          process_main_event(event)
+        end
+      end
+
+      private
+
+      def initial_data(payload)
+        {
+          method: nil,
+          path: nil,
+          format: nil,
+          params: payload[:data],
+          controller: payload[:channel_class] || payload[:connection_class],
+          action: payload[:action]
+        }
+      end
+
+      def default_status
+        200
+      end
+
+      def extract_runtimes(event, _payload)
+        { duration: event.duration.to_f.round(2) }
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/log_subscribers/action_controller.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Lograge
+  module LogSubscribers
+    class ActionController < Base
+      def process_action(event)
+        process_main_event(event)
+      end
+
+      def redirect_to(event)
+        RequestStore.store[:lograge_location] = event.payload[:location]
+      end
+
+      def unpermitted_parameters(event)
+        RequestStore.store[:lograge_unpermitted_params] ||= []
+        RequestStore.store[:lograge_unpermitted_params].concat(event.payload[:keys])
+      end
+
+      private
+
+      def initial_data(payload)
+        {
+          method: payload[:method],
+          path: extract_path(payload),
+          format: extract_format(payload),
+          controller: payload[:controller],
+          action: payload[:action]
+        }
+      end
+
+      def extract_path(payload)
+        path = payload[:path]
+        strip_query_string(path)
+      end
+
+      def strip_query_string(path)
+        index = path.index('?')
+        index ? path[0, index] : path
+      end
+
+      if ::ActionPack::VERSION::MAJOR == 3 && ::ActionPack::VERSION::MINOR.zero?
+        def extract_format(payload)
+          payload[:formats].first
+        end
+      else
+        def extract_format(payload)
+          payload[:format]
+        end
+      end
+
+      def extract_runtimes(event, payload)
+        data = { duration: event.duration.to_f.round(2) }
+        data[:view] = payload[:view_runtime].to_f.round(2) if payload.key?(:view_runtime)
+        data[:db] = payload[:db_runtime].to_f.round(2) if payload.key?(:db_runtime)
+        data
+      end
+
+      def extract_location
+        location = RequestStore.store[:lograge_location]
+        return {} unless location
+
+        RequestStore.store[:lograge_location] = nil
+        { location: strip_query_string(location) }
+      end
+
+      def extract_unpermitted_params
+        unpermitted_params = RequestStore.store[:lograge_unpermitted_params]
+        return {} unless unpermitted_params
+
+        RequestStore.store[:lograge_unpermitted_params] = nil
+        { unpermitted_params: unpermitted_params }
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/log_subscribers/base.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'action_pack'
+require 'active_support'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/log_subscriber'
+require 'request_store'
+
+module Lograge
+  module LogSubscribers
+    class Base < ActiveSupport::LogSubscriber
+      def logger
+        Lograge.logger.presence || super
+      end
+
+      private
+
+      def process_main_event(event)
+        return if Lograge.ignore?(event)
+
+        payload = event.payload
+        data = extract_request(event, payload)
+        data = before_format(data, payload)
+        formatted_message = Lograge.formatter.call(data)
+        logger.send(Lograge.log_level, formatted_message)
+      end
+
+      def extract_request(event, payload)
+        data = initial_data(payload)
+        data.merge!(extract_status(payload))
+        data.merge!(extract_allocations(event))
+        data.merge!(extract_runtimes(event, payload))
+        data.merge!(extract_location)
+        data.merge!(extract_unpermitted_params)
+        data.merge!(custom_options(event))
+      end
+
+      %i[initial_data extract_status extract_runtimes
+         extract_location extract_unpermitted_params].each do |method_name|
+        define_method(method_name) { |*_arg| {} }
+      end
+
+      def extract_status(payload)
+        if (status = payload[:status])
+          { status: status.to_i }
+        elsif (error = payload[:exception])
+          exception, message = error
+          { status: get_error_status_code(exception), error: "#{exception}: #{message}" }
+        else
+          { status: default_status }
+        end
+      end
+
+      def default_status
+        0
+      end
+
+      def get_error_status_code(exception_class_name)
+        ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
+      end
+
+      def extract_allocations(event)
+        if (allocations = (event.respond_to?(:allocations) && event.allocations))
+          { allocations: allocations }
+        else
+          {}
+        end
+      end
+
+      def custom_options(event)
+        options = Lograge.custom_options(event) || {}
+        options.merge event.payload[:custom_payload] || {}
+      end
+
+      def before_format(data, payload)
+        Lograge.before_format(data, payload)
+      end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/ordered_options.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/ordered_options'
+
+module Lograge
+  class OrderedOptions < ActiveSupport::OrderedOptions
+    def custom_payload(&block)
+      self.custom_payload_method = block
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/rails_ext/action_cable/channel/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Lograge
+  module ActionCable
+    module ChannelInstrumentation
+      def subscribe_to_channel
+        ActiveSupport::Notifications.instrument('subscribe.action_cable', notification_payload('subscribe')) { super }
+      end
+
+      def unsubscribe_from_channel
+        ActiveSupport::Notifications.instrument('unsubscribe.action_cable', notification_payload('unsubscribe')) do
+          super
+        end
+      end
+
+      private
+
+      def notification_payload(method_name)
+        { channel_class: self.class.name, action: method_name }
+      end
+    end
+  end
+end
+
+ActionCable::Channel::Base.prepend(Lograge::ActionCable::ChannelInstrumentation)

data/lograge-0.14.0/lib/lograge/rails_ext/action_cable/connection/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lograge
+  module ActionCable
+    module ConnectionInstrumentation
+      def handle_open
+        ActiveSupport::Notifications.instrument('connect.action_cable', notification_payload('connect')) { super }
+      end
+
+      def handle_close
+        ActiveSupport::Notifications.instrument('disconnect.action_cable', notification_payload('disconnect')) { super }
+      end
+
+      def notification_payload(method_name)
+        { connection_class: self.class.name, action: method_name, data: request.params }
+      end
+    end
+  end
+end
+
+ActionCable::Connection::Base.prepend(Lograge::ActionCable::ConnectionInstrumentation)

data/lograge-0.14.0/lib/lograge/rails_ext/action_cable/server/base.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ActionCable
+  module Server
+    class Base
+      mattr_accessor :logger
+      self.logger = Lograge::SilentLogger.new(config.logger)
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/rails_ext/rack/logger.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/concern'
+require 'rails/rack/logger'
+
+module Rails
+  module Rack
+    # Overwrites defaults of Rails::Rack::Logger that cause
+    # unnecessary logging.
+    # This effectively removes the log lines from the log
+    # that say:
+    # Started GET / for 192.168.2.1...
+    class Logger
+      # Overwrites Rails code that logs new requests
+      def call_app(*args)
+        env = args.last
+        status, headers, body = @app.call(env)
+        # needs to have same return type as the Rails builtins being overridden, see https://github.com/roidrage/lograge/pull/333
+        # https://github.com/rails/rails/blob/be9d34b9bcb448b265114ebc28bef1a5b5e4c272/railties/lib/rails/rack/logger.rb#L37
+        [status, headers, ::Rack::BodyProxy.new(body) {}] # rubocop:disable Lint/EmptyBlock
+      ensure
+        ActiveSupport::LogSubscriber.flush_all!
+      end
+
+      # Overwrites Rails 3.0/3.1 code that logs new requests
+      def before_dispatch(_env); end
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/railtie.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+require 'action_view/log_subscriber'
+require 'action_controller/log_subscriber'
+
+module Lograge
+  class Railtie < Rails::Railtie
+    config.lograge = Lograge::OrderedOptions.new
+    config.lograge.enabled = false
+
+    initializer :deprecator do |app|
+      app.deprecators[:lograge] = Lograge.deprecator if app.respond_to?(:deprecators)
+    end
+
+    config.after_initialize do |app|
+      Lograge.setup(app) if app.config.lograge.enabled
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/silent_logger.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Lograge
+  class SilentLogger < SimpleDelegator
+    %i[debug info warn error fatal unknown].each do |method_name|
+      # rubocop:disable Lint/EmptyBlock
+      define_method(method_name) { |*_args| }
+      # rubocop:enable Lint/EmptyBlock
+    end
+  end
+end

data/lograge-0.14.0/lib/lograge/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Lograge
+  VERSION = '0.14.0'
+end

data/lograge-0.14.0/lib/lograge.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require 'lograge/version'
+require 'lograge/formatters/helpers/method_and_path'
+require 'lograge/formatters/cee'
+require 'lograge/formatters/json'
+require 'lograge/formatters/graylog2'
+require 'lograge/formatters/key_value'
+require 'lograge/formatters/key_value_deep'
+require 'lograge/formatters/l2met'
+require 'lograge/formatters/lines'
+require 'lograge/formatters/logstash'
+require 'lograge/formatters/ltsv'
+require 'lograge/formatters/raw'
+require 'lograge/log_subscribers/base'
+require 'lograge/log_subscribers/action_cable'
+require 'lograge/log_subscribers/action_controller'
+require 'lograge/silent_logger'
+require 'lograge/ordered_options'
+require 'active_support'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/inflections'
+
+# rubocop:disable Metrics/ModuleLength
+module Lograge
+  module_function
+
+  mattr_accessor :logger, :application, :ignore_tests
+
+  # Custom options that will be appended to log line
+  #
+  # Currently supported formats are:
+  #  - Hash
+  #  - Any object that responds to call and returns a hash
+  #
+  mattr_writer :custom_options
+  self.custom_options = nil
+
+  def custom_options(event)
+    if @@custom_options.respond_to?(:call)
+      @@custom_options.call(event)
+    else
+      @@custom_options
+    end
+  end
+
+  # Before format allows you to change the structure of the output.
+  # You've to pass in something callable
+  #
+  mattr_writer :before_format
+  self.before_format = nil
+
+  def before_format(data, payload)
+    result = nil
+    result = @@before_format.call(data, payload) if @@before_format
+    result || data
+  end
+
+  # Set conditions for events that should be ignored
+  #
+  # Currently supported formats are:
+  #  - A single string representing a controller action, e.g. 'UsersController#sign_in'
+  #  - An array of strings representing controller actions
+  #  - An object that responds to call with an event argument and returns
+  #    true iff the event should be ignored.
+  #
+  # The action ignores are given to 'ignore_actions'. The callable ignores
+  # are given to 'ignore'.  Both methods can be called multiple times, which
+  # just adds more ignore conditions to a list that is checked before logging.
+
+  def ignore_actions(actions)
+    ignore(lambda do |event|
+             params = event.payload
+             Array(actions).include?("#{controller_field(params)}##{params[:action]}")
+           end)
+  end
+
+  def controller_field(params)
+    params[:controller] || params[:channel_class] || params[:connection_class]
+  end
+
+  def ignore_tests
+    @ignore_tests ||= []
+  end
+
+  def ignore(test)
+    ignore_tests.push(test) if test
+  end
+
+  def ignore_nothing
+    @ignore_tests = []
+  end
+
+  def ignore?(event)
+    ignore_tests.any? { |ignore_test| ignore_test.call(event) }
+  end
+
+  # Loglines are emitted with this log level
+  mattr_accessor :log_level
+  self.log_level = :info
+
+  # The emitted log format
+  #
+  # Currently supported formats are>
+  #  - :lograge - The custom tense lograge format
+  #  - :logstash - JSON formatted as a Logstash Event.
+  mattr_accessor :formatter
+
+  def remove_existing_log_subscriptions
+    ActiveSupport::LogSubscriber.log_subscribers.each do |subscriber|
+      case subscriber
+      when ActionView::LogSubscriber
+        unsubscribe(:action_view, subscriber)
+      when ActionController::LogSubscriber
+        unsubscribe(:action_controller, subscriber)
+      end
+    end
+  end
+
+  def unsubscribe(component, subscriber)
+    events = subscriber.public_methods(false).reject { |method| method.to_s == 'call' }
+    events.each do |event|
+      Lograge.notification_listeners_for("#{event}.#{component}").each do |listener|
+        ActiveSupport::Notifications.unsubscribe listener if listener.instance_variable_get('@delegate') == subscriber
+      end
+    end
+  end
+
+  def setup(app)
+    self.application = app
+    disable_rack_cache_verbose_output
+    keep_original_rails_log
+
+    attach_to_action_controller
+    attach_to_action_cable if defined?(ActionCable)
+
+    set_lograge_log_options
+    setup_custom_payload
+    support_deprecated_config # TODO: Remove with version 1.0
+    set_formatter
+    set_ignores
+  end
+
+  def set_ignores
+    Lograge.ignore_actions(lograge_config.ignore_actions)
+    Lograge.ignore(lograge_config.ignore_custom)
+  end
+
+  def set_formatter
+    Lograge.formatter = lograge_config.formatter || Lograge::Formatters::KeyValue.new
+  end
+
+  def attach_to_action_controller
+    Lograge::LogSubscribers::ActionController.attach_to :action_controller
+  end
+
+  def attach_to_action_cable
+    require 'lograge/rails_ext/action_cable/channel/base'
+    require 'lograge/rails_ext/action_cable/connection/base'
+
+    Lograge::LogSubscribers::ActionCable.attach_to :action_cable
+  end
+
+  def setup_custom_payload
+    return unless lograge_config.custom_payload_method.respond_to?(:call)
+
+    base_classes = Array(lograge_config.base_controller_class)
+    base_classes.map! { |klass| klass.try(:constantize) }
+    base_classes << ActionController::Base if base_classes.empty?
+
+    base_classes.each do |base_class|
+      extend_base_class(base_class)
+    end
+  end
+
+  def extend_base_class(klass)
+    append_payload_method = klass.instance_method(:append_info_to_payload)
+    custom_payload_method = lograge_config.custom_payload_method
+
+    klass.send(:define_method, :append_info_to_payload) do |payload|
+      append_payload_method.bind(self).call(payload)
+      payload[:custom_payload] = custom_payload_method.call(self)
+    end
+  end
+
+  def set_lograge_log_options
+    Lograge.logger = lograge_config.logger
+    Lograge.custom_options = lograge_config.custom_options
+    Lograge.before_format = lograge_config.before_format
+    Lograge.log_level = lograge_config.log_level || :info
+  end
+
+  def disable_rack_cache_verbose_output
+    application.config.action_dispatch.rack_cache[:verbose] = false if rack_cache_hashlike?(application)
+  end
+
+  def keep_original_rails_log
+    return if lograge_config.keep_original_rails_log
+
+    require 'lograge/rails_ext/rack/logger'
+
+    require 'lograge/rails_ext/action_cable/server/base' if defined?(ActionCable)
+
+    Lograge.remove_existing_log_subscriptions
+  end
+
+  def rack_cache_hashlike?(app)
+    app.config.action_dispatch.rack_cache&.respond_to?(:[]=)
+  end
+  private_class_method :rack_cache_hashlike?
+
+  # TODO: Remove with version 1.0
+
+  def support_deprecated_config
+    return unless lograge_config.log_format
+
+    legacy_log_format = lograge_config.log_format
+    warning = 'config.lograge.log_format is deprecated. Use config.lograge.formatter instead.'
+    deprecator.warn(warning, caller)
+    legacy_log_format = :key_value if legacy_log_format == :lograge
+    lograge_config.formatter = "Lograge::Formatters::#{legacy_log_format.to_s.classify}".constantize.new
+  end
+
+  def lograge_config
+    application.config.lograge
+  end
+
+  def deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new('1.0', 'Lograge')
+  end
+
+  if ::ActiveSupport::VERSION::MAJOR >= 8 ||
+     (::ActiveSupport::VERSION::MAJOR >= 7 && ::ActiveSupport::VERSION::MINOR >= 1)
+    def notification_listeners_for(name)
+      ActiveSupport::Notifications.notifier.all_listeners_for(name)
+    end
+  else
+    def notification_listeners_for(name)
+      ActiveSupport::Notifications.notifier.listeners_for(name)
+    end
+  end
+end
+# rubocop:enable Metrics/ModuleLength
+
+require 'lograge/railtie' if defined?(Rails)

data/super-pure-pkg.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = "super-pure-pkg"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on lograge"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+  s.metadata    = { "source_code_uri" => "https://github.com/Andrey78/super-pure-pkg" }
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: super-pure-pkg
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey78
+bindir: bin
+cert_chain: []
+date: 2026-07-06 00:00:00.000000000 Z
+dependencies: []
+description: University research based on lograge
+email:
+- cakoc614@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lograge-0.14.0/LICENSE.txt
+- lograge-0.14.0/lib/lograge.rb
+- lograge-0.14.0/lib/lograge/formatters/cee.rb
+- lograge-0.14.0/lib/lograge/formatters/graylog2.rb
+- lograge-0.14.0/lib/lograge/formatters/helpers/method_and_path.rb
+- lograge-0.14.0/lib/lograge/formatters/json.rb
+- lograge-0.14.0/lib/lograge/formatters/key_value.rb
+- lograge-0.14.0/lib/lograge/formatters/key_value_deep.rb
+- lograge-0.14.0/lib/lograge/formatters/l2met.rb
+- lograge-0.14.0/lib/lograge/formatters/lines.rb
+- lograge-0.14.0/lib/lograge/formatters/logstash.rb
+- lograge-0.14.0/lib/lograge/formatters/ltsv.rb
+- lograge-0.14.0/lib/lograge/formatters/raw.rb
+- lograge-0.14.0/lib/lograge/log_subscribers/action_cable.rb
+- lograge-0.14.0/lib/lograge/log_subscribers/action_controller.rb
+- lograge-0.14.0/lib/lograge/log_subscribers/base.rb
+- lograge-0.14.0/lib/lograge/ordered_options.rb
+- lograge-0.14.0/lib/lograge/rails_ext/action_cable/channel/base.rb
+- lograge-0.14.0/lib/lograge/rails_ext/action_cable/connection/base.rb
+- lograge-0.14.0/lib/lograge/rails_ext/action_cable/server/base.rb
+- lograge-0.14.0/lib/lograge/rails_ext/rack/logger.rb
+- lograge-0.14.0/lib/lograge/railtie.rb
+- lograge-0.14.0/lib/lograge/silent_logger.rb
+- lograge-0.14.0/lib/lograge/version.rb
+- super-pure-pkg.gemspec
+homepage: https://rubygems.org/profiles/Andrey78
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Andrey78/super-pure-pkg
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Research test
+test_files: []