minato_logger 0.2.19 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f523fd2c4e6ebb0bc2ef9cad19a5e0a0f48f29e4f27ff81b98bce11a848ed768
-  data.tar.gz: 0e2c98f92018bd6cdc91eb7b8e60fec03e6e34d28d4e4afdca7f54e09c853115
+  metadata.gz: 06f80153de91decba9f1d6a522d0b1e4d9b960ad25e73c233a0bc72631d86a18
+  data.tar.gz: 68ea47ede5ecb8d9c2dafa98730113433a8a8bde2195d1549b08e7411f8d9c08
 SHA512:
-  metadata.gz: 113a8a0543e35113868f8dff23bcf942c5c5b089fab83eaeff0c3c422b1bec0ddeec9733e7f4aa119a9cf69715a015d05d18d5da1c95dc15bddc3e4f51284cee
-  data.tar.gz: 4269bfa90e60c7230767b517ec6dd4e3f31d4ac732953f3aeb2cfeab9914029d27b1804af37f8704b66ec9351aedcf1ba7a5c5f796239bc7f7f29685e673109b
+  metadata.gz: 9310c36ead85d039a937756560785b2aee184e4b92e8171f486d0bca3d93c5425caede4c535aec8cf59f601b907de9eef97c9af8b67b4e4b4b1effc2fc168744
+  data.tar.gz: f658c941750803befda71f8e1455ccdb0292f4ffe1d75d37d84cb37bcf47b99acea4e9c692090614f85d8f04004778765a872db5bab2c47885ef49ffc0a30091

data/.rubocop.yml

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

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,16 +2,10 @@
 
 module MinatoLogger
   class Configuration
-    attr_reader :middleware, :route_blacklist, :sensitive_headers
+    attr_reader :middleware
 
     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/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,20 +46,18 @@ module MinatoLogger
       end
 
       def add_message_to_logs(log, message)
-        ruby_version = { ruby_version: RUBY_VERSION }
-        return log.merge(message, ruby_version) unless message.is_a? String
+        return log.merge(message) unless message.is_a? String
 
-        log.merge({ message: message }, ruby_version)
+        log.merge({ message: message, ruby_version: RUBY_VERSION })
       end
 
       def add_tags_to_message(msg)
         return msg unless tags_text.present?
 
         if msg.is_a?(Hash)
-          msg = msg.transform_keys(&:to_s)
-          msg['message'] = "#{tags_text}#{msg["message"]}"
+          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(out = nil)
-      super(out || $stdout)
+    def initialize
+      super($stdout)
       @formatter = Formatters::FluentBit.new
     end
   end

data/lib/minato_logger/rails.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/minato_logger/version.rb

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

data/lib/minato_logger.rb

@@ -1,11 +1,11 @@
 # 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/engine'
+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
 
 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,10 +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', '>= 7.0.0'
-  spec.add_dependency 'rails', '>= 7.0.0'
+  spec.add_dependency "activesupport", "~> 8.0.2"
+  spec.add_dependency "rails", ">= 8.0.0"
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: minato_logger
 version: !ruby/object:Gem::Version
-  version: 0.2.19
+  version: 0.3.0
 platform: ruby
 authors:
 - Ferreri
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-26 00:00:00.000000000 Z
+date: 2025-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 8.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 8.0.2
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 8.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 8.0.0
 description:
 email:
 - contato@ferreri.co
@@ -57,13 +57,12 @@ files:
 - compose.yml
 - lib/minato_logger.rb
 - lib/minato_logger/configuration.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/middlewares/request_response_logger.rb
+- lib/minato_logger/rails.rb
 - lib/minato_logger/version.rb
 - minato_logger.gemspec
 - sig/minato_logger.rbs

data/lib/minato_logger/engine.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails'
-require_relative 'middlewares/request_response_logger'
-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
-      Rails.application.config.middleware.swap(
-        Rails::Rack::Logger,
-        MinatoLogger::Middlewares::RequestResponseLogger,
-        []
-      )
-    end
-  end
-end

data/lib/minato_logger/middlewares/request_response_logger.rb

@@ -1,167 +0,0 @@
-# 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)
-        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
-    end
-  end
-end