unified_logger 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0ea9e1937937ec836c644c3831302f34b27547cb06bb76a3ef4ccb089e98a90
-  data.tar.gz: d5534540295b6ee5521fe095322844e64ff5f3c9da528dec743e6919540f956e
+  metadata.gz: ff3a0a9f560baae4bcae1a17b3b4d8ef7aebd8777649f544c5fc818f4d24afa7
+  data.tar.gz: b2a9e96b83a7cf67502acc2af0d9008ba39fdef01109af2e5462e5a56a79477d
 SHA512:
-  metadata.gz: e38c0618abb36baf5dfc6fbd308925f78e5dbabf9a5913072bf2fa116936b7ae9519406966db32aaa373efe97ac9a90d7210881a10d378f4efa1cc089b3e7fc0
-  data.tar.gz: cbf6d324fa0ce67b90313427c07234b1ec16864f365fbd2c287a5ecbabd4de993ba50a3d8d655e520f96d876c462aed2e2116f9cec9f12c8687334e3993fa36f
+  metadata.gz: b798053594157ef35351db35ea2937867bdb69d41a1280ec08a6e577c9d729634f45352781f3baeff81274dcb46399bcdb883ad0b181bbf2ce7cc85b83707721
+  data.tar.gz: 97ad2f940f4889b7665cac57fc2318b91387bebc3d5400c2d4afb4b20f5d8efcd7b008b29e8286eb14992e7bbd0e896351ec2775e3d13cecc47ebd688956160c

data/lib/unified_logger/job_logger.rb

@@ -1,41 +1,61 @@
 module UnifiedLogger
   class JobLogger
-    DEFAULT_MAX_RETRIES = 5
-
     class << self
-      def log(job)
+      def log(class_name:, id: nil, queue: nil, params: nil,
+              enqueued_at: nil, retry_count: 0, max_retries: nil, **extra)
+        started = UnifiedLogger.current_time
         yield
       ensure
-        log_execution(job) if UnifiedLogger.current_logger.is_a?(UnifiedLogger::Logger)
+        if UnifiedLogger.current_logger.is_a?(UnifiedLogger::Logger)
+          write_log(class_name: class_name, id: id, queue: queue, params: params,
+                    enqueued_at: enqueued_at, retry_count: retry_count,
+                    max_retries: max_retries, started: started, **extra)
+        end
       end
 
       private
 
-      def log_execution(job)
+      def write_log(class_name:, id:, queue:, params:, enqueued_at:,
+                    retry_count:, max_retries:, started:, **extra)
+        enqueued_time = parse_time(enqueued_at)
+
         log = {
-          log_type:             :job,
-          timestamp:            UnifiedLogger.formatted_time,
-          class_name:           job.class.name,
-          id:                   job.job_id,
-          queue:                job.queue_name,
-          params:               job.arguments,
-          executions_count:     job.executions,
-          exception_executions: job.exception_executions,
-          enqueued_at:          job.enqueued_at,
-          locale:               job.locale,
-          duration:             job.enqueued_at.present? ? UnifiedLogger.current_time - job.enqueued_at.in_time_zone : "unknown"
+          log_type:       :job,
+          timestamp:      UnifiedLogger.formatted_time,
+          class_name:     class_name,
+          id:             id,
+          queue:          queue,
+          params:         params,
+          retry_count:    retry_count,
+          enqueued_at:    enqueued_at,
+          duration:       started ? UnifiedLogger.current_time - started : 0,
+          queue_duration: enqueued_time && started ? started - enqueued_time : nil,
+          thread_id:      Thread.current.object_id,
+          process_id:     Process.pid
         }
-        log[:custom] = UnifiedLogger::Logger.fetch_and_reset_custom_logs if UnifiedLogger::Logger.custom_logs.any?
+        log.merge!(extra) if extra.any?
+        log.compact!
+
+        log[:logs] = Logger.fetch_and_reset_logs if Logger.logs.any?
+        log.merge!(Logger.fetch_and_reset_extra_log_fields) if Logger.extra_log_fields.any?
 
         if $!
-          log[:exception] = UnifiedLogger::Logger.format_exception($!)
-          log[:status] = job.executions >= DEFAULT_MAX_RETRIES ? :error : :warn
+          log[:exception] = Logger.format_exception($!)
+          log[:status] = max_retries && retry_count < max_retries ? :warn : :error
         else
           log[:status] = :ok
         end
 
         UnifiedLogger.transform_job_log_callable&.call(log)
-        UnifiedLogger.current_logger.write(UnifiedLogger::Logger.format(log))
+        Logger.write_log(log)
+      end
+
+      def parse_time(value)
+        case value
+        when Numeric                           then Time.at(value).utc
+        when String                            then Time.parse(value)
+        when Time, ActiveSupport::TimeWithZone then value
+        end
       end
     end
   end

data/lib/unified_logger/logger.rb

@@ -1,9 +1,11 @@
 module UnifiedLogger
   class Logger < ::Logger
