unified_logger 0.1.3 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8852d1fcbbbc53507a9d23e79b9e08405955b89c60458cd91e7d3305e71a7be4
-  data.tar.gz: 46a8534b601d0206ebffdb7237066835d436e960bf0cf17c7f5831d710b00652
+  metadata.gz: dac24933499290c1a3703ae8da09aaeaf46e8096e68043ce1ba4618f3b61435a
+  data.tar.gz: 3876aef726012b9a428a37a951ddd515126538686f91cc793bef629e9f13f5d2
 SHA512:
-  metadata.gz: 7669986b85d090ae4098b62dd28a9a0b17bf08568b0ae8d75c1a857c3d2ca6060937128a3f6dd31f17216f7e5120f617eecb5c242e14548350a61be46d77bcb4
-  data.tar.gz: 81dfd77bfe8205b311ad2dac30fd3f4f7dfcf4aaf6e0a6ab3f5bff84e754cbfbe1ea07b8d925c33a6dfee4147fee6a204eac9d6250dba5c2fe63cda7b7ccb817
+  metadata.gz: 4bc1ef83dd6f6be2cce82a64226de3fcef60bff86728a136497eacd396b4991b0260c8740126b21e32336c2e4c42d1c821d9739141b4bf8d7783f7d9a287a9fa
+  data.tar.gz: a0e0a7d4b2b6b3907d1c73e6ee569703fa66ec56eda323efd3823563e4396151407bdda27997188b7bfcb912e54f451295d30b6c5874f594c9925669b8527771

data/lib/unified_logger/job_logger.rb

@@ -1,45 +1,61 @@
-require "English"
-
 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!
 
-        if $ERROR_INFO
-          log[:exception] = UnifiedLogger::Logger.format_exception($ERROR_INFO)
-          log[:status] = job.executions >= DEFAULT_MAX_RETRIES ? :error : :warn
+        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] = Logger.format_exception($!)
+          log[:status] = max_retries && retry_count < max_retries ? :warn : :error
         else
           log[:status] = :ok
         end
 
-        custom = {}
-        UnifiedLogger.transform_job_log_callable&.call(custom)
-        log.merge!(custom)
-        UnifiedLogger.current_logger.write(UnifiedLogger::Logger.format(log))
+        UnifiedLogger.transform_job_log_callable&.call(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,12 @@
 module UnifiedLogger
   class Logger < ::Logger
-    CUSTOM_LOGS = Concurrent::ThreadLocalVar.new([])
+    LOGS = Concurrent::ThreadLocalVar.new([])
+    EXTRA_LOG_FIELDS = Concurrent::ThreadLocalVar.new({})
+    NOTE = 1.5
     SEVERITY_LEVELS = {
       debug:   ::Logger::DEBUG,
       info:    ::Logger::INFO,
+      note:    NOTE,
       warn:    ::Logger::WARN,
       error:   ::Logger::ERROR,
       fatal:   ::Logger::FATAL,
@@ -17,6 +20,14 @@ module UnifiedLogger
       self.formatter = proc {}
     end
 
+    def level=(severity)
+      if severity == :note
+        @level = NOTE
+      else
+        super
+      end
+    end
+
     def debug(message = nil, &block)
       message = block.call if message.nil? && block
       add(::Logger::DEBUG, message)
@@ -27,6 +38,11 @@ module UnifiedLogger
       add(::Logger::INFO, message)
     end
 
+    def note(message = nil, &block)
+      message = block.call if message.nil? && block
+      add(NOTE, message)
+    end
+
     def warn(message = nil, &block)
       message = block.call if message.nil? && block
       add(::Logger::WARN, message)
@@ -57,18 +73,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)
@@ -103,12 +134,46 @@ module UnifiedLogger
 
       def format(log)
         filtered_log = filter(log)
-        formatter = UnifiedLogger.log_transformer
+        formatter = UnifiedLogger.format_log_callable
         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 +197,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

@@ -1,5 +1,3 @@
-require "English"
-
 module UnifiedLogger
   class RequestLogger
     def initialize(app)
@@ -14,10 +12,8 @@ module UnifiedLogger
     ensure
       if UnifiedLogger.current_logger.is_a?(UnifiedLogger::Logger) && !silenced?(env["REQUEST_PATH"])
         log = build_log(started, env, status, headers, response)
-        custom = {}
-        UnifiedLogger.transform_request_log_callable&.call(custom, env)
-        log.merge!(custom)
-        UnifiedLogger.current_logger.write(UnifiedLogger::Logger.format(log))
+        UnifiedLogger.transform_request_log_callable&.call(log, env)
+        UnifiedLogger::Logger.write_log(log)
       end
     end
 
@@ -40,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"],
@@ -59,8 +55,9 @@ module UnifiedLogger
         process_id: Process.pid,
         duration:   started ? UnifiedLogger.current_time - started : 0
       }
-      log[:exception] = UnifiedLogger::Logger.format_exception($ERROR_INFO) if $ERROR_INFO.present?
-      log[:custom] = UnifiedLogger::Logger.fetch_and_reset_custom_logs if UnifiedLogger::Logger.custom_logs.any?
+      log[:exception] = UnifiedLogger::Logger.format_exception($!) if $!.present?
+      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/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.3".freeze
+  VERSION = "0.1.6".freeze
 end

data/lib/unified_logger.rb

@@ -20,6 +20,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:          []
@@ -34,7 +35,7 @@ module UnifiedLogger
   end
 
   class << self
-    attr_reader :transform_request_log_callable, :transform_job_log_callable, :log_transformer
+    attr_reader :transform_request_log_callable, :transform_job_log_callable, :format_log_callable
 
     def transform_request_log=(callable)
       raise DoubleDefineError, "transform_request_log already defined" if @transform_request_log_callable
@@ -48,14 +49,15 @@ module UnifiedLogger
       @transform_job_log_callable = callable
     end
 
-    def log_transformer=(callable)
-      raise DoubleDefineError, "log_transformer already defined" if @log_transformer
+    def format_log=(callable)
+      raise DoubleDefineError, "format_log already defined" if @format_log_callable
 
-      @log_transformer = callable
+      @format_log_callable = callable
     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.3
+  version: 0.1.6
 platform: ruby
 authors:
 - Marcovecchio
 bindir: bin
 cert_chain: []
-date: 2026-03-23 00:00:00.000000000 Z
+date: 2026-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -75,6 +75,7 @@ files:
 - lib/unified_logger/logger.rb
 - lib/unified_logger/railtie.rb
 - lib/unified_logger/request_logger.rb
+- lib/unified_logger/sidekiq.rb
 - lib/unified_logger/version.rb
 homepage: https://github.com/marcovecchio/unified_logger
 licenses: