minato_logger 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 118dfb3dc19a91b17e9e1ad4f824b4009c0f43be96d9df4ee0274bb40d7255fe
-  data.tar.gz: 5e1aa0d126e91c911b3538172661cc35dea2b5488335405026810fd8ccb8d560
+  metadata.gz: beb2a53745858a930802bf198ac1214e6015772f5b0d93b3448d4a85d7ad351f
+  data.tar.gz: 74c17c9525de490e4d2ce3dfeab74a82fa9dc26cf90216ef22c7eefaf12eb34f
 SHA512:
-  metadata.gz: 3ba8c7e7570370e5b0c54f926b84f631504491945ef6e72b57f0dc6150c2c9a28df8b45db5110f42b45b535d8c5db71fe3ad6601b5522e05b4f09f516117e079
-  data.tar.gz: 0a815bde56e438a84fe95a9398d0bd186070ef2aa1d17c3cb34ac4cf9be6e0c598fc2d129ca11e18838fd6dce6d93f313fbbbc99e917b793b567a8ee5c66c316
+  metadata.gz: 246404fe6ed3d1e2fa3e312e70a07287606b187e568fd177db702038705f7271cfab4c20cab4b7aa99fa23067141f672791682125e600bc7179b53d24ca0b689
+  data.tar.gz: f9fe0c1a5e827c150a1b8223c52bc399f094375c7d533d9bc25d5f13f47063ae3aec98e9db85b93015f17eb4eccaa20e7bf4129dd8683fbbff89b7662a6f134f

data/.rubocop.yml

@@ -8,7 +8,7 @@ AllCops:
 
 Style/StringLiterals:
   Enabled: true
-  EnforcedStyle: double_quotes
+  EnforcedStyle: single_quotes
 
 Style/StringLiteralsInInterpolation:
   Enabled: true
@@ -18,4 +18,7 @@ Style/Documentation:
   Enabled: false
 
 Layout/LineLength:
-  Max: 120
+  Max: 125
+
+Metrics/ClassLength:
+  Max: 150

data/Rakefile

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 
-require "rubocop/rake_task"
+require 'rubocop/rake_task'
 
 RuboCop::RakeTask.new
 

data/lib/minato_logger/configuration.rb

@@ -2,10 +2,16 @@
 
 module MinatoLogger
   class Configuration
-    attr_reader :middleware
+    attr_reader :middleware, :route_blacklist, :sensitive_headers
 
     def initialize
       @middleware = MinatoLogger::Middleware.new
+      @route_blacklist = %w[/health/alive /health/ready]
+      @sensitive_headers = %w[
+        AUTHORIZATION PROXY_AUTHORIZATION X_CSRF_TOKEN
+        HTTP_AUTHORIZATION HTTP_PROXY_AUTHORIZATION
+        HTTP_X_CSRF_TOKEN COOKIE HTTP_COOKIE
+      ]
 
       yield(self) if block_given?
     end

data/lib/minato_logger/context.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module MinatoLogger
+  def self.context
+    Thread.current[:minato_logger_context] ||= {}
+  end
+
+  def self.with_context(attrs)
+    context.merge!(attrs)
+    yield
+  ensure
+    attrs.each_key { |k| context.delete(k) }
+  end
+end

data/lib/minato_logger/engine.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'rails'
+require_relative 'middlewares/request_response_logger'
+require_relative 'middlewares/request_context_enricher'
+require_relative 'configuration'
+require 'rails/rack/logger'
+
+module MinatoLogger
+  class Engine < ::Rails::Engine
+    isolate_namespace MinatoLogger
+
+    initializer 'minato_logger.add_middleware' do |app|
+      app.config.minato_logger = MinatoLogger::Configuration.default
+      app.config.log_formatter = MinatoLogger::Formatters::FluentBit.new
+      app.config.colorize_logging = false if Rails.env.production?
+      if defined? Minato::Trace::Middleware::IntegrateWithCloudLogging
+        app.config.minato_logger.middleware.use Minato::Trace::Middleware::IntegrateWithCloudLogging
+      end
+      app.config.minato_logger.middleware.use MinatoLogger::Middlewares::RequestContextEnricher
+      Rails.application.config.middleware.swap(
+        Rails::Rack::Logger,
+        MinatoLogger::Middlewares::RequestResponseLogger,
+        []
+      )
+    end
+  end
+end

data/lib/minato_logger/formatters/base_formatter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support"
+require 'active_support'
 
 module MinatoLogger
   module Formatters

data/lib/minato_logger/formatters/fluent_bit.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "json"
+require 'json'
 
 module MinatoLogger
   module Formatters
@@ -18,7 +18,7 @@ module MinatoLogger
       private
 
       def sanitize_hash(hash)
-        hash.transform_keys! { |key| key.to_s.encode("UTF-8", invalid: :replace, undef: :replace, replace: "?") }
+        hash.transform_keys! { |key| key.to_s.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?') }
         hash.transform_values! do |value|
           sanitize_hash_value(value)
         end
@@ -27,11 +27,11 @@ module MinatoLogger
       def sanitize_hash_value(value)
         case value
         when String
-          value.encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+          value.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
         when Hash
           sanitize_hash(value)
         when Array
-          value.map { |v| v.is_a?(String) ? v.encode("UTF-8", invalid: :replace, undef: :replace, replace: "?") : v }
+          value.map { |v| v.is_a?(String) ? v.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?') : v }
         else
           value
         end
@@ -46,18 +46,20 @@ module MinatoLogger
       end
 
       def add_message_to_logs(log, message)
-        return log.merge(message) unless message.is_a? String
+        ruby_version = { ruby_version: RUBY_VERSION }
+        return log.merge(message, ruby_version) unless message.is_a? String
 
-        log.merge({ message: message, ruby_version: RUBY_VERSION })
+        log.merge({ message: message }, ruby_version)
       end
 
       def add_tags_to_message(msg)
         return msg unless tags_text.present?
 
         if msg.is_a?(Hash)
-          msg["message"] = "#{tags_text} #{msg["message"]}"
+          msg = msg.transform_keys(&:to_s)
+          msg['message'] = "#{tags_text}#{msg["message"]}"
         else
-          msg = "#{tags_text} #{msg}"
+          msg = "#{tags_text}#{msg}"
         end
 
         msg

data/lib/minato_logger/formatters.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "minato_logger/formatters/base_formatter"
-require "minato_logger/formatters/fluent_bit"
+require 'minato_logger/formatters/base_formatter'
+require 'minato_logger/formatters/fluent_bit'
 
 module MinatoLogger
   module Formatters

data/lib/minato_logger/logger.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require "active_support/logger"
-require "active_support/tagged_logging"
+require 'active_support/logger'
+require 'active_support/tagged_logging'
 
-require_relative "formatters/fluent_bit"
+require_relative 'formatters/fluent_bit'
 
 module MinatoLogger
   class Logger < ActiveSupport::Logger
     include ActiveSupport::TaggedLogging
 
-    def initialize
-      super($stdout)
+    def initialize(out = nil)
+      super(out || $stdout)
       @formatter = Formatters::FluentBit.new
     end
   end

data/lib/minato_logger/middlewares/request_context_enricher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MinatoLogger
+  module Middlewares
+    class RequestContextEnricher
+      CONTEXT_FIELDS = %i[session_id page_url user_id calling_service].freeze
+
+      def call(log)
+        return log unless log.is_a?(Hash)
+
+        CONTEXT_FIELDS.each do |field|
+          value = MinatoLogger.context[field]
+          log[field] = value if value
+        end
+
+        log
+      end
+    end
+  end
+end

data/lib/minato_logger/middlewares/request_response_logger.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rails/rack/logger'
+
+module MinatoLogger
+  module Middlewares
+    class RequestResponseLogger < Rails::Rack::Logger
+      private
+
+      def call_app(request, env)
+        hdrs = extract_request_headers(request)
+        attrs = { session_id: hdrs['X_SESSION_ID'], page_url: hdrs['X_PAGE_URL'],
+                  calling_service: hdrs['X_SERVICE_NAME'] }.compact
+        MinatoLogger.with_context(attrs) { process_with_logging(request, env) }
+      end
+
+      def process_with_logging(request, env)
+        should_log = should_log?(request)
+        ctx = {}
+        ctx[:request] = build_request_context_base(request) if should_log
+        log_request(request, env, ctx) if should_log
+        handle = dispatch_request_event(request)
+        status, headers, rack_body, log_body = process_request(env)
+        ctx[:response] = { status: status, headers: headers, body: log_body } if should_log
+        log_response(request, env, ctx) if should_log
+        finish_request_instrumentation(handle, env['rails.rack_logger_tag_count'])
+        [status, headers, rack_body]
+      end
+
+      def compute_tags(request)
+        tags_to_use = @taggers.presence || Rails.application.config.log_tags || []
+        tags_to_use.collect do |tag|
+          next tag.call(request) if tag.is_a?(Proc)
+          next request.send(tag) if tag.is_a?(Symbol)
+
+          tag
+        end
+      end
+
+      def build_request_context_base(request)
+        { start_time: current_time, headers: extract_request_headers(request),
+          body: extract_request_body(request) }
+      end
+
+      def should_log?(request)
+        blacklist = Rails.application.config.minato_logger.route_blacklist || []
+        blacklist.none? do |item|
+          next item.call(request) if item.is_a?(Proc)
+
+          request.path == item
+        end
+      end
+
+      def process_request(env)
+        status, headers, response = @app.call(env)
+        content_type = headers['Content-Type'].to_s
+
+        if content_type.include?('application/json') || content_type.include?('text/')
+          body_str = extract_body_safely(response || [])
+          [status, headers, [body_str], body_str]
+        else
+          [status, headers, response, "[Binary or Stream Response: #{content_type}]"]
+        end
+      end
+
+      def dispatch_request_event(request)
+        instrumenter = ActiveSupport::Notifications.instrumenter
+        handle = instrumenter.build_handle('request.action_dispatch', { request: request })
+        handle.start
+        handle
+      end
+
+      def log_request(request, env, ctx)
+        payload = { type: 'REQUEST', message: "Receiving request #{request.method} #{request.fullpath}" }
+        payload.merge!(default_log_data(request, env, ctx))
+        log(payload)
+      end
+
+      def log_response(request, env, ctx)
+        ctx[:response][:duration] = ((current_time - ctx.dig(:request, :start_time)) * 1000).round(2)
+        payload = build_response_payload(request, env, ctx)
+        log_level = ctx.dig(:response, :status) >= 500 ? :error : :info
+        log(payload, log_level)
+      end
+
+      def default_log_data(request, env, ctx)
+        route = env['action_dispatch.route_uri_pattern'] || request.path
+        request = { id: request.request_id, method: request.method,
+                    time: Time.zone.now.iso8601, remote_ip: request.remote_ip, route: route, ip: request.ip,
+                    path: request.fullpath, params: filter_params(request), headers: ctx.dig(:request, :headers),
+                    body: ctx.dig(:request, :body) }
+        { rails_version: Rails.version, request: request }
+      end
+
+      def build_response_payload(request, env, ctx)
+        response = { body: safe_parse_json(ctx.dig(:response, :body)),
+                     headers: filter_sensitive_headers(ctx.dig(:response, :headers)),
+                     status: ctx.dig(:response, :status), duration: ctx.dig(:response, :duration) }
+        payload = { type: 'RESPONSE',  response: response,
+                    message: "Responding #{request.method} #{request.fullpath} " \
+                             "- #{ctx.dig(:response, :status)} (#{ctx.dig(:response, :duration)}ms)" }
+        default_log_data(request, env, ctx).merge(payload)
+      end
+
+      def log(payload, level = :info)
+        Rails.logger.public_send(level, payload)
+      rescue StandardError => e
+        Rails.logger.error({ message: "Logger Error: #{e.message}", payload: payload })
+      end
+
+      def extract_body_safely(response)
+        body = []
+        response.each { |part| body << part.to_s } if response.respond_to?(:each)
+        response.close if response.respond_to?(:close)
+        body.join
+      end
+
+      def filter_params(request)
+        request.filtered_parameters.except(:controller, :action, :format)
+      rescue StandardError
+        {}
+      end
+
+      def safe_parse_json(body)
+        return nil if body.blank?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        body.to_s
+      end
+
+      def extract_request_body(request)
+        return nil unless request.body
+        return '[Multipart Form Data / File Upload]' if request.content_type.to_s.include?('multipart/form-data')
+
+        body = request.raw_post
+        return nil if body.blank?
+
+        request.body.rewind if request.body.respond_to?(:rewind)
+        safe_parse_json(body)
+      rescue StandardError => e
+        "Error reading request body: #{e}"
+      end
+
+      def extract_request_headers(request)
+        headers = {}
+        request.headers.each do |k, v|
+          next unless k.start_with?('HTTP_') || %w[CONTENT_TYPE CONTENT_LENGTH].include?(k)
+
+          normalized_key = k.start_with?('HTTP_') ? k[5..] : k
+
+          headers[normalized_key] = v
+        end
+
+        filter_sensitive_headers(headers)
+      end
+
+      def current_time
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def filter_sensitive_headers(headers)
+        return {} unless headers.is_a?(Hash)
+
+        headers.reject do |k, _|
+          key = k.to_s.upcase.tr('-', '_')
+          Rails.application.config.minato_logger.sensitive_headers.any? { |sensitive| key.include?(sensitive) }
+        end
+      end
+
+      def finish_request_instrumentation(handle, payload)
+        if defined?(super)
+          super
+        elsif handle
+          handle.finish
+        end
+      end
+    end
+  end
+end

data/lib/minato_logger/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MinatoLogger
-  VERSION = "0.3.2"
+  VERSION = '0.4.0'
 end

data/lib/minato_logger.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require "minato_logger/version"
-require "minato_logger/middleware"
-require "minato_logger/configuration"
-require "minato_logger/formatters"
-require "minato_logger/logger"
-require "minato_logger/rails" if defined? Rails::Railtie
+require 'minato_logger/version'
+require 'minato_logger/middleware'
+require 'minato_logger/configuration'
+require 'minato_logger/context'
+require 'minato_logger/formatters'
+require 'minato_logger/logger'
+require 'minato_logger/engine'
 
 module MinatoLogger
   class << self

data/minato_logger.gemspec

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
-require_relative "lib/minato_logger/version"
+require_relative 'lib/minato_logger/version'
 
 Gem::Specification.new do |spec|
-  spec.name = "minato_logger"
+  spec.name = 'minato_logger'
   spec.version = MinatoLogger::VERSION
-  spec.authors = ["Ferreri"]
-  spec.email = ["contato@ferreri.co"]
+  spec.authors = ['Ferreri']
+  spec.email = ['contato@ferreri.co']
 
-  spec.summary = "Log enhancements for Minato Rails Apps."
-  spec.homepage = "https://gitlab.com/ferreri/minato/minato-logger-rails"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
+  spec.summary = 'Log enhancements for Minato Rails Apps.'
+  spec.homepage = 'https://gitlab.com/ferreri/minato/minato-logger-rails'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.6.0'
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://gitlab.com/ferreri/minato/minato-logger-rails"
-  spec.metadata["changelog_uri"] = "https://gitlab.com/ferreri/minato/minato-logger-rails/-/blob/main/CHANGELOG.md?ref_type=heads"
-  spec.metadata["rubygems_mfa_required"] = "true"
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://gitlab.com/ferreri/minato/minato-logger-rails'
+  spec.metadata['changelog_uri'] = 'https://gitlab.com/ferreri/minato/minato-logger-rails/-/blob/main/CHANGELOG.md?ref_type=heads'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -26,11 +26,10 @@ Gem::Specification.new do |spec|
         f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
     end
   end
-  spec.bindir = "exe"
+  spec.bindir = 'exe'
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_dependency "activesupport", "~> 8.0.2"
-  spec.add_dependency "lograge", ">= 0.14.0"
-  spec.add_dependency "rails", ">= 8.0.0"
+  spec.add_dependency 'activesupport', '>= 7.0.0'
+  spec.add_dependency 'rails', '>= 7.0.0'
 end

metadata

@@ -1,57 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: minato_logger
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Ferreri
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-03 00:00:00.000000000 Z
+date: 2026-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 8.0.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 8.0.2
-- !ruby/object:Gem::Dependency
-  name: lograge
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 7.0.0
 description:
 email:
 - contato@ferreri.co
@@ -71,12 +57,15 @@ files:
 - compose.yml
 - lib/minato_logger.rb
 - lib/minato_logger/configuration.rb
+- lib/minato_logger/context.rb
+- lib/minato_logger/engine.rb
 - lib/minato_logger/formatters.rb
 - lib/minato_logger/formatters/base_formatter.rb
 - lib/minato_logger/formatters/fluent_bit.rb
 - lib/minato_logger/logger.rb
 - lib/minato_logger/middleware.rb
-- lib/minato_logger/rails.rb
+- lib/minato_logger/middlewares/request_context_enricher.rb
+- lib/minato_logger/middlewares/request_response_logger.rb
 - lib/minato_logger/version.rb
 - minato_logger.gemspec
 - sig/minato_logger.rbs

data/lib/minato_logger/rails.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "lograge"
-
-module MinatoLogger
-  class Railtie < ::Rails::Railtie
-    config.minato_logger = MinatoLogger::Configuration.default
-
-    config.after_initialize do |app|
-      app.config.colorize_logging = false if Rails.env.production?
-
-      if defined? Minato::Trace::Middleware::IntegrateWithCloudLogging
-        app.config.minato_logger.middleware.use Minato::Trace::Middleware::IntegrateWithCloudLogging
-      end
-    end
-
-    config.lograge.enabled = true
-
-    config.lograge.formatter = Lograge::Formatters::Raw.new
-
-    config.lograge.base_controller_class = "ActionController::API"
-
-    config.lograge.custom_options = lambda do |event|
-      {
-        time: Time.zone.now.iso8601,
-        params: event.payload[:params],
-        response: event.payload[:response_body],
-        exception: event.payload[:exception],
-        exception_object: event.payload[:exception_object],
-        request_id: event.payload[:request_id],
-        user_id: event.payload[:user_id],
-        remote_ip: event.payload[:remote_ip]
-      }
-    end
-
-    ActiveSupport::Notifications.subscribe(
-      "process_action.action_controller"
-    ) do |_name, _started, _finished, _unique_id, payload|
-      response = payload[:response]
-
-      payload[:response_body] = begin
-        JSON.parse(response.body)
-      rescue StandardError
-        response.body
-      end
-    end
-  end
-end