rails_semantic_logger 4.20.0 → 5.0.0

data/lib/rails_semantic_logger/action_view/log_subscriber.rb

@@ -1,10 +1,22 @@
 require "active_support/log_subscriber"
 
+# This subscriber is a reimplementation of Rails' own ActionView::LogSubscriber that emits
+# structured (message + payload) log entries instead of formatted text. When Rails changes its
+# subscriber, those changes must be brought across here. Compare against the upstream source for
+# each supported Rails version:
+#
+#   Rails 8.1: https://github.com/rails/rails/blob/8-1-stable/actionview/lib/action_view/log_subscriber.rb
+#   Rails 8.0: https://github.com/rails/rails/blob/8-0-stable/actionview/lib/action_view/log_subscriber.rb
+#   Rails 7.2: https://github.com/rails/rails/blob/7-2-stable/actionview/lib/action_view/log_subscriber.rb
+#
+# As of these versions the upstream subscriber is identical across 7.2, 8.0, and 8.1, so no
+# version-specific behavior is required here.
+#
 module RailsSemanticLogger
   module ActionView
     # Output Semantic logs from Action View.
     class LogSubscriber < ActiveSupport::LogSubscriber
-      VIEWS_PATTERN = %r{^app/views/}.freeze
+      VIEWS_PATTERN = %r{^app/views/}
 
       class << self
         attr_reader :logger
@@ -23,13 +35,15 @@ module RailsSemanticLogger
           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)
+        payload[:allocations] = event.allocations
+        payload[:gc_time]     = event.gc_time.round(2) if event.respond_to?(:gc_time)
 
         logger.measure(
           self.class.rendered_log_level,
           "Rendered",
           payload:  payload,
-          duration: event.duration
+          duration: event.duration,
+          metric:   "rails.view.render.template"
         )
       end
 
@@ -41,13 +55,33 @@ module RailsSemanticLogger
         }
         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)
+        payload[:allocations] = event.allocations
+        payload[:gc_time]     = event.gc_time.round(2) if event.respond_to?(:gc_time)
 
         logger.measure(
           self.class.rendered_log_level,
           "Rendered",
           payload:  payload,
-          duration: event.duration
+          duration: event.duration,
+          metric:   "rails.view.render.partial"
+        )
+      end
+
+      def render_layout(event)
+        return unless should_log?
+
+        payload = {
+          template: from_rails_root(event.payload[:identifier])
+        }
+        payload[:allocations] = event.allocations
+        payload[:gc_time]     = event.gc_time.round(2) if event.respond_to?(:gc_time)
+
+        logger.measure(
+          self.class.rendered_log_level,
+          "Rendered layout",
+          payload:  payload,
+          duration: event.duration,
+          metric:   "rails.view.render.layout"
         )
       end
 
@@ -61,13 +95,15 @@ module RailsSemanticLogger
           count:    event.payload[:count]
         }
         payload[:cache_hits]  = event.payload[:cache_hits] if event.payload[:cache_hits]
-        payload[:allocations] = event.allocations if event.respond_to?(:allocations)
+        payload[:allocations] = event.allocations
+        payload[:gc_time]     = event.gc_time.round(2) if event.respond_to?(:gc_time)
 
         logger.measure(
           self.class.rendered_log_level,
           "Rendered",
           payload:  payload,
-          duration: event.duration
+          duration: event.duration,
+          metric:   "rails.view.render.collection"
         )
       end
 
@@ -83,53 +119,51 @@ module RailsSemanticLogger
         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)
+      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]
+          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
+          logger.debug(message: "Rendering#{qualifier}", payload: payload)
+        end
 
-          def finish(name, id, payload)
-          end
+        def finish(name, id, payload)
+        end
 
-          private
+        private
 
-          def from_rails_root(string)
-            string = string.sub(rails_root, "")
-            string.sub!(VIEWS_PATTERN, "")
-            string
-          end
+        def from_rails_root(string)
+          string = string.sub(rails_root, "")
+          string.sub!(VIEWS_PATTERN, "")
+          string
+        end
 
-          def rails_root
-            @root ||= "#{Rails.root}/"
-          end
+        def rails_root
+          @root ||= "#{Rails.root}/"
+        end
 
-          def logger
-            @logger ||= SemanticLogger["ActionView"]
-          end
+        def logger
+          @logger ||= ::ActionView::Base.logger
         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)
+      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
+        super
       end
 
       private
 
-      @logger             = SemanticLogger["ActionView"]
+      @logger             = ::ActionView::Base.logger
       @rendered_log_level = :debug
 
       EMPTY = "".freeze

data/lib/rails_semantic_logger/active_job/log_subscriber.rb

@@ -1,10 +1,27 @@
 require "active_job"
 
+# This subscriber is a reimplementation of Rails' own ActiveJob::LogSubscriber that emits
+# structured (message + payload) log entries instead of formatted text. When Rails changes its
+# subscriber, those changes must be brought across here. Compare against the upstream source for
+# each supported Rails version:
+#
+#   Rails 8.1: https://github.com/rails/rails/blob/8-1-stable/activejob/lib/active_job/log_subscriber.rb
+#   Rails 8.0: https://github.com/rails/rails/blob/8-0-stable/activejob/lib/active_job/log_subscriber.rb
+#   Rails 7.2: https://github.com/rails/rails/blob/7-2-stable/activejob/lib/active_job/log_subscriber.rb
+#
+# Event coverage by Rails version:
+#   7.2 / 8.0: enqueue, enqueue_at, enqueue_all, perform_start, perform,
+#              enqueue_retry, retry_stopped, discard
+#   8.1 adds (ActiveJob Continuations): interrupt, resume, step_skipped, step_started, step
+#
+# The Continuation handlers are defined unconditionally. On Rails < 8.1 those notifications are
+# never emitted, so the extra methods are simply never invoked.
+#
 module RailsSemanticLogger
   module ActiveJob
     class LogSubscriber < ::ActiveSupport::LogSubscriber
       def enqueue(event)
-        ex = event.payload[:exception_object]
+        ex = enqueue_error(event)
 
         if ex
           log_with_formatter level: :error, event: event do |fmt|
@@ -25,7 +42,7 @@ module RailsSemanticLogger
       end
 
       def enqueue_at(event)
-        ex = event.payload[:exception_object]
+        ex = enqueue_error(event)
 
         if ex
           log_with_formatter level: :error, event: event do |fmt|
@@ -60,6 +77,11 @@ module RailsSemanticLogger
               exception: ex
             }
           end
+        elsif event.payload[:aborted]
+          log_with_formatter event: event, log_duration: true, level: :error do |fmt|
+            {message: "Error performing #{fmt.job_info} in #{event.duration.round(2)}ms: " \
+                      "a before_perform callback halted the job execution"}
+          end
         else
           log_with_formatter event: event, log_duration: true do |fmt|
             {message: "Performed #{fmt.job_info} in #{event.duration.round(2)}ms"}
@@ -67,8 +89,177 @@ module RailsSemanticLogger
         end
       end
 
+      def enqueue_retry(event)
+        ex   = event.payload[:error]
+        wait = event.payload[:wait]
+
+        log_with_formatter level: :info, event: event do |fmt|
+          base    = "Retrying #{fmt.job_info} after #{fmt.executions} attempts in #{wait.to_i} seconds"
+          message = ex ? "#{base}, due to a #{ex.class} (#{ex.message})." : "#{base}."
+
+          {
+            message:   message,
+            exception: ex,
+            payload:   {executions: fmt.executions, wait: wait.to_i}
+          }
+        end
+      end
+
+      def retry_stopped(event)
+        ex = event.payload[:error]
+
+        log_with_formatter level: :error, event: event do |fmt|
+          {
+            message:   "Stopped retrying #{fmt.job_info} due to a #{ex.class} (#{ex.message}), " \
+                       "which reoccurred on #{fmt.executions} attempts.",
+            exception: ex,
+            payload:   {executions: fmt.executions}
+          }
+        end
+      end
+
+      def discard(event)
+        ex = event.payload[:error]
+
+        log_with_formatter level: :error, event: event do |fmt|
+          {
+            message:   "Discarded #{fmt.job_info} due to a #{ex.class} (#{ex.message}).",
+            exception: ex
+          }
+        end
+      end
+
+      # ActiveJob Continuations (Rails 8.1+)
+
+      def interrupt(event)
+        description = event.payload[:description]
+        reason      = event.payload[:reason]
+
+        log_with_formatter level: :info, event: event do |fmt|
+          {
+            message: "Interrupted #{fmt.job_info} #{description} (#{reason})",
+            payload: {description: description, reason: reason}
+          }
+        end
+      end
+
+      def resume(event)
+        description = event.payload[:description]
+
+        log_with_formatter level: :info, event: event do |fmt|
+          {
+            message: "Resuming #{fmt.job_info} #{description}",
+            payload: {description: description}
+          }
+        end
+      end
+
+      def step_skipped(event)
+        step = event.payload[:step]
+
+        log_with_formatter level: :info, event: event do |fmt|
+          {
+            message: "Step '#{step.name}' skipped for #{fmt.job_info}",
+            payload: {step_name: step.name}
+          }
+        end
+      end
+
+      def step_started(event)
+        step = event.payload[:step]
+
+        log_with_formatter level: :info, event: event do |fmt|
+          message =
+            if step.resumed?
+              "Step '#{step.name}' resumed from cursor '#{step.cursor}' for #{fmt.job_info}"
+            else
+              "Step '#{step.name}' started for #{fmt.job_info}"
+            end
+
+          {
+            message: message,
+            payload: {step_name: step.name, step_cursor: step.cursor}
+          }
+        end
+      end
+
+      def step(event)
+        step = event.payload[:step]
+        ex   = event.payload[:exception_object]
+
+        if event.payload[:interrupted]
+          log_with_formatter level: :info, event: event, log_duration: true do |fmt|
+            {
+              message: "Step '#{step.name}' interrupted at cursor '#{step.cursor}' for " \
+                       "#{fmt.job_info} in #{event.duration.round(2)}ms",
+              payload: {step_name: step.name, step_cursor: step.cursor}
+            }
+          end
+        elsif ex
+          log_with_formatter level: :error, event: event, log_duration: true do |fmt|
+            {
+              message:   "Error during step '#{step.name}' at cursor '#{step.cursor}' for " \
+                         "#{fmt.job_info} in #{event.duration.round(2)}ms: #{ex.class} (#{ex.message})",
+              exception: ex,
+              payload:   {step_name: step.name, step_cursor: step.cursor}
+            }
+          end
+        else
+          log_with_formatter level: :info, event: event, log_duration: true do |fmt|
+            {
+              message: "Step '#{step.name}' completed for #{fmt.job_info} in #{event.duration.round(2)}ms",
+              payload: {step_name: step.name, step_cursor: step.cursor}
+            }
+          end
+        end
+      end
+
+      def enqueue_all(event)
+        jobs           = event.payload[:jobs]
+        adapter        = event.payload[:adapter]
+        enqueued_count = event.payload[:enqueued_count].to_i
+        adapter_name   = ::ActiveJob.adapter_name(adapter)
+        failed_count   = jobs.size - enqueued_count
+
+        message =
+          if failed_count.zero?
+            enqueued_jobs_message(adapter_name, jobs)
+          elsif jobs.any?(&:successfully_enqueued?)
+            "#{enqueued_jobs_message(adapter_name, jobs.select(&:successfully_enqueued?))}. " \
+              "Failed enqueuing #{failed_count} #{'job'.pluralize(failed_count)}"
+          else
+            "Failed enqueuing #{failed_count} #{'job'.pluralize(failed_count)} to #{adapter_name}"
+          end
+
+        logger.info(
+          message: message,
+          metric:  "rails.job.enqueue_all",
+          payload: {
+            event_name:     event.name,
+            adapter:        adapter_name,
+            enqueued_count: enqueued_count,
+            total_count:    jobs.size,
+            job_classes:    jobs.map { |job| job.class.name }.tally
+          }
+        )
+      end
+
       private
 
+      # Upstream records an enqueue failure either via the event's exception_object or via
+      # ActiveJob's job.enqueue_error. Prefer the former, fall back to the latter.
+      def enqueue_error(event)
+        event.payload[:exception_object] ||
+          (event.payload[:job].respond_to?(:enqueue_error) ? event.payload[:job].enqueue_error : nil)
+      end
+
+      def enqueued_jobs_message(adapter_name, enqueued_jobs)
+        enqueued_count     = enqueued_jobs.size
+        job_classes_counts = enqueued_jobs.map(&:class).tally.sort_by { |_k, v| -v }
+        "Enqueued #{enqueued_count} #{'job'.pluralize(enqueued_count)} to #{adapter_name} " \
+          "(#{job_classes_counts.map { |klass, count| "#{count} #{klass}" }.join(', ')})"
+      end
+
       class EventFormatter
         def initialize(event:, log_duration: false)
           @event = event
@@ -79,6 +270,9 @@ module RailsSemanticLogger
           "#{job.class.name} (Job ID: #{job.job_id}) to #{queue_name}"
         end
 
+        # Standard payload shared by every event. enqueued_at, scheduled_at, and duration are
+        # only present when applicable (the job was scheduled, has been enqueued, or the event
+        # carries a duration), so that handlers that do not have them never emit blank keys.
         def payload
           {}.tap do |h|
             h[:event_name]      = event.name
@@ -86,7 +280,9 @@ module RailsSemanticLogger
             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[:provider_job_id] = job.provider_job_id
+            h[:enqueued_at]     = job.enqueued_at if job.respond_to?(:enqueued_at) && job.enqueued_at.present?
+            h[:scheduled_at]    = scheduled_at if job.scheduled_at
             h[:duration]        = event.duration.round(2) if log_duration?
             h[:arguments]       = formatted_args
           end
@@ -97,7 +293,11 @@ module RailsSemanticLogger
         end
 
         def scheduled_at
-          Time.at(event.payload[:job].scheduled_at).utc
+          Time.at(job.scheduled_at).utc
+        end
+
+        def executions
+          job.executions
         end
 
         private
@@ -144,10 +344,19 @@ module RailsSemanticLogger
         end
       end
 
+      # Builds the structured log entry for an event. The block is given an EventFormatter and
+      # returns a hash with :message, an optional :exception, and an optional :payload of extra
+      # fields. Those extra fields are merged on top of the formatter's standard payload, so
+      # handlers can add event-specific keys (executions, wait, step_name, ...) without each
+      # having to rebuild the common job payload.
       def log_with_formatter(level: :info, **kw_args)
-        fmt = EventFormatter.new(**kw_args)
-        msg = yield fmt
-        logger.public_send(level, **msg, payload: fmt.payload)
+        fmt   = EventFormatter.new(**kw_args)
+        msg   = yield fmt
+        extra = msg.delete(:payload) || {}
+        # Emit a metric for every info/warn/error entry, named after the notification
+        # (e.g. "enqueue.active_job" -> "rails.job.enqueue"). Debug entries are excluded.
+        msg[:metric] ||= "rails.job.#{kw_args[:event].name.split('.').first}" unless level == :debug
+        logger.public_send(level, **msg, payload: fmt.payload.merge(extra))
       end
 
       def logger