logstruct 0.1.12 → 0.2.1

data/lib/log_struct/integrations/action_mailer/error_handling.rb

@@ -15,6 +15,63 @@ module LogStruct
         extend T::Sig
         extend ActiveSupport::Concern
 
+        # ActionMailer::MailDeliveryJob passes errors to the mailer class (`handle_exception`), which
+        # looks the rescue_from handlers up on the class, so the handlers are defined there too.
+        # (ActiveSupport::Concern extends the class with ClassMethods when it's included or prepended.)
+        module ClassMethods
+          extend T::Sig
+
+          # Logs the error, and doesn't report or raise it
+          sig { params(ex: StandardError).void }
+          def log_and_ignore_error(ex)
+            ErrorHandling.handle_mailer_class_error(self, ex, report: false, reraise: false)
+          end
+
+          # Logs and reports the error, and doesn't raise it
+          sig { params(ex: StandardError).void }
+          def log_and_report_error(ex)
+            ErrorHandling.handle_mailer_class_error(self, ex, report: true, reraise: false)
+          end
+
+          # Logs the error and raises it again, reporting it too in the Report modes
+          sig { params(ex: StandardError).void }
+          def log_and_reraise_error(ex)
+            ErrorHandling.handle_mailer_class_error(self, ex, report: ErrorHandling.report_before_reraise?, reraise: true)
+          end
+        end
+
+        # log_and_reraise_error reports the error where standard_errors' mode reports the app's errors
+        # (Report, and ReportProduction in production). Elsewhere whatever rescues the raised error decides.
+        sig { returns(T::Boolean) }
+        def self.report_before_reraise?
+          mode = LogStruct.error_handling_mode_for(Source::Mailer)
+          mode == ErrorHandlingMode::Report || (mode == ErrorHandlingMode::ReportProduction && LogStruct.is_production?)
+        end
+
+        # An error that reaches the class handler from the delivery itself was logged (and reported)
+        # by the mailer's handler, which raised it again (log_and_reraise_error). It's raised again,
+        # without logging it twice, so the job fails as deliver_now would.
+        sig { params(mailer_class: T.untyped, error: StandardError, report: T::Boolean, reraise: T::Boolean).void }
+        def self.handle_mailer_class_error(mailer_class, error, report:, reraise:)
+          Kernel.raise error if LogStruct::LoggedErrors.logged?(error)
+
+          message = if reraise
+            "#{error.class}: Email delivery failed. Error message: #{error.message}"
+          else
+            "#{error.class}: Cannot send email. Error message: #{error.message}"
+          end
+          LogStruct.error(Log::ActionMailer::Error.new(
+            mailer_class: mailer_class.to_s,
+            error_class: error.class,
+            message: message,
+            backtrace: error.backtrace,
+            level: Level::Error
+          ))
+          LogStruct.report_error(error, source: Source::Mailer, context: {mailer_class: mailer_class.to_s}) if report
+
+          Kernel.raise error if reraise
+        end
+
         sig { returns(T.nilable(T::Boolean)) }
         attr_accessor :logstruct_mail_failed
 
@@ -47,23 +104,23 @@ module LogStruct
 
         protected
 
-        # Just log the error without reporting or retrying
+        # Logs the error, and doesn't report or raise it
         sig { params(ex: StandardError).void }
         def log_and_ignore_error(ex)
           self.logstruct_mail_failed = true
           log_email_delivery_error(ex, notify: false, report: false, reraise: false)
         end
 
-        # Log and report to error service, but doesn't reraise.
+        # Logs and reports the error, and doesn't raise it
         sig { params(ex: StandardError).void }
         def log_and_report_error(ex)
           log_email_delivery_error(ex, notify: false, report: true, reraise: false)
         end
 
-        # Log, report to error service, and reraise for retry
+        # Logs the error and raises it again, reporting it too in the Report modes (report_before_reraise?)
         sig { params(ex: StandardError).void }
         def log_and_reraise_error(ex)
-          log_email_delivery_error(ex, notify: false, report: true, reraise: true)
+          log_email_delivery_error(ex, notify: false, report: ErrorHandling.report_before_reraise?, reraise: true)
         end
 
         private
@@ -101,7 +158,8 @@ module LogStruct
             message: message,
             backtrace: error.backtrace,
             additional_data: context_data.presence,
-            timestamp: Time.now
+            timestamp: Time.now,
+            level: Level::Error
           )
 
           # Log the structured error
@@ -127,8 +185,11 @@ module LogStruct
 
           # Use structured error logging
           log_structured_error(self, error, message)
+          # The mailer class handler gets the error if it's raised from here (re-raised, or raised by
+          # LogStruct.handle_exception in Raise mode), and mustn't log or report it again
+          LogStruct::LoggedErrors.mark(error)
 
-          # Handle notifications and reporting
+          # Handle notifications, reporting and raising
           handle_error_notifications(error, notify, report, reraise)
         end
 
@@ -136,7 +197,7 @@ module LogStruct
         sig { params(error: StandardError, reraise: T::Boolean).returns(String) }
         def error_message_for(error, reraise)
           if reraise
-            "#{error.class}: Email delivery error, will retry. Recipients: #{recipients(error)}. Error message: #{error.message}"
+            "#{error.class}: Email delivery failed. Recipients: #{recipients(error)}. Error message: #{error.message}"
           else
             "#{error.class}: Cannot send email to #{recipients(error)}. Error message: #{error.message}"
           end
@@ -148,21 +209,14 @@ module LogStruct
           # Log a notification event if requested
           log_notification_event(error) if notify
 
-          # Report to error reporting service if requested
+          # Report to error reporting service if requested. The structured error line is already logged.
           if report
-            context_data = {recipients: recipients(error)}
-            exception_data = build_exception_data(error, Level::Error, context_data)
-
-            # Log the exception with structured data
-            LogStruct.error(exception_data)
-
-            # Call the error handler with flat context for compatibility
             context = {
               mailer_class: self.class.to_s,
               mailer_action: respond_to?(:action_name) ? action_name : nil,
               recipients: recipients(error)
             }
-            LogStruct.handle_exception(error, source: Source::Mailer, context: context)
+            LogStruct.report_error(error, source: Source::Mailer, context: context)
           end
 
           # Re-raise the error if requested
@@ -214,14 +268,18 @@ module LogStruct
           )
         end
 
+        # The formatter scrubs the addresses in the line
         sig { params(error: StandardError).returns(String) }
         def recipients(error)
-          # Extract recipient info if available
+          # Some delivery errors (Postmark's, for example) have the recipients that failed
           if error.respond_to?(:recipients) && T.unsafe(error).recipients.present?
-            T.unsafe(error).recipients.join(", ")
-          else
-            "unknown"
+            return T.unsafe(error).recipients.join(", ")
           end
+
+          # Otherwise the mail's own: to, cc and bcc (unknown when the mailer failed before it built the mail)
+          mail = respond_to?(:message) ? message : nil
+          destinations = mail.respond_to?(:destinations) ? Array(mail.destinations).compact : []
+          destinations.empty? ? "unknown" : destinations.join(", ")
         end
       end
     end

data/lib/log_struct/integrations/action_mailer/fallback_error_handlers.rb

@@ -0,0 +1,81 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    module ActionMailer
+      # The error handlers a mailer can name in rescue_from (with: :log_and_ignore_error), for processes
+      # where LogStruct doesn't set up ActionMailer (development, the console and Rake tasks by default).
+      # Without them those mailers raised NameError there. Each logs the error with the mailer's logger,
+      # then ignores it, reports it to Rails.error, or raises it again, as its name says.
+      module FallbackErrorHandlers
+        extend T::Sig
+        extend T::Helpers
+
+        requires_ancestor { ::ActionMailer::Base }
+
+        class << self
+          extend T::Sig
+
+          sig { params(logger: T.untyped, error: StandardError, report: T::Boolean, reraise: T::Boolean).void }
+          def handle(logger, error, report:, reraise:)
+            logger&.error("#{error.class}: #{error.message}")
+            ::Rails.error.report(error, handled: true, source: "logstruct.action_mailer") if report
+            Kernel.raise error if reraise
+          end
+        end
+
+        # The handlers, for a mailer and (through ClassMethods) for the mailer class, which
+        # ActionMailer::MailDeliveryJob passes an error to. Both have a logger.
+        module Handlers
+          extend T::Sig
+          extend T::Helpers
+
+          abstract!
+
+          sig { params(ex: StandardError).void }
+          def log_and_ignore_error(ex)
+            FallbackErrorHandlers.handle(handler_logger, ex, report: false, reraise: false)
+          end
+
+          sig { params(ex: StandardError).void }
+          def log_and_report_error(ex)
+            FallbackErrorHandlers.handle(handler_logger, ex, report: true, reraise: false)
+          end
+
+          sig { params(ex: StandardError).void }
+          def log_and_reraise_error(ex)
+            FallbackErrorHandlers.handle(handler_logger, ex, report: false, reraise: true)
+          end
+
+          private
+
+          sig { abstract.returns(T.untyped) }
+          def handler_logger
+          end
+        end
+
+        include Handlers
+
+        module ClassMethods
+          extend T::Sig
+          extend T::Helpers
+
+          requires_ancestor { T.class_of(::ActionMailer::Base) }
+
+          include Handlers
+
+          private
+
+          sig { override.returns(T.untyped) }
+          def handler_logger = logger
+        end
+
+        private
+
+        sig { override.returns(T.untyped) }
+        def handler_logger = logger
+      end
+    end
+  end
+end

data/lib/log_struct/integrations/action_mailer/metadata_collection.rb

@@ -25,9 +25,6 @@ module LogStruct
         def self.add_context_metadata(mailer, log_data)
           # Add account ID information if available (but not user email)
           extract_ids_to_log_data(mailer, log_data)
-
-          # Add any current tags from ActiveJob or ActionMailer
-          add_current_tags_to_log_data(log_data)
         end
 
         sig { params(mailer: T.untyped, log_data: T::Hash[Symbol, T.untyped]).void }
@@ -43,23 +40,6 @@ module LogStruct
             log_data[log_key] = obj.id if obj.respond_to?(:id)
           end
         end
-
-        sig { params(log_data: T::Hash[Symbol, T.untyped]).void }
-        def self.add_current_tags_to_log_data(log_data)
-          # Get current tags from thread-local storage or ActiveSupport::TaggedLogging
-          tags = if ::ActiveSupport::TaggedLogging.respond_to?(:current_tags)
-            T.unsafe(::ActiveSupport::TaggedLogging).current_tags
-          else
-            Thread.current[:activesupport_tagged_logging_tags] || []
-          end
-          log_data[:tags] = tags if tags.present?
-
-          # Get job_id from ActiveJob if available
-          if defined?(::ActiveJob::Logging) && ::ActiveJob::Logging.respond_to?(:job_id) &&
-              T.unsafe(::ActiveJob::Logging).job_id.present?
-            log_data[:job_id] = T.unsafe(::ActiveJob::Logging).job_id
-          end
-        end
       end
     end
   end

data/lib/log_struct/integrations/action_mailer.rb

@@ -8,10 +8,10 @@ rescue LoadError
 end
 
 if defined?(::ActionMailer)
-  require "logger"
   require_relative "action_mailer/metadata_collection"
   require_relative "action_mailer/event_logging"
   require_relative "action_mailer/error_handling"
+  require_relative "action_mailer/fallback_error_handlers"
 end
 
 module LogStruct
@@ -28,30 +28,35 @@ module LogStruct
         return nil unless config.enabled
         return nil unless config.integrations.enable_actionmailer
 
-        # Silence default ActionMailer logs (we use our own structured logging)
-        # This is required because we replace the logging using our own callbacks
-        if defined?(::ActionMailer::Base)
-          ::ActionMailer::Base.logger = ::Logger.new(File::NULL)
-        end
-
-        # Register our custom observers and handlers
-        # Registering these at the class level means all mailers will use them
+        # Register our custom observers and handlers on all mailers. The hook runs right away
+        # if ActionMailer::Base is already loaded.
         ActiveSupport.on_load(:action_mailer) do
+          # LogStruct's delivery lines replace Rails' mail lines, which also log the whole mail at debug level.
+          # Mailers keep their logger, so an app's own logger calls in a mailer are still logged.
+          RailsLogSubscribers.detach(::ActionMailer::LogSubscriber, :action_mailer) if defined?(::ActionMailer::LogSubscriber)
+
           prepend LogStruct::Integrations::ActionMailer::EventLogging
           prepend LogStruct::Integrations::ActionMailer::ErrorHandling
           prepend LogStruct::Integrations::ActionMailer::MetadataCollection
         end
 
-        # If ActionMailer::Base is already loaded, the on_load hooks won't run
-        # So we need to apply the modules directly
-        if defined?(::ActionMailer::Base)
-          ::ActionMailer::Base.prepend(LogStruct::Integrations::ActionMailer::EventLogging)
-          ::ActionMailer::Base.prepend(LogStruct::Integrations::ActionMailer::ErrorHandling)
-          ::ActionMailer::Base.prepend(LogStruct::Integrations::ActionMailer::MetadataCollection)
-        end
-
         true
       end
+
+      # Where LogStruct doesn't set up ActionMailer, mailers still get the error handlers they can name in
+      # rescue_from (see FallbackErrorHandlers)
+      sig { params(config: LogStruct::Configuration).void }
+      def self.setup_fallback_error_handlers(config)
+        return unless defined?(::ActionMailer)
+        return if config.enabled && config.integrations.enable_actionmailer
+
+        ActiveSupport.on_load(:action_mailer) do
+          next if include?(LogStruct::Integrations::ActionMailer::FallbackErrorHandlers)
+
+          include LogStruct::Integrations::ActionMailer::FallbackErrorHandlers
+          extend LogStruct::Integrations::ActionMailer::FallbackErrorHandlers::ClassMethods
+        end
+      end
     end
   end
 end

data/lib/log_struct/integrations/active_job/log_subscriber.rb

@@ -17,25 +17,38 @@ module LogStruct
 
         sig { params(event: ::ActiveSupport::Notifications::Event).void }
         def enqueue(event)
-          job = T.cast(event.payload[:job], ::ActiveJob::Base)
-          ts = EventTime.coerce_event_time(event.time)
-          base_fields = build_base_fields(job)
-          logger.info(Log::ActiveJob::Enqueue.new(
-            **base_fields.to_kwargs,
-            timestamp: ts
-          ))
+          log_enqueue(event)
         end
 
         sig { params(event: ::ActiveSupport::Notifications::Event).void }
         def enqueue_at(event)
-          job = T.cast(event.payload[:job], ::ActiveJob::Base)
+          log_enqueue(event)
+        end
+
+        # perform_all_later: a line for each job, as perform_later writes
+        sig { params(event: ::ActiveSupport::Notifications::Event).void }
+        def enqueue_all(event)
           ts = EventTime.coerce_event_time(event.time)
-          base_fields = build_base_fields(job)
-          logger.info(Log::ActiveJob::Schedule.new(
-            **base_fields.to_kwargs,
-            scheduled_at: job.scheduled_at,
-            timestamp: ts
-          ))
+          jobs = Array(event.payload[:jobs]).grep(::ActiveJob::Base)
+          error = event.payload[:exception_object]
+          if error
+            log_enqueue_all_error(error, jobs, ts)
+            return
+          end
+
+          # Adapters with their own enqueue_all (Sidekiq's) say only how many jobs they enqueued
+          if jobs.none? { |job| job.successfully_enqueued? || job.enqueue_error }
+            log_enqueued_count(jobs, event.payload[:enqueued_count], ts)
+            return
+          end
+
+          jobs.each do |job|
+            if job.successfully_enqueued?
+              log_enqueued(job, ts)
+            elsif job.enqueue_error
+              log_exception(job.enqueue_error, job)
+            end
+          end
         end
 
         sig { params(event: ::ActiveSupport::Notifications::Event).void }
@@ -45,16 +58,16 @@ module LogStruct
 
           if exception
             # Log the exception with the job context
-            log_exception(exception, job, event)
-          else
-            ts = EventTime.coerce_event_time(event.time)
+            log_exception(exception, job)
+          # An aborted job didn't run: a before_perform callback stopped it
+          elsif !event.payload[:aborted]
             finished_at = EventTime.coerce_event_time(event.end)
             base_fields = build_base_fields(job)
             logger.info(Log::ActiveJob::Finish.new(
               **base_fields.to_kwargs,
               duration_ms: event.duration.to_f,
               finished_at: finished_at,
-              timestamp: ts
+              timestamp: finished_at
             ))
           end
         end
@@ -74,8 +87,130 @@ module LogStruct
           ))
         end
 
+        # retry_on caught the exception and enqueued the job again
+        sig { params(event: ::ActiveSupport::Notifications::Event).void }
+        def enqueue_retry(event)
+          job = T.cast(event.payload[:job], ::ActiveJob::Base)
+          # retry_job can be called without an exception or a wait
+          error = event.payload[:error]
+          wait = event.payload[:wait]
+          logger.info(Log::ActiveJob::Retry.new(
+            **build_base_fields(job).to_kwargs,
+            error_class: error&.class,
+            message: error&.message,
+            wait_ms: wait.nil? ? nil : wait.to_f * 1000,
+            timestamp: EventTime.coerce_event_time(event.time)
+          ))
+        end
+
+        # retry_on ran out of attempts. The job then raises the exception (an error line), unless
+        # retry_on was given a block.
+        sig { params(event: ::ActiveSupport::Notifications::Event).void }
+        def retry_stopped(event)
+          job = T.cast(event.payload[:job], ::ActiveJob::Base)
+          error = T.cast(event.payload[:error], Exception)
+          logger.error(Log::ActiveJob::RetryStopped.new(
+            **build_base_fields(job).to_kwargs,
+            error_class: error.class,
+            message: error.message,
+            timestamp: EventTime.coerce_event_time(event.time)
+          ))
+        end
+
+        sig { params(event: ::ActiveSupport::Notifications::Event).void }
+        def discard(event)
+          job = T.cast(event.payload[:job], ::ActiveJob::Base)
+          error = T.cast(event.payload[:error], Exception)
+          logger.error(Log::ActiveJob::Discard.new(
+            **build_base_fields(job).to_kwargs,
+            error_class: error.class,
+            message: error.message,
+            timestamp: EventTime.coerce_event_time(event.time)
+          ))
+        end
+
         private
 
+        # Like Rails' own enqueue lines: a job the queue didn't take writes an error line, and one a
+        # before_enqueue callback stopped writes none
+        sig { params(event: ::ActiveSupport::Notifications::Event).void }
+        def log_enqueue(event)
+          job = T.cast(event.payload[:job], ::ActiveJob::Base)
+          # perform_later rescues ActiveJob::EnqueueError and keeps it on the job
+          error = event.payload[:exception_object] || job.enqueue_error
+          if error
+            # With the inline adapter, a job that fails raises out of perform_later, and its perform line has
+            # already logged the error
+            log_exception(error, job) unless LogStruct::LoggedErrors.logged?(error)
+          elsif !event.payload[:aborted]
+            log_enqueued(job, EventTime.coerce_event_time(event.time))
+          end
+        end
+
+        sig { params(job: ::ActiveJob::Base, ts: Time).void }
+        def log_enqueued(job, ts)
+          base_fields = build_base_fields(job)
+          scheduled_at = job.scheduled_at
+          if scheduled_at
+            logger.info(Log::ActiveJob::Schedule.new(**base_fields.to_kwargs, scheduled_at: scheduled_at, timestamp: ts))
+          else
+            logger.info(Log::ActiveJob::Enqueue.new(**base_fields.to_kwargs, timestamp: ts))
+          end
+        end
+
+        # perform_all_later raised: the adapter did (Redis down, say), or with the inline adapter a job did
+        sig { params(error: Exception, jobs: T::Array[::ActiveJob::Base], ts: Time).void }
+        def log_enqueue_all_error(error, jobs, ts)
+          # Rails' own enqueue loop (for adapters without enqueue_all) marks each job it tries, keeps an
+          # ActiveJob::EnqueueError on its job and goes on, and stops at a job that raises anything else
+          tried = jobs.reject { |job| job.successfully_enqueued?.nil? }
+          tried.each do |job|
+            enqueue_error = job.enqueue_error
+            if job.successfully_enqueued?
+              log_enqueued(job, ts)
+            elsif enqueue_error
+              log_exception(enqueue_error, job)
+            end
+          end
+          # With the inline adapter, the error is a job's own, which its perform line has logged
+          return if LogStruct::LoggedErrors.logged?(error)
+
+          raised_by = tried.last
+          if raised_by && !raised_by.successfully_enqueued? && raised_by.enqueue_error.nil?
+            log_exception(error, raised_by)
+            return
+          end
+
+          # Which job it was isn't known: an adapter's own enqueue_all (Sidekiq's) doesn't say which jobs it
+          # enqueued before it raised
+          classes = jobs.map { |job| job.class.to_s }.uniq.join(", ")
+          message = "perform_all_later of #{jobs.size} jobs (#{classes}) failed"
+          message += "; the queue adapter doesn't say which it enqueued" if tried.empty?
+          logger.error(Log::Error.new(
+            source: Source::Job,
+            error_class: error.class,
+            message: message,
+            error_message: error.message,
+            backtrace: error.backtrace,
+            level: Level::Error,
+            timestamp: ts
+          ))
+          LogStruct::LoggedErrors.mark(error)
+        end
+
+        # Every job's line when the adapter enqueued them all; when it didn't, it doesn't say which it enqueued
+        sig { params(jobs: T::Array[::ActiveJob::Base], enqueued_count: T.untyped, ts: Time).void }
+        def log_enqueued_count(jobs, enqueued_count, ts)
+          return if jobs.empty?
+
+          if enqueued_count == jobs.size
+            jobs.each { |job| log_enqueued(job, ts) }
+          else
+            classes = jobs.map { |job| job.class.to_s }.uniq.join(", ")
+            logger.warn("perform_all_later enqueued #{enqueued_count.to_i} of #{jobs.size} jobs (#{classes}); the queue adapter doesn't say which")
+          end
+        end
+
         sig { params(job: ::ActiveJob::Base).returns(Log::ActiveJob::BaseFields) }
         def build_base_fields(job)
           Log::ActiveJob::BaseFields.new(
@@ -83,19 +218,36 @@ module LogStruct
             job_class: job.class.to_s,
             queue_name: job.queue_name&.to_sym,
             executions: job.executions,
-            provider_job_id: job.provider_job_id,
-            arguments: ((job.class.respond_to?(:log_arguments?) && job.class.log_arguments?) ? job.arguments : nil)
+            # Backends use Strings or Integers (SolidQueue uses its job row ID)
+            provider_job_id: job.provider_job_id&.to_s,
+            arguments: logged_arguments(job)
           )
         end
 
-        sig { params(exception: StandardError, job: ::ActiveJob::Base, _event: ::ActiveSupport::Notifications::Event).void }
-        def log_exception(exception, job, _event)
-          base_fields = build_base_fields(job)
-          job_context = base_fields.to_kwargs
+        # ActionMailer's delivery job carries the mail's own arguments, which can be secrets: Devise passes its
+        # confirmation, password reset and invitation tokens as plain strings, which no key-based filter can find.
+        # For a mail, log the mailer, the mail and the delivery method only.
+        sig { params(job: ::ActiveJob::Base).returns(T.nilable(T::Array[T.untyped])) }
+        def logged_arguments(job)
+          return nil unless job.class.respond_to?(:log_arguments?) && job.class.log_arguments?
+          return job.arguments.first(3) if defined?(::ActionMailer::MailDeliveryJob) && job.is_a?(::ActionMailer::MailDeliveryJob)
 
-          log_data = Log.from_exception(Source::Job, exception, job_context)
+          job.arguments
+        end
+
+        # perform_now lets any Exception through, not only StandardErrors
+        sig { params(exception: Exception, job: ::ActiveJob::Base).void }
+        def log_exception(exception, job)
+          log_data = Log::ActiveJob::Error.new(
+            **build_base_fields(job).to_kwargs,
+            error_class: exception.class,
+            message: exception.message,
+            backtrace: exception.backtrace
+          )
 
           logger.error(log_data)
+          # So a backend that reports the same exception (GoodJob's on_thread_error) doesn't log it again
+          LogStruct::LoggedErrors.mark(exception)
         end
 
         sig { returns(T.untyped) }

data/lib/log_struct/integrations/active_job.rb

@@ -25,13 +25,8 @@ module LogStruct
         return nil unless config.integrations.enable_activejob
 
         ::ActiveSupport.on_load(:active_job) do
-          if ::ActiveJob::LogSubscriber.respond_to?(:detach_from)
-            # Detach the default text formatter
-            ::ActiveJob::LogSubscriber.detach_from :active_job
-          elsif ::ActiveSupport.respond_to?(:event_reporter)
-            reporter = ::ActiveSupport.event_reporter
-            reporter.unsubscribe(::ActiveJob::LogSubscriber) if reporter.respond_to?(:unsubscribe)
-          end
+          # Detach the default text formatter
+          RailsLogSubscribers.detach(::ActiveJob::LogSubscriber, :active_job)
 
           # Attach our structured formatter
           Integrations::ActiveJob::LogSubscriber.attach_to :active_job

data/lib/log_struct/integrations/active_model_serializers.rb

@@ -17,6 +17,11 @@ module LogStruct
         # Only activate if AMS appears to be present
         return nil unless defined?(::ActiveModelSerializers)
 
+        # AMS logs each render as a line of text too
+        if defined?(::ActiveModelSerializers::Logging::LogSubscriber)
+          ::ActiveModelSerializers::Logging::LogSubscriber.detach_from(:active_model_serializers)
+        end
+
         # Subscribe to common AMS notification names; keep broad but specific
         pattern = /\.active_model_serializers\z/
 
@@ -39,7 +44,8 @@ module LogStruct
             )
           )
         rescue => e
-          LogStruct.handle_exception(e, source: LogStruct::Source::Rails, context: {integration: :active_model_serializers})
+          # A problem with the log line is LogStruct's own, and never fails the render in production
+          LogStruct.handle_exception(e, source: LogStruct::Source::Internal, context: {integration: :active_model_serializers})
         end
 
         true