rails_semantic_logger 4.20.0 → 5.1.0

data/lib/rails_semantic_logger/solid_queue/log_subscriber.rb

@@ -0,0 +1,183 @@
+module RailsSemanticLogger
+  module SolidQueue
+    class LogSubscriber < ::ActiveSupport::LogSubscriber
+      def dispatch_scheduled(event)
+        log_event(event, :debug, "Dispatch scheduled jobs", **event.payload.slice(:batch_size, :size))
+      end
+
+      def claim(event)
+        log_event(event, :debug, "Claim jobs", **event.payload.slice(:process_id, :job_ids, :claimed_job_ids, :size))
+      end
+
+      def release_many_claimed(event)
+        log_event(event, :info, "Release claimed jobs", **event.payload.slice(:size))
+      end
+
+      def fail_many_claimed(event)
+        log_event(event, :warn, "Fail claimed jobs", **event.payload.slice(:job_ids, :process_ids))
+      end
+
+      def release_claimed(event)
+        log_event(event, :info, "Release claimed job", **event.payload.slice(:job_id, :process_id))
+      end
+
+      def retry_all(event)
+        log_event(event, :debug, "Retry failed jobs", **event.payload.slice(:jobs_size, :size))
+      end
+
+      def retry(event)
+        log_event(event, :debug, "Retry failed job", **event.payload.slice(:job_id))
+      end
+
+      def discard_all(event)
+        log_event(event, :debug, "Discard jobs", **event.payload.slice(:jobs_size, :size, :status))
+      end
+
+      def discard(event)
+        log_event(event, :debug, "Discard job", **event.payload.slice(:job_id, :status))
+      end
+
+      def release_many_blocked(event)
+        log_event(event, :debug, "Unblock jobs", **event.payload.slice(:limit, :size))
+      end
+
+      def release_blocked(event)
+        log_event(event, :debug, "Release blocked job", **event.payload.slice(:job_id, :concurrency_key, :released))
+      end
+
+      def enqueue_recurring_task(event)
+        attributes      = event.payload.slice(:task, :active_job_id, :enqueue_error)
+        attributes[:at] = event.payload[:at]&.iso8601
+
+        if attributes[:active_job_id].nil? && event.payload[:skipped].nil?
+          log_event(event, :error, "Error enqueuing recurring task", **attributes)
+        elsif event.payload[:other_adapter]
+          log_event(event, :debug, "Enqueued recurring task outside Solid Queue", **attributes)
+        else
+          action = if event.payload[:skipped].present?
+                     "Skipped recurring task – already dispatched"
+                   else
+                     "Enqueued recurring task"
+                   end
+          log_event(event, :debug, action, **attributes)
+        end
+      end
+
+      def start_process(event)
+        process    = event.payload[:process]
+        attributes = process_attributes(process).merge(process.metadata)
+
+        log_event(event, :info, "Started #{process.kind}", **attributes)
+      end
+
+      def shutdown_process(event)
+        process    = event.payload[:process]
+        attributes = process_attributes(process).merge(process.metadata)
+
+        log_event(event, :info, "Shutdown #{process.kind}", **attributes)
+      end
+
+      def register_process(event)
+        process_kind = event.payload[:kind]
+        attributes   = event.payload.slice(:pid, :hostname, :process_id, :name)
+
+        if (error = event.payload[:error])
+          log_event(event, :warn, "Error registering #{process_kind}", exception: error, **attributes)
+        else
+          log_event(event, :debug, "Register #{process_kind}", **attributes)
+        end
+      end
+
+      def deregister_process(event)
+        process    = event.payload[:process]
+        attributes = {
+          process_id:        process.id,
+          pid:               process.pid,
+          hostname:          process.hostname,
+          name:              process.name,
+          last_heartbeat_at: process.last_heartbeat_at.iso8601,
+          claimed_size:      event.payload[:claimed_size],
+          pruned:            event.payload[:pruned]
+        }
+
+        if (error = event.payload[:error])
+          log_event(event, :warn, "Error deregistering #{process.kind}", exception: error, **attributes)
+        else
+          log_event(event, :debug, "Deregister #{process.kind}", **attributes)
+        end
+      end
+
+      def prune_processes(event)
+        log_event(event, :debug, "Prune dead processes", **event.payload.slice(:size))
+      end
+
+      def thread_error(event)
+        log_event(event, :error, "Error in thread", exception: event.payload[:error])
+      end
+
+      def graceful_termination(event)
+        attributes = event.payload.slice(:process_id, :supervisor_pid, :supervised_processes)
+
+        if event.payload[:shutdown_timeout_exceeded]
+          log_event(event, :warn, "Supervisor wasn't terminated gracefully - shutdown timeout exceeded", **attributes)
+        else
+          log_event(event, :info, "Supervisor terminated gracefully", **attributes)
+        end
+      end
+
+      def immediate_termination(event)
+        log_event(event, :info, "Supervisor terminated immediately",
+                  **event.payload.slice(:process_id, :supervisor_pid, :supervised_processes))
+      end
+
+      def unhandled_signal_error(event)
+        log_event(event, :error, "Received unhandled signal", **event.payload.slice(:signal))
+      end
+
+      def replace_fork(event)
+        supervisor_pid = event.payload[:supervisor_pid]
+        status         = event.payload[:status]
+        attributes     = event.payload.slice(:pid).merge(
+          status:          status.exitstatus || "no exit status set",
+          pid_from_status: status.pid,
+          signaled:        status.signaled?,
+          stopsig:         status.stopsig,
+          termsig:         status.termsig
+        )
+
+        if (replaced_fork = event.payload[:fork])
+          log_event(event, :info, "Replaced terminated #{replaced_fork.kind}",
+                    **attributes, hostname: replaced_fork.hostname, name: replaced_fork.name)
+        elsif supervisor_pid != 1 # Running Docker, possibly having some processes that have been reparented
+          log_event(event, :warn, "Tried to replace forked process but it had already died", **attributes)
+        end
+      end
+
+      private
+
+      def process_attributes(process)
+        {
+          pid:        process.pid,
+          hostname:   process.hostname,
+          process_id: process.process_id,
+          name:       process.name
+        }
+      end
+
+      def log_event(event, level, action, exception: nil, **attributes)
+        logger.public_send(level) do
+          msg = {message: action, payload: attributes, duration: event.duration}
+          msg[:exception] = exception if exception
+          # Emit a metric for every info/warn/error entry, named after the notification
+          # (e.g. "start_process.solid_queue" -> "rails.solid_queue.start_process"). Debug entries are excluded.
+          msg[:metric] = "rails.solid_queue.#{event.name.split('.').first}" unless level == :debug
+          msg
+        end
+      end
+
+      def logger
+        @logger ||= SemanticLogger[::SolidQueue]
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module RailsSemanticLogger
-  VERSION = "4.20.0".freeze
+  VERSION = "5.1.0".freeze
 end

data/lib/rails_semantic_logger.rb

@@ -27,21 +27,96 @@ module RailsSemanticLogger
     autoload :Logger, "rails_semantic_logger/rack/logger"
   end
 
-  module DelayedJob
-    autoload :Plugin, "rails_semantic_logger/delayed_job/plugin"
-  end
-
   module Sidekiq
     autoload :Defaults, "rails_semantic_logger/sidekiq/defaults"
     autoload :JobLogger, "rails_semantic_logger/sidekiq/job_logger"
     autoload :Loggable, "rails_semantic_logger/sidekiq/loggable"
   end
 
+  module SolidQueue
+    autoload :LogSubscriber, "rails_semantic_logger/solid_queue/log_subscriber"
+  end
+
+  autoload :Appenders, "rails_semantic_logger/appenders"
   autoload :Options, "rails_semantic_logger/options"
 
+  # Deprecator used for options that are being phased out in favor of declaring
+  # appenders directly (see RailsSemanticLogger::Appenders).
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("6.0", "rails_semantic_logger")
+  end
+
+  # Warn that a setting was changed too late to take effect, so the change has no
+  # effect. When `config_initializers_too_late` is true (the default), the setting
+  # is consumed while the logger is built, *before* `config/initializers/*` is
+  # loaded, so that location is called out as too late. When false, the setting is
+  # consumed at the end of initialization (`config/initializers/*` still works) and
+  # only a change after the application has booted is too late.
+  def self.warn_initialized_too_late(setting, config_initializers_too_late: true)
+    env       = defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : "<env>"
+    locations = "`config/application.rb` or `config/environments/#{env}.rb`"
+    locations += " (or a `config/initializers/*` file)" unless config_initializers_too_late
+    suffix    = config_initializers_too_late ? "; `config/initializers/*` is loaded too late." : "."
+    warn(
+      "[rails_semantic_logger] `config.rails_semantic_logger.#{setting}` was set too late to take " \
+      "effect, so it has no effect. Set it in #{locations}#{suffix}"
+    )
+  end
+
+  # Create the appenders declared via `config.rails_semantic_logger.appenders` with
+  # `add_server` (or the default console appender when the application declared no
+  # appenders of its own).
+  #
+  # Called automatically for the server contexts that have a first-party hook
+  # (`rails server`, Sidekiq in server mode). App servers without such a hook (bare
+  # puma, rackup, Passenger, Unicorn) cannot be detected reliably, so call this from
+  # the server's own definitive boot hook instead of relying on a guess. Example,
+  # in `config/puma.rb`:
+  #
+  #   on_booted { RailsSemanticLogger.add_server_appenders }
+  def self.add_server_appenders
+    options = Rails.application.config.rails_semantic_logger
+    # Backward compatibility
+    if !options.appenders? && options.console_logger && !SemanticLogger.appenders.console_output?
+      SemanticLogger.add_appender(io: $stdout, formatter: :color)
+    end
+
+    options.appenders.server.each do |args, block|
+      SemanticLogger.add_appender(**args, &block)
+    end
+  end
+
+  # Console (REPL) counterpart of .add_server_appenders, used by the `rails console`
+  # hook. When the application declared its own appenders, its `add_console`
+  # declarations apply; otherwise the deprecated `console_logger` toggle decides
+  # whether the default stderr console appender is added.
+  def self.add_console_appenders
+    options = Rails.application.config.rails_semantic_logger
+    # Backward compatibility: honor the deprecated console_logger toggle.
+    if !options.appenders? && options.console_logger && !SemanticLogger.appenders.console_output?
+      SemanticLogger.add_appender(io: $stderr, formatter: :color)
+    end
+
+    options.appenders.console.each do |args, block|
+      SemanticLogger.add_appender(**args, &block)
+    end
+  end
+
+  # Create each appender declared via `config.rails_semantic_logger.appenders`.
+  # The first file appender (if any) becomes the internal logger, so that any
+  # failures writing to other appenders are still recorded somewhere durable.
+  def self.add_appenders(appenders)
+    internal_logger = nil
+    appenders.each do |args, block|
+      appender = SemanticLogger.add_appender(**args, &block)
+      internal_logger ||= appender if appender.is_a?(SemanticLogger::Appender::File)
+    end
+    SemanticLogger::Processor.logger = internal_logger if internal_logger
+  end
+
   # Swap an existing subscriber with a new one
   def self.swap_subscriber(old_class, new_class, notifier)
-    subscribers = ActiveSupport::LogSubscriber.subscribers.select { |s| s.is_a?(old_class) }
+    subscribers = ActiveSupport::LogSubscriber.subscribers.grep(old_class)
     subscribers.each { |subscriber| unattach(subscriber) }
 
     new_class.attach_to(notifier)
@@ -60,19 +135,11 @@ module RailsSemanticLogger
   end
 
   def self.subscriber_patterns(subscriber)
-    if subscriber.patterns.respond_to?(:keys)
-      subscriber.patterns.keys
-    else
-      subscriber.patterns
-    end
+    subscriber.patterns.keys
   end
 
   def self.listeners_for(notifier, pattern)
-    if notifier.respond_to?(:all_listeners_for) # Rails >= 7.1
-      notifier.all_listeners_for(pattern)
-    else
-      notifier.listeners_for(pattern)
-    end
+    notifier.all_listeners_for(pattern)
   end
 
   private_class_method :listeners_for, :subscriber_patterns, :unattach
@@ -80,15 +147,3 @@ end
 
 require("rails_semantic_logger/extensions/mongoid/config") if defined?(Mongoid)
 require("rails_semantic_logger/extensions/active_support/logger") if defined?(ActiveSupport::Logger)
-require("rails_semantic_logger/extensions/active_support/log_subscriber") if defined?(ActiveSupport::LogSubscriber)
-
-begin
-  require "rackup"
-rescue LoadError
-  # No need to do anything, will fall back to Rack
-end
-if defined?(Rackup::Server)
-  require("rails_semantic_logger/extensions/rackup/server")
-elsif defined?(Rack::Server)
-  require("rails_semantic_logger/extensions/rack/server")
-end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.20.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Reid Morrison
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -30,30 +29,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: semantic_logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.16'
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.16'
-description:
-email:
+        version: '5.1'
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -67,7 +64,7 @@ files:
 - lib/rails_semantic_logger/action_view/log_subscriber.rb
 - lib/rails_semantic_logger/active_job/log_subscriber.rb
 - lib/rails_semantic_logger/active_record/log_subscriber.rb
