rails_semantic_logger 4.4.2 → 4.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32fc703f9cccb2497f676f165469986f8bb692c4bf54628e98e2df6ab14807bd
-  data.tar.gz: ec0b15888d70b7635f8a85dfe16d3164de2fe66e66862c242a9ae9c3c65be02a
+  metadata.gz: 073a9356b40dc5616e3e4b179ea108d7419dc9e4bba685c230e41acd93ca48d4
+  data.tar.gz: 106766c0a81ed7a2d7b25c7810aa1edac1eedf5638426373209b168d7ea57b43
 SHA512:
-  metadata.gz: 655a3c58abe00572424587cf790eaba6e8cd69cb795af5b7b01078a27220dba2a6d2010aae905c9c88a7b36f0d46de9f7c5efdf8406ad31ac292e38a1f2a1c87
-  data.tar.gz: 19726f3321f658c0fb6a112e73e56326db798ca3ffa2c206e07f8b235140a4b1de0018551993cef041e44dc1a7759fb3f30a297db7297877e55dad54c179f2a1
+  metadata.gz: fd450ba87b0d22e139fd7afa626ed4fb8566e3ebc70880c05fe2c73c1ff5067a8d3626a8bddd742160a3d25eced3f8e4431e1fac96432f0fe53e6ec740c78d46
+  data.tar.gz: 2bee7d442cab44140f00b9ca74d0b343d6e19933953487c5b21c094bea0c7f811f2bb6014090eda6a778eb1ebd8209f86a9b4c3afb471fd1fa9955ad3fc160e4

data/README.md

@@ -21,7 +21,7 @@ SemanticLogger::Processor.instance.instance_variable_set(:@queue, Queue.new)
 
 ## Supports
 
-- Rails 3.2, 4, 5
+For the complete list of supported Ruby and Rails versions, see the [Testing file](https://github.com/rocketjob/rails_semantic_logger/blob/master/.travis.yml).
 
 ## Author
 

data/Rakefile

@@ -1,30 +1,30 @@
 # Setup bundler to avoid having to run bundle exec all the time.
-require 'rubygems'
-require 'bundler/setup'
+require "rubygems"
+require "bundler/setup"
 
-require 'rake/testtask'
-require_relative 'lib/rails_semantic_logger/version'
+require "rake/testtask"
+require_relative "lib/rails_semantic_logger/version"
 
 task :gem do
-  system 'gem build rails_semantic_logger.gemspec'
+  system "gem build rails_semantic_logger.gemspec"
 end
 
 task publish: :gem do
   system "git tag -a v#{RailsSemanticLogger::VERSION} -m 'Tagging #{RailsSemanticLogger::VERSION}'"
-  system 'git push --tags'
+  system "git push --tags"
   system "gem push rails_semantic_logger-#{RailsSemanticLogger::VERSION}.gem"
   system "rm rails_semantic_logger-#{RailsSemanticLogger::VERSION}.gem"
 end
 
 Rake::TestTask.new(:test) do |t|
-  t.pattern = 'test/**/*_test.rb'
+  t.pattern = "test/**/*_test.rb"
   t.verbose = true
   t.warning = false
 end
 
 # By default run tests against all appraisals
-if !ENV['APPRAISAL_INITIALIZED'] && !ENV['TRAVIS']
-  require 'appraisal'
+if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
+  require "appraisal"
   task default: :appraisal
 else
   task default: :test

data/lib/rails_semantic_logger.rb

@@ -1,25 +1,28 @@
-require 'semantic_logger'
-require 'rails_semantic_logger/extensions/rails/server' if defined?(Rails::Server)
-require 'rails_semantic_logger/engine'
+require "semantic_logger"
+require "rails_semantic_logger/extensions/rails/server" if defined?(Rails::Server)
+require "rails_semantic_logger/engine"
 
 module RailsSemanticLogger
   module ActionController
-    autoload :LogSubscriber, 'rails_semantic_logger/action_controller/log_subscriber'
+    autoload :LogSubscriber, "rails_semantic_logger/action_controller/log_subscriber"
   end
   module ActionView
-    autoload :LogSubscriber, 'rails_semantic_logger/action_view/log_subscriber'
+    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'
+    autoload :LogSubscriber, "rails_semantic_logger/active_record/log_subscriber"
   end
   module Rack
-    autoload :Logger, 'rails_semantic_logger/rack/logger'
+    autoload :Logger, "rails_semantic_logger/rack/logger"
   end
   module DelayedJob
-    autoload :Plugin, 'rails_semantic_logger/delayed_job/plugin'
+    autoload :Plugin, "rails_semantic_logger/delayed_job/plugin"
   end
 
-  autoload :Options, 'rails_semantic_logger/options'
+  autoload :Options, "rails_semantic_logger/options"
 
   # Swap an existing subscriber with a new one
   def self.swap_subscriber(old_class, new_class, notifier)
@@ -30,14 +33,22 @@ module RailsSemanticLogger
   end
 
   def self.unattach(subscriber)
-    subscriber.patterns.each do |event|
-      ActiveSupport::Notifications.notifier.listeners_for(event).each do |sub|
+    subscriber_patterns(subscriber).each do |pattern|
+      ActiveSupport::Notifications.notifier.listeners_for(pattern).each do |sub|
         next unless sub.instance_variable_get(:@delegate) == subscriber
+
         ActiveSupport::Notifications.unsubscribe(sub)
       end
     end
 
     ActiveSupport::LogSubscriber.subscribers.delete(subscriber)
   end
-  private_class_method :unattach
+
+  def self.subscriber_patterns(subscriber)
+    subscriber.patterns.respond_to?(:keys) ?
+      subscriber.patterns.keys :
+      subscriber.patterns
+  end
+
+  private_class_method :subscriber_patterns, :unattach
 end

data/lib/rails_semantic_logger/action_controller/log_subscriber.rb

@@ -37,14 +37,21 @@ module RailsSemanticLogger
             payload[key] = payload[key].to_f.round(2) if key.to_s =~ /(.*)_runtime/
           end
 
+          # Rails 6+ includes allocation count
+          payload[:allocations] = event.allocations if event.respond_to?(:allocations)
+
           payload[:status_message] = ::Rack::Utils::HTTP_STATUS_CODES[payload[:status]] if payload[:status].present?
+
           # Causes excessive log output with Rails 5 RC1
           payload.delete(:headers)
+          # Causes recursion in Rails 6.1.rc1
+          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']
+            params["file"] = params["file"].inspect if params["file"]
           end
 
           {
@@ -60,15 +67,15 @@ module RailsSemanticLogger
       end
 
       def send_file(event)
-        controller_logger(event).info(message: 'Sent file', payload: {path: event.payload[:path]}, duration: event.duration)
+        controller_logger(event).info(message: "Sent file", payload: {path: event.payload[:path]}, duration: event.duration)
       end
 
       def redirect_to(event)
-        controller_logger(event).info(message: 'Redirected to', payload: {location: event.payload[:location]})
+        controller_logger(event).info(message: "Redirected to", payload: {location: event.payload[:location]})
       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)
@@ -106,7 +113,7 @@ module RailsSemanticLogger
       end
 
       def extract_path(path)
-        index = path.index('?')
+        index = path.index("?")
         index ? path[0, index] : path
       end
     end

data/lib/rails_semantic_logger/action_view/log_subscriber.rb

@@ -1,10 +1,10 @@
-require 'active_support/log_subscriber'
+require "active_support/log_subscriber"
 
 module RailsSemanticLogger
   module ActionView
     # Output Semantic logs from Action View.
     class LogSubscriber < ActiveSupport::LogSubscriber
-      VIEWS_PATTERN = /^app\/views\//
+      VIEWS_PATTERN = %r{^app/views/}.freeze
 
       class << self
         attr_reader :logger
@@ -19,14 +19,15 @@ module RailsSemanticLogger
       def render_template(event)
         return unless should_log?
 
-        payload          = {
+        payload = {
           template: from_rails_root(event.payload[:identifier])
         }
         payload[:within] = from_rails_root(event.payload[:layout]) if event.payload[:layout]
+        payload[:allocations] = event.allocations if event.respond_to?(:allocations)
 
         logger.measure(
           self.class.rendered_log_level,
-          'Rendered',
+          "Rendered",
           payload:  payload,
           duration: event.duration
         )
@@ -35,15 +36,16 @@ module RailsSemanticLogger
       def render_partial(event)
         return unless should_log?
 
-        payload          = {
+        payload = {
           partial: from_rails_root(event.payload[:identifier])
         }
         payload[:within] = from_rails_root(event.payload[:layout]) if event.payload[:layout]
         payload[:cache]  = payload[:cache_hit] unless event.payload[:cache_hit].nil?
+        payload[:allocations] = event.allocations if event.respond_to?(:allocations)
 
         logger.measure(
           self.class.rendered_log_level,
-          'Rendered',
+          "Rendered",
           payload:  payload,
           duration: event.duration
         )
@@ -52,28 +54,29 @@ module RailsSemanticLogger
       def render_collection(event)
         return unless should_log?
 
-        identifier = event.payload[:identifier] || 'templates'
+        identifier = event.payload[:identifier] || "templates"
 
-        payload              = {
+        payload = {
           template: from_rails_root(identifier),
           count:    event.payload[:count]
         }
         payload[:cache_hits] = payload[:cache_hits] if payload[:cache_hits]
+        payload[:allocations] = event.allocations if event.respond_to?(:allocations)
 
         logger.measure(
           self.class.rendered_log_level,
-          'Rendered',
+          "Rendered",
           payload:  payload,
           duration: event.duration
         )
       end
 
       def start(name, id, payload)
-        if (name == 'render_template.action_view') && should_log?
+        if (name == "render_template.action_view") && should_log?
           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", payload: payload)
         end
 
         super
@@ -81,10 +84,10 @@ module RailsSemanticLogger
 
       private
 
-      @logger             = SemanticLogger['ActionView']
+      @logger             = SemanticLogger["ActionView"]
       @rendered_log_level = :debug
 
-      EMPTY = ''.freeze
+      EMPTY = "".freeze
 
       def should_log?
         logger.send("#{self.class.rendered_log_level}?")

data/lib/rails_semantic_logger/active_job/log_subscriber.rb

@@ -0,0 +1,121 @@
+require "active_job"
+
+module RailsSemanticLogger
+  module ActiveJob
+    class LogSubscriber < ::ActiveSupport::LogSubscriber
+      def enqueue(event)
+        log_with_formatter event: event do |fmt|
+          "Enqueued #{fmt.job_info}"
+        end
+      end
+
+      def enqueue_at(event)
+        log_with_formatter event: event do |fmt|
+          "Enqueued #{fmt.job_info} at #{fmt.scheduled_at}"
+        end
+      end
+
+      def perform_start(event)
+        log_with_formatter event: event do |fmt|
+          "Performing #{fmt.job_info}"
+        end
+      end
+
+      def perform(event)
+        ex = event.payload[:exception_object]
+        if ex
+          logger.error ex
+        else
+          log_with_formatter event: event, log_duration: true do |fmt|
+            "Performed #{fmt.job_info} in #{event.duration.round(2)}ms"
+          end
+        end
+      end
+
+      private
+
+      class EventFormatter
+        def initialize(event:, log_duration: false)
+          @event = event
+          @log_duration = log_duration
+        end
+
+        def job_info
+          "#{job.class.name} (Job ID: #{job.job_id}) to #{queue_name}"
+        end
+
+        def payload
+          {}.tap do |h|
+            h[:event_name]      = event.name
+            h[:adapter]         = adapter_name
+            h[:queue]           = job.queue_name
+            h[:job_class]       = job.class.name
+            h[:job_id]          = job.job_id
+            h[:provider_job_id] = job.try(:provider_job_id) # Not available in Rails 4.2
+            h[:duration]        = event.duration.round(2) if log_duration?
+            h[:arguments]       = formatted_args
+          end
+        end
+
+        def queue_name
+          adapter_name + "(#{job.queue_name})"
+        end
+
+        def scheduled_at
+          Time.at(event.payload[:job].scheduled_at).utc
+        end
+
+        private
+
+        attr_reader :event
+
+        def job
+          event.payload[:job]
+        end
+
+        def adapter_name
+          event.payload[:adapter].class.name.demodulize.remove("Adapter")
+        end
+
+        def formatted_args
+          if defined?(job.class.log_arguments?) && !job.class.log_arguments?
+            ""
+          else
+            JSON.pretty_generate(job.arguments.map { |arg| format(arg) })
+          end
+        end
+
+        def format(arg)
+          case arg
+          when Hash
+            arg.transform_values { |value| format(value) }
+          when Array
+            arg.map { |value| format(value) }
+          when GlobalID::Identification
+            begin
+              arg.to_global_id
+            rescue StandardError
+              arg
+            end
+          else
+            arg
+          end
+        end
+
+        def log_duration?
+          @log_duration
+        end
+      end
+
+      def log_with_formatter(**kw_args)
+        fmt = EventFormatter.new(**kw_args)
+        msg = yield fmt
+        logger.info msg, fmt.payload
+      end
+
+      def logger
+        ::ActiveJob::Base.logger
+      end
+    end
+  end
+end

data/lib/rails_semantic_logger/active_record/log_subscriber.rb

@@ -31,6 +31,7 @@ module RailsSemanticLogger
 
         log_payload         = {sql: payload[:sql]}
         log_payload[:binds] = bind_values(payload) unless (payload[:binds] || []).empty?
+        log_payload[:allocations] = event.allocations if event.respond_to?(:allocations)
 
         log = {
           message:  name,
@@ -48,11 +49,11 @@ module RailsSemanticLogger
 
       private
 
-      @logger = SemanticLogger['ActiveRecord']
+      @logger = SemanticLogger["ActiveRecord"]
 
       # When multiple values are received for a single bound field, it is converted into an array
       def add_bind_value(binds, key, value)
-        key        = key.downcase.to_sym
+        key        = key.downcase.to_sym unless key.nil?
         value      = (Array(binds[key]) << value) if binds.key?(key)
         binds[key] = value
       end
@@ -115,12 +116,22 @@ module RailsSemanticLogger
         binds
       end
 
+      def bind_values_v6_1(payload)
+        binds         = {}
+        casted_params = type_casted_binds(payload[:type_casted_binds])
+        payload[:binds].each_with_index do |attr, i|
+          attr_name, value = render_bind(attr, casted_params[i])
+          add_bind_value(binds, attr_name, value)
+        end
+        binds
+      end
+
       def render_bind_v4_2(column, value)
         if column
           if column.binary?
             # This specifically deals with the PG adapter that casts bytea columns into a Hash.
             value = value[:value] if value.is_a?(Hash)
-            value = value ? "<#{value.bytesize} bytes of binary data>" : '<NULL binary data>'
+            value = value ? "<#{value.bytesize} bytes of binary data>" : "<NULL binary data>"
           end
 
           [column.name, value]
@@ -154,6 +165,21 @@ module RailsSemanticLogger
         [attr&.name, value]
       end
 
+      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
+        when Array
+          attr = attr.first
+        else
+          attr = nil
+        end
+
+        [attr&.name, value]
+      end
+
       def type_casted_binds_v5_0_3(binds, casted_binds)
         casted_binds || ::ActiveRecord::Base.connection.type_casted_binds(binds)
       end
@@ -171,6 +197,10 @@ module RailsSemanticLogger
         alias bind_values bind_values_v5_0_3
         alias render_bind render_bind_v5_0_3
         alias type_casted_binds type_casted_binds_v5_0_3
+      elsif Rails::VERSION::MAJOR == 6 && Rails::VERSION::MINOR > 0 # ~> 6.1.0
+        alias bind_values bind_values_v6_1
+        alias render_bind render_bind_v6_1
+        alias type_casted_binds type_casted_binds_v5_1_5
       elsif Rails::VERSION::MAJOR >= 5 # ~> 5.1.5 && ~> 5.0.7 && 6.x.x
         alias bind_values bind_values_v5_1_5
         alias render_bind render_bind_v5_0_3

data/lib/rails_semantic_logger/delayed_job/plugin.rb

@@ -2,7 +2,7 @@ module RailsSemanticLogger
   module DelayedJob
     class Plugin < Delayed::Plugin
       callbacks do |lifecycle|
-        lifecycle.before(:execute) do |job, &block|
+        lifecycle.before(:execute) do |_job|
           ::SemanticLogger.reopen
         end
       end

data/lib/rails_semantic_logger/engine.rb

@@ -1,6 +1,7 @@
-require 'rails'
-require 'action_controller/log_subscriber'
-require 'rails_semantic_logger/options'
+require "rails"
+require "action_controller/log_subscriber"
+require "action_view/log_subscriber"
+require "rails_semantic_logger/options"
 
 module RailsSemanticLogger
   class Engine < ::Rails::Engine
@@ -41,53 +42,54 @@ module RailsSemanticLogger
 
       # Existing loggers are ignored because servers like trinidad supply their
       # own file loggers which would result in duplicate logging to the same log file
-      Rails.logger = config.logger = begin
-        if config.rails_semantic_logger.add_file_appender
-          path = config.paths['log'].first
-          FileUtils.mkdir_p(File.dirname(path)) unless File.exist?(File.dirname(path))
-
-          # Add the log file to the list of appenders
-          # Use the colorized formatter if Rails colorized logs are enabled
-          ap_options = config.rails_semantic_logger.ap_options
-          formatter  = config.rails_semantic_logger.format
-          formatter  = {color: {ap: ap_options}} if (formatter == :default) && (config.colorize_logging != false)
-
-          # Set internal logger to log to file only, in case another appender experiences errors during writes
-          appender = SemanticLogger::Appender::File.new(
-            file_name: path,
-            level:     config.log_level,
-            formatter: formatter
+      Rails.logger = config.logger =
+        begin
+          if config.rails_semantic_logger.add_file_appender
+            path = config.paths["log"].first
+            FileUtils.mkdir_p(File.dirname(path)) unless File.exist?(File.dirname(path))
+
+            # Add the log file to the list of appenders
+            # Use the colorized formatter if Rails colorized logs are enabled
+            ap_options = config.rails_semantic_logger.ap_options
+            formatter  = config.rails_semantic_logger.format
+            formatter  = {color: {ap: ap_options}} if (formatter == :default) && (config.colorize_logging != false)
+
+            # Set internal logger to log to file only, in case another appender experiences errors during writes
+            appender                         = SemanticLogger::Appender::File.new(
+              file_name: path,
+              level:     config.log_level,
+              formatter: formatter
+            )
+            appender.name                    = "SemanticLogger"
+            SemanticLogger::Processor.logger = appender
+
+            # Check for previous file or stdout loggers
+            SemanticLogger.appenders.each { |app| app.formatter = formatter if app.is_a?(SemanticLogger::Appender::File) }
+            SemanticLogger.add_appender(file_name: path, formatter: formatter, filter: config.rails_semantic_logger.filter)
+          end
+
+          SemanticLogger[Rails]
+        rescue StandardError => e
+          # If not able to log to file, log to standard error with warning level only
+          SemanticLogger.default_level = :warn
+
+          SemanticLogger::Processor.logger = SemanticLogger::Appender::File.new(io: STDERR)
+          SemanticLogger.add_appender(io: STDERR)
+
+          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.",
+            e
           )
-          appender.name                    = 'SemanticLogger'
-          SemanticLogger::Processor.logger = appender
-
-          # Check for previous file or stdout loggers
-          SemanticLogger.appenders.each { |app| app.formatter = formatter if app.is_a?(SemanticLogger::Appender::File) }
-          SemanticLogger.add_appender(file_name: path, formatter: formatter, filter: config.rails_semantic_logger.filter)
+          logger
         end
 
-        SemanticLogger[Rails]
-      rescue StandardError => exc
-        # If not able to log to file, log to standard error with warning level only
-        SemanticLogger.default_level = :warn
-
-        SemanticLogger::Processor.logger = SemanticLogger::Appender::File.new(io: STDERR)
-        SemanticLogger.add_appender(io: STDERR)
-
-        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.',
-          exc
-        )
-        logger
-      end
-
       # Replace Rails loggers
       %i[active_record action_controller action_mailer action_view].each do |name|
         ActiveSupport.on_load(name) { include SemanticLogger::Loggable }
       end
-      ActiveSupport.on_load(:action_cable) { self.logger = SemanticLogger['ActionCable'] }
+      ActiveSupport.on_load(:action_cable) { self.logger = SemanticLogger["ActionCable"] }
     end
 
     # Before any initializers run, but after the gems have been loaded
@@ -100,18 +102,18 @@ module RailsSemanticLogger
       end
 
       # Replace the Mongo Loggers
-      Mongoid.logger          = SemanticLogger[Mongoid] if defined?(Mongoid)
-      Moped.logger            = SemanticLogger[Moped] if defined?(Moped)
-      Mongo::Logger.logger    = SemanticLogger[Mongo] if defined?(Mongo::Logger)
+      Mongoid.logger       = SemanticLogger[Mongoid] if defined?(Mongoid)
+      Moped.logger         = SemanticLogger[Moped] if defined?(Moped)
+      Mongo::Logger.logger = SemanticLogger[Mongo] if defined?(Mongo::Logger)
 
       # Replace the Resque Logger
-      Resque.logger           = SemanticLogger[Resque] if defined?(Resque) && Resque.respond_to?(:logger)
+      Resque.logger        = SemanticLogger[Resque] if defined?(Resque) && Resque.respond_to?(:logger)
 
       # Replace the Sidekiq logger
-      Sidekiq::Logging.logger = SemanticLogger[Sidekiq] if defined?(Sidekiq)
+      Sidekiq.logger       = SemanticLogger[Sidekiq] if defined?(Sidekiq)
 
       # Replace the Sidetiq logger
-      Sidetiq.logger          = SemanticLogger[Sidetiq] if defined?(Sidetiq)
+      Sidetiq.logger       = SemanticLogger[Sidetiq] if defined?(Sidetiq)
 
       # Replace the DelayedJob logger
       if defined?(Delayed::Worker)
@@ -129,17 +131,36 @@ module RailsSemanticLogger
       Bugsnag.configure { |config| 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)
-      require('rails_semantic_logger/extensions/action_view/streaming_template_renderer') if defined?(ActionView::StreamingTemplateRenderer::Body)
-      require('rails_semantic_logger/extensions/active_job/logging') if defined?(ActiveJob)
-      require('rails_semantic_logger/extensions/active_model_serializers/logging') if defined?(ActiveModelSerializers)
+      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?(ActionView::StreamingTemplateRenderer::Body)
+        require("rails_semantic_logger/extensions/action_view/streaming_template_renderer")
+      end
+      require("rails_semantic_logger/extensions/active_job/logging") if defined?(::ActiveJob)
+      require("rails_semantic_logger/extensions/active_model_serializers/logging") if defined?(ActiveModelSerializers)
 
       if config.rails_semantic_logger.semantic
+        # Active Job
+        if defined?(::ActiveJob) && defined?(::ActiveJob::Logging::LogSubscriber)
+          RailsSemanticLogger.swap_subscriber(
+            ::ActiveJob::Logging::LogSubscriber,
+            RailsSemanticLogger::ActiveJob::LogSubscriber,
+            :active_job
+          )
+        end
+
+        if defined?(::ActiveJob) && defined?(::ActiveJob::LogSubscriber)
+          RailsSemanticLogger.swap_subscriber(
+            ::ActiveJob::LogSubscriber,
+            RailsSemanticLogger::ActiveJob::LogSubscriber,
+            :active_job
+          )
+        end
+
         # Active Record
         if defined?(::ActiveRecord)
-          require 'active_record/log_subscriber'
+          require "active_record/log_subscriber"
 
           RailsSemanticLogger.swap_subscriber(
             ::ActiveRecord::LogSubscriber,
@@ -189,7 +210,7 @@ module RailsSemanticLogger
       Resque.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Resque)
 
       # Re-open appenders after Spring has forked a process
-      Spring.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Spring)
+      Spring.after_fork { |_job| ::SemanticLogger.reopen } if defined?(Spring.after_fork)
     end
   end
 end

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

@@ -1,5 +1,5 @@
 # Patch ActiveJob logger
-require 'active_job/logging'
+require "active_job/logging"
 
 module ActiveJob
   module Logging
@@ -10,126 +10,5 @@ module ActiveJob
     def tag_logger(*tags, &block)
       logger.tagged(*tags, &block)
     end
-
-    class LogSubscriber < ActiveSupport::LogSubscriber
-      def enqueue(event)
-        log_with_formatter event: event do |fmt|
-          "Enqueued #{fmt.job_info}"
-        end
-      end
-
-      def enqueue_at(event)
-        log_with_formatter event: event do |fmt|
-          "Enqueued #{fmt.job_info} at #{fmt.scheduled_at}"
-        end
-      end
-
-      def perform_start(event)
-        log_with_formatter event: event do |fmt|
-          "Performing #{fmt.job_info}"
-        end
-      end
-
-      def perform(event)
-        ex = event.payload[:exception_object]
-        if ex
-          logger.error ex
-        else
-          log_with_formatter event: event, log_duration: true do |fmt|
-            "Performed #{fmt.job_info} in #{event.duration.round(2)}ms"
-          end
-        end
-      end
-
-      private
-
-      class EventFormatter
-        def initialize(event:, log_duration: false)
-          @event = event
-          @log_duration = log_duration
-        end
-
-        def job_info
-          "#{job.class.name} (Job ID: #{job.job_id}) to #{queue_name}"
-        end
-
-        def payload
-          {}.tap do |h|
-            h[:event_name]      = event.name
-            h[:adapter]         = adapter_name
-            h[:queue]           = job.queue_name
-            h[:job_class]       = job.class.name
-            h[:job_id]          = job.job_id
-            h[:provider_job_id] = job.try(:provider_job_id) # Not available in Rails 4.2
-            h[:duration]        = event.duration.round(2) if log_duration?
-            h[:arguments]       = formatted_args
-          end
-        end
-
-        def queue_name
-          adapter_name + "(#{job.queue_name})"
-        end
-
-        def scheduled_at
-          Time.at(event.payload[:job].scheduled_at).utc
-        end
-
-        private
-
-        attr_reader :event
-
-        def job
-          event.payload[:job]
-        end
-
-        def adapter_name
-          event.payload[:adapter].class.name.demodulize.remove('Adapter')
-        end
-
-        def formatted_args
-          JSON.pretty_generate(job.arguments.map { |arg| format(arg) })
-        end
-
-        def format(arg)
-          case arg
-          when Hash
-            arg.transform_values { |value| format(value) }
-          when Array
-            arg.map { |value| format(value) }
-          when GlobalID::Identification
-            begin
-              arg.to_global_id
-            rescue StandardError
-              arg
-            end
-          else
-            arg
-          end
-        end
-
-        def log_duration?
-          @log_duration
-        end
-      end
-
-      def log_with_formatter(**kw_args)
-        fmt = EventFormatter.new(**kw_args)
-        msg = yield fmt
-        logger.info msg, fmt.payload
-      end
-
-      def logger
-        ActiveJob::Base.logger
-      end
-    end
   end
 end
-
-if defined?(ActiveSupport::Notifications)
-  ActiveSupport::Notifications.unsubscribe('perform_start.active_job')
-  ActiveSupport::Notifications.unsubscribe('perform.active_job')
-  ActiveSupport::Notifications.unsubscribe('enqueue_at.active_job')
-  ActiveSupport::Notifications.unsubscribe('enqueue.active_job')
-
-  ActiveJob::Logging::LogSubscriber.attach_to :active_job
-end

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

@@ -1,5 +1,5 @@
 # Patch ActiveModelSerializers logger
-require 'active_model_serializers/logging'
+require "active_model_serializers/logging"
 
 module ActiveModelSerializers
   module Logging

data/lib/rails_semantic_logger/rack/logger.rb

@@ -1,8 +1,8 @@
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/object/blank'
-require 'active_support/log_subscriber'
-require 'action_dispatch/http/request'
-require 'rack/body_proxy'
+require "active_support/core_ext/time/conversions"
+require "active_support/core_ext/object/blank"
+require "active_support/log_subscriber"
+require "action_dispatch/http/request"
+require "rack/body_proxy"
 
 module RailsSemanticLogger
   module Rack
@@ -31,12 +31,12 @@ module RailsSemanticLogger
 
       private
 
-      @logger                    = SemanticLogger['Rack']
+      @logger                    = SemanticLogger["Rack"]
       @started_request_log_level = :debug
 
       def call_app(request, env)
         instrumenter = ActiveSupport::Notifications.instrumenter
-        instrumenter.start 'request.action_dispatch', request: request
+        instrumenter.start "request.action_dispatch", request: request
 
         logger.send(self.class.started_request_log_level) { started_request_message(request) }
 
@@ -50,7 +50,7 @@ module RailsSemanticLogger
 
       def started_request_message(request)
         {
-          message: 'Started',
+          message: "Started",
           payload: {
             method: request.request_method,
             path:   request.filtered_path,
@@ -92,7 +92,7 @@ module RailsSemanticLogger
 
       def finish(request)
         instrumenter = ActiveSupport::Notifications.instrumenter
-        instrumenter.finish 'request.action_dispatch', request: request
+        instrumenter.finish "request.action_dispatch", request: request
       end
 
       def logger

data/lib/rails_semantic_logger/version.rb

@@ -1,3 +1,3 @@
 module RailsSemanticLogger
-  VERSION = '4.4.2'.freeze
+  VERSION = "4.5.0".freeze
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rails_semantic_logger
 version: !ruby/object:Gem::Version
-  version: 4.4.2
+  version: 4.5.0
 platform: ruby
 authors:
 - Reid Morrison
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-07-12 00:00:00.000000000 Z
+date: 2021-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: railties
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: semantic_logger
   requirement: !ruby/object:Gem::Requirement
@@ -52,7 +52,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.4'
-description: 
+description:
 email:
 - reidmo@gmail.com
 executables: []
@@ -65,6 +65,7 @@ files:
 - lib/rails_semantic_logger.rb
 - lib/rails_semantic_logger/action_controller/log_subscriber.rb
 - 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/engine.rb
@@ -82,7 +83,7 @@ homepage: https://github.com/rocketjob/rails_semantic_logger
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -97,8 +98,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Feature rich logging framework that replaces the Rails logger.
 test_files: []