-    CUSTOM_LOGS = Concurrent::ThreadLocalVar.new([])
+    LOGS = Concurrent::ThreadLocalVar.new([])
+    EXTRA_LOG_FIELDS = Concurrent::ThreadLocalVar.new({})
     SEVERITY_LEVELS = {
       debug:   ::Logger::DEBUG,
       info:    ::Logger::INFO,
+      note:    ::Logger::Severity::NOTE,
       warn:    ::Logger::WARN,
       error:   ::Logger::ERROR,
       fatal:   ::Logger::FATAL,
@@ -27,6 +29,11 @@ module UnifiedLogger
       add(::Logger::INFO, message)
     end
 
+    def note(message = nil, &block)
+      message = block.call if message.nil? && block
+      add(::Logger::Severity::NOTE, message)
+    end
+
     def warn(message = nil, &block)
       message = block.call if message.nil? && block
       add(::Logger::WARN, message)
@@ -57,18 +64,33 @@ module UnifiedLogger
     end
 
     class << self
-      def custom_logs
-        CUSTOM_LOGS.value
+      def logs
+        LOGS.value
+      end
+
+      def add(hash)
+        EXTRA_LOG_FIELDS.value = EXTRA_LOG_FIELDS.value.merge(hash)
+      end
+
+      def extra_log_fields
+        EXTRA_LOG_FIELDS.value
+      end
+
+      def fetch_and_reset_extra_log_fields
+        fields = extra_log_fields
+        EXTRA_LOG_FIELDS.value = {}
+        fields
       end
 
       def reset_thread_logs
-        CUSTOM_LOGS.value = []
+        LOGS.value = []
+        EXTRA_LOG_FIELDS.value = {}
       end
 
-      def fetch_and_reset_custom_logs
-        logs = custom_logs
-        reset_thread_logs
-        logs
+      def fetch_and_reset_logs
+        current = logs
+        LOGS.value = []
+        current
       end
 
       def trim(data)
@@ -107,8 +129,42 @@ module UnifiedLogger
         formatter.present? ? formatter.call(filtered_log) : filtered_log.to_json
       end
 
+      def write_log(log)
+        logger = UnifiedLogger.current_logger
+        max = UnifiedLogger.config[:max_log_size]
+        if log.inspect.length <= max || !log.key?(:logs)
+          logger.write(format(log))
+        else
+          entries = log.delete(:logs)
+          logger.write(format(log))
+          write_overflow_logs(log[:id], log[:log_type], entries, max, logger)
+        end
+      end
+
       private
 
+      def write_overflow_logs(id, log_type, entries, max, logger)
+        index = 1
+        group = []
+
+        entries.each do |entry|
+          candidate = group + [entry]
+          overflow = { id: id, log_type: log_type, index: index, logs: candidate }
+
+          if overflow.inspect.length > max && group.any?
+            logger.write(format({ id: id, log_type: log_type, index: index, logs: group }))
+            index += 1
+            group = [entry]
+          else
+            group = candidate
+          end
+        end
+
+        return if group.empty?
+
+        logger.write(format({ id: id, log_type: log_type, index: index, logs: group }))
+      end
+
       def filter(content)
         return content unless content.respond_to?(:each)
 
@@ -132,16 +188,16 @@ module UnifiedLogger
       return true unless severity >= level
 
       severity_symbol = SEVERITY_MAP[severity] || :unknown
-      append_custom_log(severity_symbol, message)
+      append_log(severity_symbol, message)
     end
 
     private
 
-    def append_custom_log(severity, message)
+    def append_log(severity, message)
       message = sanitize_log_message(message) if message.is_a?(String)
       log_hash = { timestamp: UnifiedLogger.formatted_time, severity: severity, message: message }
 
-      CUSTOM_LOGS.value = CUSTOM_LOGS.value + [log_hash]
+      LOGS.value = LOGS.value + [log_hash]
     end
 
     def sanitize_log_message(text)

data/lib/unified_logger/request_logger.rb

@@ -13,7 +13,7 @@ module UnifiedLogger
       if UnifiedLogger.current_logger.is_a?(UnifiedLogger::Logger) && !silenced?(env["REQUEST_PATH"])
         log = build_log(started, env, status, headers, response)
         UnifiedLogger.transform_request_log_callable&.call(log, env)
-        UnifiedLogger.current_logger.write(UnifiedLogger::Logger.format(log))
+        UnifiedLogger::Logger.write_log(log)
       end
     end
 
@@ -36,7 +36,7 @@ module UnifiedLogger
         timestamp:  UnifiedLogger.formatted_time,
         id:         env["action_dispatch.request_id"],
         ip:         env["action_dispatch.remote_ip"].to_s,
-        controller: path_parameters[:controller],
+        controller: path_parameters[:controller]&.camelize&.concat("Controller"),
         action:     path_parameters[:action],
         request:    {
           path:         env["REQUEST_PATH"],
@@ -56,7 +56,8 @@ module UnifiedLogger
         duration:   started ? UnifiedLogger.current_time - started : 0
       }
       log[:exception] = UnifiedLogger::Logger.format_exception($!) if $!.present?
-      log[:custom] = UnifiedLogger::Logger.fetch_and_reset_custom_logs if UnifiedLogger::Logger.custom_logs.any?
+      log[:logs] = UnifiedLogger::Logger.fetch_and_reset_logs if UnifiedLogger::Logger.logs.any?
+      log.merge!(UnifiedLogger::Logger.fetch_and_reset_extra_log_fields) if UnifiedLogger::Logger.extra_log_fields.any?
 
       log
     end

data/lib/unified_logger/severity.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Extends Ruby's Logger::Severity to recognize the custom :note level (1.5),
+# sitting between INFO (1) and WARN (2). This patch ensures ALL logger instances
+# (not just UnifiedLogger::Logger) accept :note as a valid level — which is
+# required because Rails applies config.log_level to every logger it creates.
+
+Logger::Severity.const_set(:NOTE, 1.5) unless Logger::Severity.const_defined?(:NOTE)
+
+if Logger::Severity.respond_to?(:coerce)
+  # Ruby 3.3+ / logger gem >= 1.6: patch coerce so level= works for :note
+  module UnifiedLoggerSeverityCoerce
+    CUSTOM_LEVELS = { "note" => 1.5 }.freeze
+
+    def coerce(severity)
+      if severity.is_a?(Numeric)
+        severity
+      else
+        key = severity.to_s.downcase
+        CUSTOM_LEVELS[key] || super
+      end
+    end
+  end
+
+  Logger::Severity.singleton_class.prepend(UnifiedLoggerSeverityCoerce)
+else
+  # Older Ruby: no coerce method, patch level= directly on Logger
+  module UnifiedLoggerSeverityLevel
+    def level=(severity)
+      if severity.is_a?(Numeric)
+        @level = severity
+      elsif severity.to_s.downcase == "note"
+        @level = Logger::Severity::NOTE
+      else
+        super
+      end
+    end
+  end
+
+  Logger.prepend(UnifiedLoggerSeverityLevel)
+end

data/lib/unified_logger/sidekiq.rb

@@ -0,0 +1,40 @@
+require "unified_logger"
+
+module UnifiedLogger
+  class SidekiqServerMiddleware
+    def call(job_instance, job_hash, queue)
+      UnifiedLogger::JobLogger.log(**attrs_from(job_instance, job_hash, queue)) { yield } # rubocop:disable Style/ExplicitBlockArgument
+    end
+
+    private
+
+    def attrs_from(job_instance, job_hash, queue)
+      aj = job_hash.key?("wrapped") ? job_hash.dig("args", 0) : nil
+      retries = job_hash["retry"]
+
+      {
+        class_name:  aj&.[]("job_class") || job_hash["wrapped"] || job_instance.class.name,
+        id:          aj&.[]("job_id") || job_hash["jid"],
+        queue:       queue,
+        params:      aj&.[]("arguments") || job_hash["args"],
+        retry_count: job_hash["retry_count"].to_i,
+        max_retries: resolve_max_retries(retries),
+        enqueued_at: aj&.[]("enqueued_at") || job_hash["enqueued_at"]
+      }.compact
+    end
+
+    def resolve_max_retries(retries)
+      return retries if retries.is_a?(Integer)
+
+      retries == false ? 0 : 25
+    end
+  end
+end
+
+if defined?(Sidekiq)
+  Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add UnifiedLogger::SidekiqServerMiddleware
+    end
+  end
+end

data/lib/unified_logger/version.rb

@@ -1,3 +1,3 @@
 module UnifiedLogger
-  VERSION = "0.1.5".freeze
+  VERSION = "0.1.7".freeze
 end

data/lib/unified_logger.rb

@@ -11,6 +11,7 @@ require "json"
 require "logger"
 
 require_relative "unified_logger/version"
+require_relative "unified_logger/severity"
 require_relative "unified_logger/logger"
 require_relative "unified_logger/request_logger"
 require_relative "unified_logger/job_logger"
@@ -20,6 +21,7 @@ module UnifiedLogger
 
   DEFAULTS = {
     max_log_field_size:     2048,
+    max_log_size:           10_000,
     filter_params:          %i[passw secret token crypt salt certificate otp ssn set-cookie http_authorization http_cookie pin],
     auto_insert_middleware: true,
     silence_paths:          []
@@ -55,7 +57,8 @@ module UnifiedLogger
     end
 
     delegate :trim, :format, :format_exception,
-             :custom_logs, :fetch_and_reset_custom_logs, :reset_thread_logs,
+             :logs, :fetch_and_reset_logs, :reset_thread_logs,
+             :add, :extra_log_fields, :fetch_and_reset_extra_log_fields,
              to: :"UnifiedLogger::Logger"
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: unified_logger
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Marcovecchio
 bindir: bin
 cert_chain: []
-date: 2026-03-24 00:00:00.000000000 Z
+date: 2026-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -75,6 +75,8 @@ files:
 - lib/unified_logger/logger.rb
 - lib/unified_logger/railtie.rb
 - lib/unified_logger/request_logger.rb
+- lib/unified_logger/severity.rb
+- lib/unified_logger/sidekiq.rb
 - lib/unified_logger/version.rb
 homepage: https://github.com/marcovecchio/unified_logger
 licenses: