rails_semantic_logger 4.11.0 → 4.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6944c99a390bc385a4d5a83daea0fc340dbd4dd2913631ae3a812590ec1503e4
-  data.tar.gz: ebb36106bde192de58b716077fc4c1b5c51d474ee9e86e5a93ef4a77fc25d1be
+  metadata.gz: 9a96d9dc4eb844eb8561d52f66dc27e2e07edb6b61da2163b0351ce3b12759ff
+  data.tar.gz: 34145d723bd89d14e5377200862df57829739b2ee5e5422a58f1d0edd4cbff0f
 SHA512:
-  metadata.gz: 1e1cf6df574f6dd146029407d80d2a4b51e1bfb222dbf511dbc6b540070e8d7432cff0eaf4cf94227b2d5440eb21c2ebab7222db774dd9408ebda613ae0df3bf
-  data.tar.gz: 2da852f09a5417bc91e155f1bb80d9a1c50baa823cd39c46ee2ea7a9ecfa366f95b551c996a3a295d6074424224fd5aaf390c14c7f08b88effdcae31486d3bc4
+  metadata.gz: e99c63ad9e4d02377d5ea25ba528f5de4fa8f83a2aadd7ef19ef2e3b8f52fc67cd2d08130ec18478ab4e5a2785657928f4e863024d8214a76de3bff4618b6891
+  data.tar.gz: 2d6ccc0cb9e385a2ca3a0fdc65023948f968a83b044768fc9bc9ccfb78452d7d4325731cdc4c5397bb097efa1ad72a1ce05d5576429cb2eb05b8c984fa7f06bb

data/README.md

@@ -3,12 +3,116 @@
 
 Rails Semantic Logger replaces the Rails default logger with [Semantic Logger](https://logger.rocketjob.io/)
 
+When any large Rails application is deployed to production one of the first steps is to move to centralized logging, so that logs can be viewed and searched from a central location.
+
+Centralized logging quickly falls apart when trying to consume the current human readable log files:
+- Log entries often span multiple lines, resulting in unrelated log lines in the centralized logging system. For example, stack traces.
+- Complex Regular Expressions are needed to parse the text lines and make them machine readable. For example to build queries, or alerts that are looking for specific elements in the message.
+- Writing searches, alerts, or dashboards based on text logs is incredibly brittle, since a small change to the text logged can often break the parsing of those logs.
+- Every log entry often has a completely different format, making it difficult to make consistent searches against the data.
+
+For these and many other reasons switching to structured logging, or logs in JSON format, in testing and production makes centralized logging incredibly powerful.
+
+For example, adding these lines to `config/application.rb` and removing any other log overrides from other environments, will switch automatically to structured logging when running inside Kubernetes:
+~~~ruby
+    # Setup structured logging
+    config.semantic_logger.application = "my_application"
+    config.semantic_logger.environment = ENV["STACK_NAME"] || Rails.env
+    config.log_level = ENV["LOG_LEVEL"] || :info
+
+    # Switch to JSON Logging output to stdout when running on Kubernetes
+    if ENV["LOG_TO_CONSOLE"] || ENV["KUBERNETES_SERVICE_HOST"]
+      config.rails_semantic_logger.add_file_appender = false
+      config.semantic_logger.add_appender(io: $stdout, formatter: :json)
+    end
+~~~
+
+Then configure the centralized logging system to tell it that the data is in JSON format, so that it will parse it for you into a hierarchy.
+
+For example, the following will instruct [Observe](https://www.observeinc.com/) to parse the JSON data and create machine readable data from it:
+~~~ruby
+interface "log", "log":log
+
+make_col event:parse_json(log)
+
+make_col
+   time:parse_isotime(event.timestamp),
+   application:string(event.application),
+   environment:string(event.environment),
+   duration:duration_ms(event.duration_ms),
+   level:string(event.level),
+   name:string(event.name),
+   message:string(event.message),
+   named_tags:event.named_tags,
+   payload:event.payload,
+   metric:string(event.metric),
+   metric_amount:float64(event.metric_amount),
+   tags:array(event.tags),
+   exception:event.exception,
+   host:string(event.host),
+   pid:int64(event.pid),
+   thread:string(event.thread),
+   file:string(event.file),
+   line:int64(event.line),
+   dimensions:event.dimensions,
+   backtrace:array(event.backtrace),
+   level_index:int64(event.level_index)
+
+set_valid_from(time)
+drop_col timestamp, log, event, stream
+rename_col timestamp:time
+~~~
+
+Now queries can be built to drill down into each of these fields, including `payload` which is a nested object.
+
+For example to find all failed Sidekiq job calls where the causing exception class name is `NoMethodError`:
+~~~ruby
+filter environment = "uat2"
+filter level = "error"
+filter metric = "sidekiq.job.perform"
+filter (string(exception.cause.name) = "NoMethodError")
+~~~
+
+Example: create a dashboard showing the duration of all successful Sidekiq jobs:
+~~~ruby
+filter environment = "production"
+filter level = "info"
+filter metric = "sidekiq.job.perform"
+timechart duration:avg(duration), group_by(name)
+~~~
+
+Example: create a dashboard showing the queue latency of all Sidekiq jobs. 
+The queue latency is the time between when the job was enqueued and when it was started:
+~~~ruby
+filter environment = "production"
+filter level = "info"
+filter metric = "sidekiq.queue.latency"
+timechart latency:avg(metric_amount/1000), group_by(string(named_tags.queue))
+~~~
+
 * http://github.com/reidmorrison/rails_semantic_logger
 
 ## Documentation
 
 For complete documentation see: https://logger.rocketjob.io/rails
 
+## Upgrading to Semantic Logger V4.16 - Sidekiq Metrics Support
+
+Rails Semantic Logger now supports Sidekiq metrics. 
+Below are the metrics that are now available when the JSON logging format is used:
+- `sidekiq.job.perform`
+  - The duration of each Sidekiq job.
+  - `duration` contains the time in milliseconds that the job took to run.
+- `sidekiq.queue.latency` 
+  - The time between when a Sidekiq job was enqueued and when it was started.
+  - `metric_amount` contains the time in milliseconds that the job was waiting in the queue.
+
+## Upgrading to Semantic Logger v4.15 & V4.16 - Sidekiq Support
+
+Rails Semantic Logger introduces direct support for Sidekiq v4, v5, v6, and v7. 
+Please remove any previous custom patches or configurations to make Sidekiq work with Semantic Logger.
+To see the complete list of patches being made, and to contribute your own changes, see: [Sidekiq Patches](https://github.com/reidmorrison/rails_semantic_logger/blob/master/lib/rails_semantic_logger/extensions/sidekiq/sidekiq.rb)
+
 ## Upgrading to Semantic Logger v4.4
 
 With some forking frameworks it is necessary to call `reopen` after the fork. With v4.4 the
@@ -19,7 +123,18 @@ I.e. Please remove the following line if being called anywhere:
 SemanticLogger::Processor.instance.instance_variable_set(:@queue, Queue.new)
 ~~~
 
-## Supports
+## New Versions of Rails, etc.
+
+The primary purpose of the Rails Semantic Logger gem is to patch other gems, primarily Rails, to make them support structured logging though Semantic Logger.
+
+When new versions of Rails and other gems are published they often make changes to the internals, so the existing patches stop working.
+
+Rails Semantic Logger survives only when someone in the community upgrades to a newer Rails or other supported libraries, runs into problems, 
+and then contributes the fix back to the community by means of a pull request.
+
+Additionally, when new popular gems come out, we rely only the community to supply the necessary patches in Rails Semantic Logger to make those gems support structured logging.
+
+## Supported Platforms
 
 For the complete list of supported Ruby and Rails versions, see the [Testing file](https://github.com/reidmorrison/rails_semantic_logger/blob/master/.github/workflows/ci.yml).
 

data/lib/rails_semantic_logger/action_controller/log_subscriber.rb

@@ -15,11 +15,21 @@ module RailsSemanticLogger
           # Unused, but needed for Devise 401 status code monkey patch to still work.
           ::ActionController::Base.log_process_action(payload)
 
-          # According to PR https://github.com/reidmorrison/rails_semantic_logger/pull/37/files
-          # payload[:params] is not always a Hash.
-          payload[:params] = payload[:params].to_unsafe_h unless payload[:params].is_a?(Hash)
-          payload[:params] = payload[:params].except(*INTERNAL_PARAMS)
-          payload.delete(:params) if payload[:params].empty?
+          params = payload[:params]
+
+          if params.is_a?(Hash) || params.is_a?(::ActionController::Parameters)
+            # According to PR https://github.com/reidmorrison/rails_semantic_logger/pull/37/files
+            # params is not always a Hash.
+            payload[:params] = params.to_unsafe_h unless params.is_a?(Hash)
+            payload[:params] = params.except(*INTERNAL_PARAMS)
+
+            if payload[:params].empty?
+              payload.delete(:params)
+            elsif params["file"]
+              # When logging to JSON the entire tempfile is logged, so convert it to a string.
+              payload[:params]["file"] = params["file"].inspect
+            end
+          end
 
           format           = payload[:format]
           payload[:format] = format.to_s.upcase if format.is_a?(Symbol)
@@ -48,12 +58,6 @@ module RailsSemanticLogger
           payload.delete(:request)
           payload.delete(:response)
 
-          params = payload[:params]
-          if params
-            # When logging to JSON the entire tempfile is logged, so convert it to a string.
-            params["file"] = params["file"].inspect if params["file"]
-          end
-
           {
             message:  "Completed ##{payload[:action]}",
             duration: event.duration,
@@ -75,7 +79,9 @@ module RailsSemanticLogger
       end
 
       def send_data(event)
-        controller_logger(event).info(message: "Sent data", payload: {file_name: event.payload[:filename]}, duration: event.duration)
+        controller_logger(event).info(message:  "Sent data",
+                                      payload:  {file_name: event.payload[:filename]},
+                                      duration: event.duration)
       end
 
       def unpermitted_parameters(event)

data/lib/rails_semantic_logger/action_mailer/log_subscriber.rb

@@ -9,22 +9,22 @@ module RailsSemanticLogger
         message_id = event.payload[:message_id]
         duration = event.duration.round(1)
         if ex
-         log_with_formatter event: event, log_duration: true, level: :error do |fmt|
+          log_with_formatter event: event, log_duration: true, level: :error do |_fmt|
             {
-              message: "Error delivering mail #{message_id} (#{duration}ms)",
+              message:   "Error delivering mail #{message_id} (#{duration}ms)",
               exception: ex
             }
           end
         else
-          message = begin
-          if event.payload[:perform_deliveries]
+          message =
+            if event.payload[:perform_deliveries]
               "Delivered mail #{message_id} (#{duration}ms)"
             else
               "Skipped delivery of mail #{message_id} as `perform_deliveries` is false"
             end
-          end
-          log_with_formatter event: event, log_duration: true do |fmt|
-            { message: message }
+
+          log_with_formatter event: event, log_duration: true do |_fmt|
+            {message: message}
           end
         end
       end
@@ -34,8 +34,8 @@ module RailsSemanticLogger
         mailer   = event.payload[:mailer]
         action   = event.payload[:action]
         duration = event.duration.round(1)
-        log_with_formatter event: event do |fmt|
-          { message: "#{mailer}##{action}: processed outbound mail in #{duration}ms" }
+        log_with_formatter event: event do |_fmt|
+          {message: "#{mailer}##{action}: processed outbound mail in #{duration}ms"}
         end
       end
 
@@ -74,8 +74,6 @@ module RailsSemanticLogger
             event.payload[:date].to_time.utc
           elsif event.payload[:date].is_a?(String)
             Time.parse(date).utc
-          else
-            nil
           end
         end
 
@@ -92,10 +90,10 @@ module RailsSemanticLogger
         end
 
         def formatted_args
-          if defined?(mailer.contantize.log_arguments?) && !mailer.contantize.log_arguments?
+          if defined?(mailer.constantize.log_arguments?) && !mailer.constantize.log_arguments?
             ""
-          else
-            JSON.pretty_generate(event.payload[:args].map { |arg| format(arg) }) if event.payload[:args].present?
+          elsif event.payload[:args].present?
+            JSON.pretty_generate(event.payload[:args].map { |arg| format(arg) })
           end
         end
 

data/lib/rails_semantic_logger/action_view/log_subscriber.rb

@@ -22,7 +22,7 @@ module RailsSemanticLogger
         payload = {
           template: from_rails_root(event.payload[:identifier])
         }
-        payload[:within] = from_rails_root(event.payload[:layout]) if event.payload[:layout]
+        payload[:within]      = from_rails_root(event.payload[:layout]) if event.payload[:layout]
         payload[:allocations] = event.allocations if event.respond_to?(:allocations)
 
         logger.measure(
@@ -39,8 +39,8 @@ module RailsSemanticLogger
         payload = {
           partial: from_rails_root(event.payload[:identifier])
         }
-        payload[:within] = from_rails_root(event.payload[:layout]) if event.payload[:layout]
-        payload[:cache]  = event.payload[:cache_hit] unless event.payload[:cache_hit].nil?
+        payload[:within]      = from_rails_root(event.payload[:layout]) if event.payload[:layout]
+        payload[:cache]       = event.payload[:cache_hit] unless event.payload[:cache_hit].nil?
         payload[:allocations] = event.allocations if event.respond_to?(:allocations)
 
         logger.measure(
@@ -60,7 +60,7 @@ module RailsSemanticLogger
           template: from_rails_root(identifier),
           count:    event.payload[:count]
         }
-        payload[:cache_hits] = event.payload[:cache_hits] if event.payload[:cache_hits]
+        payload[:cache_hits]  = event.payload[:cache_hits] if event.payload[:cache_hits]
         payload[:allocations] = event.allocations if event.respond_to?(:allocations)
 
         logger.measure(
@@ -72,16 +72,61 @@ module RailsSemanticLogger
       end
 
       def start(name, id, payload)
-        if (name == "render_template.action_view") && should_log?
+        if ["render_template.action_view", "render_layout.action_view"].include?(name) && should_log?
+          qualifier        = " layout" if name == "render_layout.action_view"
           payload          = {template: from_rails_root(payload[:identifier])}
           payload[:within] = from_rails_root(payload[:layout]) if payload[:layout]
 
-          logger.send(self.class.rendered_log_level, message: "Rendering", payload: payload)
+          logger.send(self.class.rendered_log_level, message: "Rendering#{qualifier}", payload: payload)
         end
 
         super
       end
 
+      if (Rails::VERSION::MAJOR == 7 && Rails::VERSION::MINOR >= 1) || Rails::VERSION::MAJOR > 7
+        class Start
+          def start(name, _id, payload)
+            return unless %w[render_template.action_view render_layout.action_view].include?(name)
+
+            qualifier        = " layout" if name == "render_layout.action_view"
+            payload          = {template: from_rails_root(payload[:identifier])}
+            payload[:within] = from_rails_root(payload[:layout]) if payload[:layout]
+
+            logger.debug(message: "Rendering#{qualifier}", payload: payload)
+          end
+
+          def finish(name, id, payload)
+          end
+
+          private
+
+          def from_rails_root(string)
+            string = string.sub(rails_root, "")
+            string.sub!(VIEWS_PATTERN, "")
+            string
+          end
+
+          def rails_root
+            @root ||= "#{Rails.root}/"
+          end
+
+          def logger
+            @logger ||= SemanticLogger["ActionView"]
+          end
+        end
+
+        def self.attach_to(*)
+          ActiveSupport::Notifications.unsubscribe("render_template.action_view")
+          ActiveSupport::Notifications.unsubscribe("render_layout.action_view")
+          ActiveSupport::Notifications.subscribe("render_template.action_view",
+                                                 RailsSemanticLogger::ActionView::LogSubscriber::Start.new)
+          ActiveSupport::Notifications.subscribe("render_layout.action_view",
+                                                 RailsSemanticLogger::ActionView::LogSubscriber::Start.new)
+
+          super
+        end
+      end
+
       private
 
       @logger             = SemanticLogger["ActionView"]

data/lib/rails_semantic_logger/active_job/log_subscriber.rb

@@ -4,14 +4,44 @@ module RailsSemanticLogger
   module ActiveJob
     class LogSubscriber < ::ActiveSupport::LogSubscriber
       def enqueue(event)
-        log_with_formatter event: event do |fmt|
-          {message: "Enqueued #{fmt.job_info}"}
+        ex = event.payload[:exception_object]
+
+        if ex
+          log_with_formatter level: :error, event: event do |fmt|
+            {
+              message:   "Failed enqueuing #{fmt.job_info} (#{ex.class} (#{ex.message})",
+              exception: ex
+            }
+          end
+        elsif event.payload[:aborted]
+          log_with_formatter level: :info, event: event do |fmt|
+            {message: "Failed enqueuing #{fmt.job_info}, a before_enqueue callback halted the enqueuing execution."}
+          end
+        else
+          log_with_formatter event: event do |fmt|
+            {message: "Enqueued #{fmt.job_info}"}
+          end
         end
       end
 
       def enqueue_at(event)
-        log_with_formatter event: event do |fmt|
-          {message: "Enqueued #{fmt.job_info} at #{fmt.scheduled_at}"}
+        ex = event.payload[:exception_object]
+
+        if ex
+          log_with_formatter level: :error, event: event do |fmt|
+            {
+              message:   "Failed enqueuing #{fmt.job_info} (#{ex.class} (#{ex.message})",
+              exception: ex
+            }
+          end
+        elsif event.payload[:aborted]
+          log_with_formatter level: :info, event: event do |fmt|
+            {message: "Failed enqueuing #{fmt.job_info}, a before_enqueue callback halted the enqueuing execution."}
+          end
+        else
+          log_with_formatter event: event do |fmt|
+            {message: "Enqueued #{fmt.job_info} at #{fmt.scheduled_at}"}
+          end
         end
       end
 
@@ -26,7 +56,7 @@ module RailsSemanticLogger
         if ex
           log_with_formatter event: event, log_duration: true, level: :error do |fmt|
             {
-              message: "Error performing #{fmt.job_info} in #{event.duration.round(2)}ms",
+              message:   "Error performing #{fmt.job_info} in #{event.duration.round(2)}ms",
               exception: ex
             }
           end

data/lib/rails_semantic_logger/active_record/log_subscriber.rb

@@ -169,9 +169,7 @@ module RailsSemanticLogger
       def render_bind_v6_1(attr, value)
         case attr
         when ActiveModel::Attribute
-          if attr.type.binary? && attr.value
-            value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
-          end
+          value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>" if attr.type.binary? && attr.value
         when Array
           attr = attr.first
         else

data/lib/rails_semantic_logger/engine.rb

@@ -1,7 +1,4 @@
 require "rails"
-require "action_controller/log_subscriber"
-require "action_view/log_subscriber"
-require "action_mailer/log_subscriber"
 require "rails_semantic_logger/options"
 
 module RailsSemanticLogger
@@ -80,7 +77,7 @@ module RailsSemanticLogger
           logger = SemanticLogger[Rails]
           logger.warn(
             "Rails Error: Unable to access log file. Please ensure that #{path} exists and is chmod 0666. " \
-              "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed.",
+            "The log level has been raised to WARN and the output directed to STDERR until the problem is fixed.",
             e
           )
           logger
@@ -111,10 +108,36 @@ module RailsSemanticLogger
       Resque.logger        = SemanticLogger[Resque] if defined?(Resque) && Resque.respond_to?(:logger=)
 
       # Replace the Sidekiq logger
-      Sidekiq.logger       = SemanticLogger[Sidekiq] if defined?(Sidekiq) && Sidekiq.respond_to?(:logger=)
+      if defined?(::Sidekiq)
+        ::Sidekiq.configure_client do |config|
+          config.logger = ::SemanticLogger[::Sidekiq]
+        end
+
+        ::Sidekiq.configure_server do |config|
+          config.logger = ::SemanticLogger[::Sidekiq]
+          if config.respond_to?(:options)
+            config.options[:job_logger] = RailsSemanticLogger::Sidekiq::JobLogger
+          else
+            config[:job_logger] = RailsSemanticLogger::Sidekiq::JobLogger
+          end
+
+          # Add back the default console logger unless already added
+          SemanticLogger.add_appender(io: $stdout, formatter: :color) unless SemanticLogger.appenders.console_output?
+
+          # Replace default error handler when present
+          existing = RailsSemanticLogger::Sidekiq::Defaults.delete_default_error_handler(config.error_handlers)
+          config.error_handlers << RailsSemanticLogger::Sidekiq::Defaults::ERROR_HANDLER if existing
+        end
+
+        if defined?(::Sidekiq::Job) && (::Sidekiq::VERSION.to_i != 5)
+          ::Sidekiq::Job.singleton_class.prepend(RailsSemanticLogger::Sidekiq::Loggable)
+        else
+          ::Sidekiq::Worker.singleton_class.prepend(RailsSemanticLogger::Sidekiq::Loggable)
+        end
+      end
 
       # Replace the Sidetiq logger
-      Sidetiq.logger       = SemanticLogger[Sidetiq] if defined?(Sidetiq) && Sidetiq.respond_to?(:logger=)
+      Sidetiq.logger = SemanticLogger[Sidetiq] if defined?(Sidetiq) && Sidetiq.respond_to?(:logger=)
 
       # Replace the DelayedJob logger
       if defined?(Delayed::Worker)
@@ -123,7 +146,7 @@ module RailsSemanticLogger
       end
 
       # Replace the Bugsnag logger
-      Bugsnag.configure { |config| config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
+      Bugsnag.configure(false) { |config| config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
 
       # Set the IOStreams PGP logger
       IOStreams::Pgp.logger = SemanticLogger["IOStreams::Pgp"] if defined?(IOStreams)
@@ -134,12 +157,14 @@ module RailsSemanticLogger
       config = Rails.application.config
 
       # Replace the Bugsnag logger
-      Bugsnag.configure { |bugsnag_config| bugsnag_config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
+      Bugsnag.configure(false) { |bugsnag_config| bugsnag_config.logger = SemanticLogger[Bugsnag] } if defined?(Bugsnag)
 
       # Rails Patches
       require("rails_semantic_logger/extensions/action_cable/tagged_logger_proxy") if defined?(::ActionCable)
       require("rails_semantic_logger/extensions/action_controller/live") if defined?(::ActionController::Live)
-      require("rails_semantic_logger/extensions/action_dispatch/debug_exceptions") if defined?(::ActionDispatch::DebugExceptions)
+      if defined?(::ActionDispatch::DebugExceptions)
+        require("rails_semantic_logger/extensions/action_dispatch/debug_exceptions")
+      end
       if defined?(::ActionView::StreamingTemplateRenderer::Body)
         require("rails_semantic_logger/extensions/action_view/streaming_template_renderer")
       end
@@ -148,7 +173,7 @@ module RailsSemanticLogger
 
       if config.rails_semantic_logger.semantic
         # Active Job
-        if defined?(::ActiveJob) && defined?(::ActiveJob::Logging::LogSubscriber)
+        if defined?(::ActiveJob::Logging::LogSubscriber)
           RailsSemanticLogger.swap_subscriber(
             ::ActiveJob::Logging::LogSubscriber,
             RailsSemanticLogger::ActiveJob::LogSubscriber,
@@ -156,7 +181,7 @@ module RailsSemanticLogger
           )
         end
 
-        if defined?(::ActiveJob) && defined?(::ActiveJob::LogSubscriber)
+        if defined?(::ActiveJob::LogSubscriber)
           RailsSemanticLogger.swap_subscriber(
             ::ActiveJob::LogSubscriber,
             RailsSemanticLogger::ActiveJob::LogSubscriber,
@@ -186,26 +211,40 @@ module RailsSemanticLogger
         end
 
         # Action View
-        RailsSemanticLogger::ActionView::LogSubscriber.rendered_log_level = :info if config.rails_semantic_logger.rendered
-        RailsSemanticLogger.swap_subscriber(
-          ::ActionView::LogSubscriber,
-          RailsSemanticLogger::ActionView::LogSubscriber,
-          :action_view
-        )
+        if defined?(::ActionView)
+          require "action_view/log_subscriber"
+
+          RailsSemanticLogger::ActionView::LogSubscriber.rendered_log_level = :info if config.rails_semantic_logger.rendered
+          RailsSemanticLogger.swap_subscriber(
+            ::ActionView::LogSubscriber,
+            RailsSemanticLogger::ActionView::LogSubscriber,
+            :action_view
+          )
+        end
 
         # Action Controller
-        RailsSemanticLogger.swap_subscriber(
-          ::ActionController::LogSubscriber,
-          RailsSemanticLogger::ActionController::LogSubscriber,
-          :action_controller
-        )
+        if defined?(::ActionController)
+          require "action_controller/log_subscriber"
+
+          RailsSemanticLogger.swap_subscriber(
+            ::ActionController::LogSubscriber,
+            RailsSemanticLogger::ActionController::LogSubscriber,
+            :action_controller
+          )
+        end
 
         # Action Mailer
-        RailsSemanticLogger.swap_subscriber(
-          ::ActionMailer::LogSubscriber,
-          RailsSemanticLogger::ActionMailer::LogSubscriber,
-          :action_mailer
-        )
+        if defined?(::ActionMailer)
+          require "action_mailer/log_subscriber"
+
+          RailsSemanticLogger.swap_subscriber(
+            ::ActionMailer::LogSubscriber,
+            RailsSemanticLogger::ActionMailer::LogSubscriber,
+            :action_mailer
+          )
+        end
+
+        require("rails_semantic_logger/extensions/sidekiq/sidekiq") if defined?(::Sidekiq)
       end
 
       #
@@ -221,7 +260,7 @@ module RailsSemanticLogger
       end
 
       # Re-open appenders after Resque has forked a worker
-      Resque.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Resque)
+      Resque.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Resque.after_fork)
 
       # Re-open appenders after Spring has forked a process
       Spring.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Spring.after_fork)

data/lib/rails_semantic_logger/extensions/action_dispatch/debug_exceptions.rb

@@ -6,9 +6,17 @@ module ActionDispatch
     private
 
     undef_method :log_error
-    def log_error(_request, wrapper)
-      ActiveSupport::Deprecation.silence do
-        ActionController::Base.logger.fatal(wrapper.exception)
+    if (Rails::VERSION::MAJOR == 7 && Rails::VERSION::MINOR >= 1) || Rails::VERSION::MAJOR > 7
+      def log_error(_request, wrapper)
+        Rails.application.deprecators.silence do
+          ActionController::Base.logger.fatal(wrapper.exception)
+        end
+      end
+    else
+      def log_error(_request, wrapper)
+        ActiveSupport::Deprecation.silence do
+          ActionController::Base.logger.fatal(wrapper.exception)
+        end
       end
     end
   end

data/lib/rails_semantic_logger/extensions/active_job/logging.rb

@@ -9,7 +9,11 @@ module ActiveJob
 
     undef_method :tag_logger
     def tag_logger(*tags, &block)
-      logger.tagged(*tags, &block)
+      if logger.respond_to?(:tagged)
+        logger.tagged(*tags, &block)
+      else
+        yield
+      end
     end
   end
 end

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

@@ -0,0 +1,13 @@
+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/active_support/logger.rb

@@ -4,20 +4,23 @@ module ActiveSupport
   # More hacks to try and stop Rails from being it's own worst enemy.
   class Logger
     class << self
-      undef :logger_outputs_to?, :broadcast
+      undef :logger_outputs_to?
+
+      # Prevent broadcasting since SemanticLogger already supports multiple loggers
+      if method_defined?(:broadcast)
+        undef :broadcast
+        def broadcast(_logger)
+          Module.new
+        end
+      end
     end
 
     # Prevent Console from trying to merge loggers
-    def self.logger_outputs_to?(*args)
+    def self.logger_outputs_to?(*_args)
       true
     end
 
-    # Prevent broadcasting since SemanticLogger already supports multiple loggers
-    def self.broadcast(logger)
-      Module.new
-    end
-
-    def self.new(*args, **kwargs)
+    def self.new(*_args, **_kwargs)
       SemanticLogger[self]
     end
   end

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

@@ -0,0 +1,12 @@
+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/rails/server.rb

@@ -4,7 +4,7 @@ require "rails"
 module Rails
   class Server
     private
-    
+
     undef_method :log_to_stdout if method_defined?(:log_to_stdout)
     def log_to_stdout
       wrapped_app # touch the app so the logger is set up

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

@@ -0,0 +1,70 @@
+# 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
+              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 }
+            end
+          end
+
+          def job_latency_ms(job)
+            return unless job && job["enqueued_at"]
+
+            (Time.now.to_f - job["enqueued_at"].to_f) * 1000
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/rack/logger.rb

@@ -35,16 +35,18 @@ module RailsSemanticLogger
       @started_request_log_level = :debug
 
       def call_app(request, env)
-        instrumenter = ActiveSupport::Notifications.instrumenter
-        instrumenter.start "request.action_dispatch", request: request
+        instrumenter        = ActiveSupport::Notifications.instrumenter
+        instrumenter_state  = instrumenter.start "request.action_dispatch", request: request
+        instrumenter_finish = lambda {
+          instrumenter.finish_with_state(instrumenter_state, "request.action_dispatch", request: request)
+        }
 
         logger.send(self.class.started_request_log_level) { started_request_message(request) }
-
         status, headers, body = @app.call(env)
-        body                  = ::Rack::BodyProxy.new(body) { finish(request) }
+        body                  = ::Rack::BodyProxy.new(body, &instrumenter_finish)
         [status, headers, body]
       rescue Exception
-        finish(request)
+        instrumenter_finish.call
         raise
       end
 
@@ -90,11 +92,6 @@ module RailsSemanticLogger
         tagged
       end
 
-      def finish(request)
-        instrumenter = ActiveSupport::Notifications.instrumenter
-        instrumenter.finish "request.action_dispatch", request: request
-      end
-
       def logger
         self.class.logger
       end

data/lib/rails_semantic_logger/sidekiq/defaults.rb

@@ -0,0 +1,40 @@
+module RailsSemanticLogger
+  module Sidekiq
+    module Defaults
+      # Prevent exception logging during standard error handling since the Job Logger below already logs the exception.
+      ERROR_HANDLER =
+        if ::Sidekiq::VERSION.to_f < 7.1 ||
+           (::Sidekiq::VERSION.to_f == 7.1 && ::Sidekiq::VERSION.split(".").last.to_i < 6)
+          lambda do |_ex, ctx|
+            unless ctx.empty?
+              job_hash = ctx[:job] || {}
+              klass    = job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
+              logger   = klass ? SemanticLogger[klass] : Sidekiq.logger
+              ctx[:context] ? logger.warn(ctx[:context], ctx) : logger.warn(ctx)
+            end
+          end
+        else
+          lambda do |_ex, ctx, _default_configuration|
+            unless ctx.empty?
+              job_hash = ctx[:job] || {}
+              klass    = job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
+              logger   = klass ? SemanticLogger[klass] : Sidekiq.logger
+              ctx[:context] ? logger.warn(ctx[:context], ctx) : logger.warn(ctx)
+            end
+          end
+        end
+
+      # Returns the default logger after removing from the supplied list.
+      # Returns [nil] when the default logger was not present.
+      def self.delete_default_error_handler(error_handlers)
+        return error_handlers.delete(::Sidekiq::Config::ERROR_HANDLER) if defined?(::Sidekiq::Config::ERROR_HANDLER)
+        return error_handlers.delete(::Sidekiq::DEFAULT_ERROR_HANDLER) if defined?(::Sidekiq::DEFAULT_ERROR_HANDLER)
+
+        return unless defined?(::Sidekiq::ExceptionHandler)
+
+        existing = error_handlers.find { |handler| handler.is_a?(::Sidekiq::ExceptionHandler::Logger) }
+        error_handlers.delete(existing) if existing
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/sidekiq/job_logger.rb

@@ -0,0 +1,59 @@
+module RailsSemanticLogger
+  module Sidekiq
+    class JobLogger
+      # Sidekiq 6.5 does not take any arguments, whereas v7 is given a logger
+      def initialize(*_args)
+      end
+
+      def call(item, queue, &block)
+        klass  = item["wrapped"] || item["class"]
+        logger = klass ? SemanticLogger[klass] : Sidekiq.logger
+
+        SemanticLogger.tagged(queue: queue) do
+          # Latency is the time between when the job was enqueued and when it started executing.
+          logger.info(
+            "Start #perform",
+            metric:        "sidekiq.queue.latency",
+            metric_amount: job_latency_ms(item)
+          )
+
+          # Measure the duration of running the job
+          logger.measure_info(
+            "Completed #perform",
+            on_exception_level: :error,
+            log_exception:      :full,
+            metric:             "sidekiq.job.perform",
+            &block
+          )
+        end
+      end
+
+      def prepare(job_hash, &block)
+        level = job_hash["log_level"]
+        if level
+          SemanticLogger.silence(level) do
+            SemanticLogger.tagged(job_hash_context(job_hash), &block)
+          end
+        else
+          SemanticLogger.tagged(job_hash_context(job_hash), &block)
+        end
+      end
+
+      private
+
+      def job_hash_context(job_hash)
+        h         = {jid: job_hash["jid"]}
+        h[:bid]   = job_hash["bid"] if job_hash["bid"]
+        h[:tags]  = job_hash["tags"] if job_hash["tags"]
+        h[:queue] = job_hash["queue"] if job_hash["queue"]
+        h
+      end
+
+      def job_latency_ms(job)
+        return unless job && job["enqueued_at"]
+
+        (Time.now.to_f - job["enqueued_at"].to_f) * 1000
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/sidekiq/loggable.rb

@@ -0,0 +1,10 @@
+module RailsSemanticLogger
+  module Sidekiq
+    module Loggable
+      def included(base)
+        super
+        base.include(SemanticLogger::Loggable)
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module RailsSemanticLogger
-  VERSION = "4.11.0".freeze
+  VERSION = "4.17.0".freeze
 end

data/lib/rails_semantic_logger.rb

@@ -6,25 +6,37 @@ module RailsSemanticLogger
   module ActionController
     autoload :LogSubscriber, "rails_semantic_logger/action_controller/log_subscriber"
   end
+
   module ActionMailer
     autoload :LogSubscriber, "rails_semantic_logger/action_mailer/log_subscriber"
   end
+
   module ActionView
     autoload :LogSubscriber, "rails_semantic_logger/action_view/log_subscriber"
   end
+
   module ActiveJob
     autoload :LogSubscriber, "rails_semantic_logger/active_job/log_subscriber"
   end
+
   module ActiveRecord
     autoload :LogSubscriber, "rails_semantic_logger/active_record/log_subscriber"
   end
+
   module Rack
     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
+
   autoload :Options, "rails_semantic_logger/options"
 
   # Swap an existing subscriber with a new one
@@ -48,9 +60,11 @@ module RailsSemanticLogger
   end
 
   def self.subscriber_patterns(subscriber)
-    subscriber.patterns.respond_to?(:keys) ?
-      subscriber.patterns.keys :
+    if subscriber.patterns.respond_to?(:keys)
+      subscriber.patterns.keys
+    else
       subscriber.patterns
+    end
   end
 
   private_class_method :subscriber_patterns, :unattach
@@ -58,4 +72,15 @@ 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/rack/server") if defined?(Rack::Server)
+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,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.11.0
+  version: 4.17.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-10 00:00:00.000000000 Z
+date: 2024-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.9'
+        version: '4.16'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.9'
+        version: '4.16'
 description:
 email:
 executables: []
@@ -75,18 +75,28 @@ 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/version.rb
 homepage: https://logger.rocketjob.io
 licenses:
 - Apache-2.0
-metadata: {}
+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.17.0
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -102,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Feature rich logging framework that replaces the Rails logger.