rails_semantic_logger 4.14.0 → 4.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b41a1fee07d074d18bcaed7538592f123ecbbbe0f232b52cbca96133654ac256
-  data.tar.gz: df2d6ef10cb8aa051f56a3b916064d1c51afcc3c9ef6f834c2c26be5a3dfc9b4
+  metadata.gz: 3bb41dd02df0dc0dc472a66f83a82146878942a309670d4fb10da64bfdae4bc4
+  data.tar.gz: c1463e8da359c87fffc4e7d4e56919609320473fa0702b6a7f9b9fec1bdc5050
 SHA512:
-  metadata.gz: 70dec27d9976ae2edfc028bdfd03f51b3eade4cf1562681096ba3a882e2f0aacc9fba893cacd5ac7604f3810b2d6e3b880d2411d78a4372ad5b53ab579e41878
-  data.tar.gz: 635c69136356a8c3ad62a81e0b2db7e397031878619c381fe52240405c2c0b720b9f4900fc2d2ae886d8c23943f8ebd1649444b35357c6178016bb99f036e7dd
+  metadata.gz: 1604cdbeed7b9bda178517f7cd7f72e4721523cf222aa6b0a2dcce36fc77c62807641ca32aef349f91c9e5aa86d04e9202e15adff71e4b5e4e29798a3c9dde16
+  data.tar.gz: b0e79372c2111bb823c191595a600c8c4c218e6989249f66c0ec46d66826116abfe2f6c5c761d33ae23f1494e7a74b8299d70b037410570757195115b212dced

data/lib/rails_semantic_logger/engine.rb

@@ -224,6 +224,8 @@ module RailsSemanticLogger
             :action_mailer
           )
         end
+
+        require("rails_semantic_logger/extensions/sidekiq/sidekiq") if defined?(::Sidekiq)
       end
 
       #
@@ -239,7 +241,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/sidekiq/sidekiq.rb

@@ -0,0 +1,211 @@
+# Sidekiq patches
+#
+# To re-enable stdout logging for sidekiq server processes, add the following snippet to config/initializers/sidekiq.rb:
+#   Sidekiq.configure_server do |config|
+#     SemanticLogger.add_appender(io: $stdout, level: :debug, formatter: :color)
+#   end
+if Sidekiq::VERSION.to_i == 4
+  require "sidekiq/exception_handler"
+  require "sidekiq/logging"
+  require "sidekiq/middleware/server/logging"
+  require "sidekiq/processor"
+  require "sidekiq/worker"
+elsif Sidekiq::VERSION.to_i == 5
+  require "sidekiq/exception_handler"
+  require "sidekiq/job_logger"
+  require "sidekiq/logging"
+  require "sidekiq/worker"
+elsif Sidekiq::VERSION.to_i == 6 && Sidekiq::VERSION.to_f < 6.5
+  require "sidekiq/exception_handler"
+  require "sidekiq/job_logger"
+  require "sidekiq/worker"
+elsif Sidekiq::VERSION.to_i == 6
+  require "sidekiq/job_logger"
+  require "sidekiq/worker"
+else
+  require "sidekiq/config"
+  require "sidekiq/job_logger"
+  require "sidekiq/job"
+end
+
+module Sidekiq
+  # Sidekiq > v4
+  if defined?(::Sidekiq::JobLogger)
+    # Let Semantic Logger handle duration logging
+    class JobLogger
+      def call(item, queue)
+        klass  = item["wrapped"] || item["class"]
+        metric = "Sidekiq/#{klass}/perform" if klass
+        logger = klass ? SemanticLogger[klass] : Sidekiq.logger
+        logger.info("Start #perform")
+        logger.measure_info(
+          "Completed #perform",
+          on_exception_level: :error,
+          log_exception:      :full,
+          metric:             metric
+        ) do
+          yield
+        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
+
+      def job_hash_context(job_hash)
+        h        = {
+          class: job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"],
+          jid:   job_hash["jid"]
+        }
+        h[:bid]  = job_hash["bid"] if job_hash["bid"]
+        h[:tags] = job_hash["tags"] if job_hash["tags"]
+        h
+      end
+    end
+  end
+
+  # Sidekiq <= v6
+  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)
+        klass       = job_hash["wrapped"] || job_hash["class"]
+        event       = { class: klass, jid: job_hash["jid"] }
+        event[:bid] = job_hash["bid"] if job_hash["bid"]
+        event
+      end
+    end
+  end
+
+  # Exception is already logged by Semantic Logger during the perform call
+  # Sidekiq <= v6.5
+  if defined?(::Sidekiq::ExceptionHandler)
+    module ExceptionHandler
+      class Logger
+        def call(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
+      end
+    end
+  # Sidekiq >= v7
+  elsif defined?(::Sidekiq::Config)
+    class Config
+      remove_const :ERROR_HANDLER
+
+      ERROR_HANDLER = ->(ex, ctx, cfg = Sidekiq.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
+  else
+    # Sidekiq >= 6.5
+    # TODO: Not taking effect. See test/sidekiq_test.rb
+    def self.default_error_handler(ex, ctx)
+      binding.irb
+      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
+
+  # Logging within each worker should use its own logger
+  if Sidekiq::VERSION.to_i == 4
+    module Worker
+      def self.included(base)
+        raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
+
+        base.extend(ClassMethods)
+        base.include(SemanticLogger::Loggable)
+        base.class_attribute :sidekiq_options_hash
+        base.class_attribute :sidekiq_retry_in_block
+        base.class_attribute :sidekiq_retries_exhausted_block
+      end
+    end
+  elsif Sidekiq::VERSION.to_i == 5
+    module Worker
+      def self.included(base)
+        raise ArgumentError, "You cannot include Sidekiq::Worker in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
+
+        base.extend(ClassMethods)
+        base.include(SemanticLogger::Loggable)
+        base.sidekiq_class_attribute :sidekiq_options_hash
+        base.sidekiq_class_attribute :sidekiq_retry_in_block
+        base.sidekiq_class_attribute :sidekiq_retries_exhausted_block
+      end
+    end
+  elsif Sidekiq::VERSION.to_i == 6
+    module Worker
+      def self.included(base)
+        raise ArgumentError, "Sidekiq::Worker cannot be included in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
+
+        base.include(Options)
+        base.extend(ClassMethods)
+        base.include(SemanticLogger::Loggable)
+      end
+    end
+  else
+    module Job
+      def self.included(base)
+        raise ArgumentError, "Sidekiq::Job cannot be included in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
+
+        base.include(Options)
+        base.extend(ClassMethods)
+        base.include(SemanticLogger::Loggable)
+      end
+    end
+  end
+
+  if Sidekiq::VERSION.to_i == 4
+    # Convert string to machine readable format
+    class Processor
+      def log_context(job_hash)
+        klass       = job_hash["wrapped"] || job_hash["class"]
+        event       = { class: klass, jid: job_hash["jid"] }
+        event[:bid] = job_hash["bid"] if job_hash["bid"]
+        event
+      end
+    end
+
+    # Let Semantic Logger handle duration logging
+    module Middleware
+      module Server
+        class Logging
+          def call(worker, item, queue)
+            worker.logger.info("Start #perform")
+            worker.logger.measure_info(
+              "Completed #perform",
+              on_exception_level: :error,
+              log_exception:      :full,
+              metric:             "Sidekiq/#{worker.class.name}/perform"
+            ) do
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module RailsSemanticLogger
-  VERSION = "4.14.0".freeze
+  VERSION = "4.15.0".freeze
 end

data/lib/rails_semantic_logger.rb

@@ -67,6 +67,12 @@ 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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.14.0
+  version: 4.15.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-16 00:00:00.000000000 Z
+date: 2024-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -82,6 +82,7 @@ files:
 - 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/version.rb
@@ -91,7 +92,7 @@ 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.14.0
+  source_code_uri: https://github.com/reidmorrison/rails_semantic_logger/tree/v4.15.0
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -108,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.9
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Feature rich logging framework that replaces the Rails logger.