-- lib/rails_semantic_logger/delayed_job/plugin.rb
+- lib/rails_semantic_logger/appenders.rb
 - lib/rails_semantic_logger/engine.rb
 - lib/rails_semantic_logger/extensions/action_cable/tagged_logger_proxy.rb
 - lib/rails_semantic_logger/extensions/action_controller/live.rb
@@ -75,19 +72,16 @@ files:
 - lib/rails_semantic_logger/extensions/action_view/streaming_template_renderer.rb
 - lib/rails_semantic_logger/extensions/active_job/logging.rb
 - lib/rails_semantic_logger/extensions/active_model_serializers/logging.rb
-- lib/rails_semantic_logger/extensions/active_support/log_subscriber.rb
 - lib/rails_semantic_logger/extensions/active_support/logger.rb
 - lib/rails_semantic_logger/extensions/active_support/tagged_logging.rb
 - lib/rails_semantic_logger/extensions/mongoid/config.rb
-- lib/rails_semantic_logger/extensions/rack/server.rb
-- lib/rails_semantic_logger/extensions/rackup/server.rb
 - lib/rails_semantic_logger/extensions/rails/server.rb
-- lib/rails_semantic_logger/extensions/sidekiq/sidekiq.rb
 - lib/rails_semantic_logger/options.rb
 - lib/rails_semantic_logger/rack/logger.rb
 - lib/rails_semantic_logger/sidekiq/defaults.rb
 - lib/rails_semantic_logger/sidekiq/job_logger.rb
 - lib/rails_semantic_logger/sidekiq/loggable.rb
+- lib/rails_semantic_logger/solid_queue/log_subscriber.rb
 - lib/rails_semantic_logger/version.rb
 homepage: https://logger.rocketjob.io
 licenses:
@@ -95,9 +89,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/reidmorrison/rails_semantic_logger/issues
   documentation_uri: https://logger.rocketjob.io
-  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v4.20.0
+  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v5.1.0
+  changelog_uri: https://github.com/reidmorrison/rails_semantic_logger/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -105,15 +99,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
-summary: Feature rich logging framework that replaces the Rails logger.
+summary: High-performance, asynchronous structured logging that replaces the Rails
+  logger.
 test_files: []

data/lib/rails_semantic_logger/delayed_job/plugin.rb

@@ -1,11 +0,0 @@
-module RailsSemanticLogger
-  module DelayedJob
-    class Plugin < Delayed::Plugin
-      callbacks do |lifecycle|
-        lifecycle.before(:execute) do |_job|
-          ::SemanticLogger.reopen
-        end
-      end
-    end
-  end
-end

data/lib/rails_semantic_logger/extensions/active_support/log_subscriber.rb

@@ -1,13 +0,0 @@
-if ActiveSupport::VERSION::STRING == "7.1.1"
-  require "active_support/log_subscriber"
-
-  module ActiveSupport
-    class LogSubscriber
-      # @override Rails 7.1
-      def silenced?(event)
-        native_log_level = @event_levels.fetch(event, ::Logger::Severity::FATAL)
-        logger.nil? || SemanticLogger::Levels.index(logger.level) > SemanticLogger::Levels.index(native_log_level)
-      end
-    end
-  end
-end

data/lib/rails_semantic_logger/extensions/rack/server.rb

@@ -1,12 +0,0 @@
-module RailsSemanticLogger
-  module Rack
-    module Server
-      def daemonize_app
-        super
-        SemanticLogger.reopen
-      end
-    end
-  end
-end
-
-Rack::Server.prepend(RailsSemanticLogger::Rack::Server)

data/lib/rails_semantic_logger/extensions/rackup/server.rb

@@ -1,12 +0,0 @@
-module RailsSemanticLogger
-  module Rackup
-    module Server
-      def daemonize_app
-        super
-        SemanticLogger.reopen
-      end
-    end
-  end
-end
-
-Rackup::Server.prepend(RailsSemanticLogger::Rackup::Server)

data/lib/rails_semantic_logger/extensions/sidekiq/sidekiq.rb

@@ -1,87 +0,0 @@
-# Sidekiq patches
-if Sidekiq::VERSION.to_i == 4
-  require "sidekiq/logging"
-  require "sidekiq/middleware/server/logging"
-  require "sidekiq/processor"
-elsif Sidekiq::VERSION.to_i == 5
-  require "sidekiq/logging"
-end
-
-module Sidekiq
-  # Sidekiq v4 & v5
-  if defined?(::Sidekiq::Logging)
-    # Replace Sidekiq logging context
-    module Logging
-      def self.with_context(msg, &block)
-        SemanticLogger.tagged(msg, &block)
-      end
-
-      def self.job_hash_context(job_hash)
-        h         = {jid: job_hash["jid"]}
-        h[:bid]   = job_hash["bid"] if job_hash["bid"]
-        h[:queue] = job_hash["queue"] if job_hash["queue"]
-        h
-      end
-    end
-  end
-
-  # Sidekiq v4
-  if defined?(::Sidekiq::Middleware::Server::Logging)
-    # Convert string to machine readable format
-    class Processor
-      def log_context(job_hash)
-        h         = {jid: job_hash["jid"]}
-        h[:bid]   = job_hash["bid"] if job_hash["bid"]
-        h[:queue] = job_hash["queue"] if job_hash["queue"]
-        h
-      end
-    end
-
-    # Let Semantic Logger handle duration logging
-    module Middleware
-      module Server
-        class Logging
-          # rubocop:disable Style/ExplicitBlockArgument
-          def call(worker, item, queue)
-            SemanticLogger.tagged(queue: queue) do
-              if perform_messages_enabled?
-                worker.logger.info(
-                  "Start #perform",
-                  metric:        "sidekiq.queue.latency",
-                  metric_amount: job_latency_ms(item)
-                )
-
-                worker.logger.measure_info(
-                  "Completed #perform",
-                  on_exception_level: :error,
-                  log_exception:      :full,
-                  metric:             "sidekiq.job.perform"
-                ) { yield }
-              else
-                yield
-              end
-            end
-          end
-
-          def perform_messages_enabled?
-            RailsSemanticLogger::Sidekiq::JobLogger.perform_messages != false
-          end
-
-          def job_latency_ms(job)
-            return unless job && job["enqueued_at"]
-
-            enqueued_at = job["enqueued_at"]
-            if enqueued_at.is_a?(Float)
-              # Sidekiq <= 7: seconds since epoch
-              (Time.now.to_f - enqueued_at) * 1000
-            else
-              # Sidekiq 8+: milliseconds since epoch
-              now = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
-              now - enqueued_at
-            end
-          end
-        end
-      end
-    end
-  end
-end