logstruct 0.1.12 → 0.2.0

data/lib/log_struct/integrations/good_job.rb

@@ -8,29 +8,17 @@ rescue LoadError
 end
 
 require_relative "good_job/logger" if defined?(::GoodJob)
-require_relative "good_job/log_subscriber" if defined?(::GoodJob)
 
 module LogStruct
   module Integrations
     # GoodJob integration for structured logging
     #
-    # GoodJob is a PostgreSQL-based ActiveJob backend that provides reliable,
-    # scalable job processing for Rails applications. This integration provides
-    # structured logging for all GoodJob operations.
+    # GoodJob is a PostgreSQL-based ActiveJob backend. Its jobs are logged by the ActiveJob
+    # integration (enqueued, started, finished, failed), so this integration covers GoodJob itself:
     #
-    # ## Features:
-    # - Structured logging for job execution lifecycle
-    # - Error tracking and retry logging
-    # - Performance metrics and timing data
-    # - Database operation logging
-    # - Thread and process tracking
-    # - Custom GoodJob logger with LogStruct formatting
-    #
-    # ## Integration Points:
-    # - Replaces GoodJob.logger with LogStruct-compatible logger
-    # - Subscribes to GoodJob's ActiveSupport notifications
-    # - Captures job execution events, errors, and performance metrics
-    # - Logs database operations and connection information
+    # - Replaces GoodJob.logger with a LogStruct logger, so GoodJob's own messages are JSON lines
+    # - Logs each thread error as a structured error line, then calls the app's `on_thread_error`
+    # - Stops GoodJob's own log subscriber logging those errors again with the whole backtrace
     #
     # ## Configuration:
     # The integration is automatically enabled when GoodJob is detected and
@@ -45,8 +33,7 @@ module LogStruct
 
       # Set up GoodJob structured logging
       #
-      # This method configures GoodJob to use LogStruct's structured logging
-      # by replacing the default logger and subscribing to job events.
+      # This method replaces GoodJob's logger and logs its thread errors as structured lines.
       #
       # @param config [LogStruct::Configuration] The LogStruct configuration
       # @return [Boolean, nil] Returns true if setup was successful, nil if skipped
@@ -59,51 +46,135 @@ module LogStruct
         # Replace GoodJob's logger with our structured logger
         configure_logger
 
-        # Subscribe to GoodJob's ActiveSupport notifications
-        subscribe_to_notifications
+        compact_error_lines
 
         true
       end
 
+      # GoodJob::LogSubscriber logs errors as text with the whole backtrace in the message (over 10KB).
+      # GoodJob passes every error its job tasks raise, every systemd watchdog error and every notifier
+      # error except connection errors to `on_thread_error`, which LogThreadErrors logs as a structured
+      # line, so GoodJob's own lines for those are off. The notifier passes connection errors on only
+      # once they repeat, so its line for them is kept, without the backtrace.
+      module CompactErrorLines
+        extend T::Sig
+        extend T::Helpers
+
+        requires_ancestor { ::GoodJob::LogSubscriber }
+
+        sig { params(_event: T.untyped).void }
+        def finished_job_task(_event)
+        end
+
+        sig { params(event: T.untyped).void }
+        def notifier_notify_error(event)
+          exception = event.payload[:error]
+          return unless exception
+          return unless LogStruct::Integrations::GoodJob.notifier_connection_error?(exception)
+
+          error { "Notifier errored: #{exception.class}: #{exception}" }
+        end
+
+        sig { params(_event: T.untyped).void }
+        def systemd_watchdog_error(_event)
+        end
+      end
+
+      # Logs each thread error as a structured line, then calls the handler the app set as
+      # `on_thread_error` (GoodJob's README sets one to report errors to an error tracker). Every
+      # GoodJob component passes its thread errors to `GoodJob._on_thread_error`, so this works
+      # whenever the app sets its handler: GoodJob's engine applies config.good_job.on_thread_error
+      # after LogStruct's setup. GoodJob passes any Exception its handled_exceptions setting lets
+      # through, not only StandardErrors.
+      module LogThreadErrors
+        extend T::Sig
+
+        sig { params(exception: Exception).void }
+        def _on_thread_error(exception)
+          LogStruct::Integrations::GoodJob.log_thread_error(exception)
+        rescue => e
+          LogStruct.handle_exception(e, source: LogStruct::Source::Internal, context: {integration: :good_job})
+        ensure
+          # The app's handler runs even if LogStruct's line failed
+          super
+        end
+      end
+
       # Configure GoodJob to use LogStruct's structured logger
       sig { void }
       def self.configure_logger
         return unless defined?(::GoodJob)
 
-        # Use direct reference to avoid const_get - GoodJob is guaranteed to be defined here
-        goodjob_module = T.unsafe(GoodJob)
+        # Not GoodJob, which here is this module
+        goodjob_module = ::GoodJob
 
         # Replace GoodJob.logger with our structured logger if GoodJob is available
         if goodjob_module.respond_to?(:logger=)
           goodjob_module.logger = LogStruct::Integrations::GoodJob::Logger.new("GoodJob")
-        end
 
-        # Configure error handling for thread errors if GoodJob supports it
-        if goodjob_module.respond_to?(:on_thread_error=)
-          goodjob_module.on_thread_error = ->(exception) do
-            log_entry = LogStruct::Log::GoodJob::Error.new(
-              error_class: exception.class.name,
-              error_message: exception.message,
-              backtrace: exception.backtrace,
-              process_id: ::Process.pid,
-              thread_id: Thread.current.object_id.to_s(36)
-            )
-            goodjob_module.logger.error(log_entry)
+          # GoodJob's executable adds a plain text STDOUT logger unless GoodJob.logger already writes
+          # to STDOUT, which it can't tell for this logger
+          if defined?(::GoodJob::CLI) && ::GoodJob::CLI.respond_to?(:log_to_stdout=)
+            ::GoodJob::CLI.log_to_stdout = false
           end
         end
+
+        configure_thread_error_handler
       end
 
-      # Subscribe to GoodJob's ActiveSupport notifications
       sig { void }
-      def self.subscribe_to_notifications
+      def self.configure_thread_error_handler
         return unless defined?(::GoodJob)
 
-        # Subscribe to our custom log subscriber for GoodJob events
-        LogStruct::Integrations::GoodJob::LogSubscriber.attach_to :good_job
+        # Not GoodJob, which here is this module
+        goodjob_singleton = ::GoodJob.singleton_class
+        return unless goodjob_singleton.method_defined?(:_on_thread_error)
+
+        goodjob_singleton.prepend(LogThreadErrors) unless goodjob_singleton.ancestors.include?(LogThreadErrors)
+      end
+
+      # A failed job's exception was already logged by the ActiveJob integration, with the job's
+      # ID and class, so it isn't logged again here
+      sig { params(exception: Exception).void }
+      def self.log_thread_error(exception)
+        return if LogStruct::LoggedErrors.logged?(exception)
+
+        ::GoodJob.logger.error(
+          LogStruct::Log::GoodJob::Error.new(
+            error_class: exception.class.name || exception.class.to_s,
+            error_message: exception.message,
+            backtrace: exception.backtrace,
+            level: LogStruct::Level::Error,
+            process_id: ::Process.pid,
+            thread_id: Thread.current.object_id.to_s(36)
+          )
+        )
+      end
+
+      # The errors GoodJob's notifier holds back until they repeat (GoodJob::Notifier::CONNECTION_ERRORS)
+      sig { params(exception: Exception).returns(T::Boolean) }
+      def self.notifier_connection_error?(exception)
+        return true unless defined?(::GoodJob::Notifier::CONNECTION_ERRORS)
+
+        ::GoodJob::Notifier::CONNECTION_ERRORS.any? do |error_name|
+          error_class = error_name.safe_constantize
+          error_class.is_a?(Class) && exception.is_a?(error_class)
+        end
+      end
+
+      # Only when LogThreadErrors logs thread errors instead
+      sig { void }
+      def self.compact_error_lines
+        return unless defined?(::GoodJob::LogSubscriber)
+        return unless ::GoodJob.singleton_class.ancestors.include?(LogThreadErrors)
+
+        log_subscriber = ::GoodJob::LogSubscriber
+        log_subscriber.prepend(CompactErrorLines) unless log_subscriber.ancestors.include?(CompactErrorLines)
       end
 
       private_class_method :configure_logger
-      private_class_method :subscribe_to_notifications
+      private_class_method :compact_error_lines
+      private_class_method :configure_thread_error_handler
     end
   end
 end

data/lib/log_struct/integrations/host_authorization.rb

@@ -35,57 +35,68 @@ module LogStruct
         return nil unless config.enabled
         return nil unless config.integrations.enable_host_authorization
 
-        # Define the response app as a separate variable to fix block alignment
-        response_app = lambda do |env|
-          request = ::ActionDispatch::Request.new(env)
-          # Include the blocked hosts app configuration in the log entry
-          # This can be helpful later when reviewing logs.
-          blocked_hosts = env["action_dispatch.blocked_hosts"]
+        # Merge our response_app into existing host_authorization config to preserve excludes
+        existing = Rails.application.config.host_authorization
+        unless existing.is_a?(Hash)
+          existing = {}
+        end
+        existing = existing.dup
+        app_response_app = existing[:response_app]
+        # Set up once: don't wrap our own response app again
+        app_response_app = app_response_app.app_response_app if app_response_app.is_a?(ResponseApp)
+        existing[:response_app] = ResponseApp.new(app_response_app)
+        Rails.application.config.host_authorization = existing
 
-          # Build allowed_hosts array
-          allowed_hosts_array = T.let(nil, T.nilable(T::Array[String]))
-          if blocked_hosts.respond_to?(:allowed_hosts)
-            allowed_hosts_array = blocked_hosts.allowed_hosts
-          end
+        true
+      end
+
+      # Logs the blocked host, then responds with the app's own response_app if it set one
+      class ResponseApp
+        extend T::Sig
 
-          # Get allow_ip_hosts value
-          allow_ip_hosts_value = T.let(nil, T.nilable(T::Boolean))
-          if blocked_hosts.respond_to?(:allow_ip_hosts)
-            allow_ip_hosts_value = blocked_hosts.allow_ip_hosts
+        sig { returns(T.untyped) }
+        attr_reader :app_response_app
+
+        sig { params(app_response_app: T.untyped).void }
+        def initialize(app_response_app)
+          @app_response_app = app_response_app
+        end
+
+        sig { params(env: T::Hash[String, T.untyped]).returns(T.untyped) }
+        def call(env)
+          begin
+            log_blocked_host(env)
+          rescue => e
+            LogStruct.handle_exception(e, source: LogStruct::Source::Internal, context: {integration: :host_authorization})
           end
+          return @app_response_app.call(env) if @app_response_app
+
+          # Dup the headers so they can be modified by downstream middleware
+          [FORBIDDEN_STATUS, RESPONSE_HEADERS.dup, [RESPONSE_HTML]]
+        end
+
+        private
+
+        sig { params(env: T::Hash[String, T.untyped]).void }
+        def log_blocked_host(env)
+          request = ::ActionDispatch::Request.new(env)
+          # The hosts Rails blocked: the Host header, and X-Forwarded-Host when it's set
+          blocked_hosts = Array(env["action_dispatch.blocked_hosts"]).map(&:to_s)
 
-          # Create structured log entry for blocked host
           log_entry = LogStruct::Log::Security::BlockedHost.new(
             message: "Blocked host detected: #{request.host}",
             blocked_host: request.host,
+            blocked_hosts: blocked_hosts.empty? ? nil : blocked_hosts,
             path: request.path,
             http_method: request.method,
             source_ip: request.ip,
             user_agent: request.user_agent,
-            referer: request.referer,
-            x_forwarded_for: request.x_forwarded_for,
-            allowed_hosts: allowed_hosts_array&.empty? ? nil : allowed_hosts_array,
-            allow_ip_hosts: allow_ip_hosts_value
+            referer: StringScrubber.without_query(request.referer),
+            x_forwarded_for: request.x_forwarded_for
           )
 
-          # Log the blocked host
           LogStruct.warn(log_entry)
-
-          # Use pre-defined headers and response if we are only logging or reporting
-          # Dup the headers so they can be modified by downstream middleware
-          [FORBIDDEN_STATUS, RESPONSE_HEADERS.dup, [RESPONSE_HTML]]
         end
-
-        # Merge our response_app into existing host_authorization config to preserve excludes
-        existing = Rails.application.config.host_authorization
-        unless existing.is_a?(Hash)
-          existing = {}
-        end
-        existing = existing.dup
-        existing[:response_app] = response_app
-        Rails.application.config.host_authorization = existing
-
-        true
       end
     end
   end

data/lib/log_struct/integrations/lograge.rb

@@ -70,9 +70,25 @@ module LogStruct
             config.lograge.custom_options = lambda do |event|
               Integrations::Lograge.lograge_default_options(event)
             end
+
+            # Lograge detaches Rails' own request lines from ActiveSupport::Notifications. From Rails 8.2 they come
+            # from Rails.event, so LogStruct detaches them there.
+            config.after_initialize do |app|
+              Integrations::Lograge.unsubscribe_rails_request_lines unless app.config.lograge.keep_original_rails_log
+            end
           end
         end
 
+        # Rails' "Processing by", "Completed 200 OK" and "Rendered" lines, which the request line replaces
+        sig { void }
+        def unsubscribe_rails_request_lines
+          # Earlier Rails versions' subscribers are lograge's to detach
+          return unless defined?(::ActiveSupport::EventReporter::LogSubscriber)
+
+          RailsLogSubscribers.unsubscribe_from_events(::ActionController::LogSubscriber) if defined?(::ActionController::LogSubscriber)
+          RailsLogSubscribers.unsubscribe_from_events(::ActionView::LogSubscriber) if defined?(::ActionView::LogSubscriber)
+        end
+
         sig { params(event: ActiveSupport::Notifications::Event).returns(T::Hash[Symbol, T.untyped]) }
         def lograge_default_options(event)
           # Extract essential fields from the payload
@@ -81,6 +97,7 @@ module LogStruct
             :host,
             :source_ip
           ).compact
+          add_request_address(event.payload[:request], options)
 
           if event.payload[:params].present?
             options[:params] = event.payload[:params].except("controller", "action")
@@ -95,6 +112,21 @@ module LogStruct
           options
         end
 
+        # Rails' payload has the request but not its address, which Rails' own "Started GET" line logs.
+        # A payload's own :source_ip and :host (from append_info_to_payload) take precedence.
+        sig { params(request: T.untyped, options: T::Hash[Symbol, T.untyped]).void }
+        def add_request_address(request, options)
+          return unless request.is_a?(::ActionDispatch::Request)
+
+          options[:host] ||= request.host
+          options[:source_ip] ||= begin
+            request.remote_ip
+          rescue ::ActionDispatch::RemoteIp::IpSpoofAttackError
+            # The forwarding headers disagree, so the address the connection came from
+            request.get_header("REMOTE_ADDR")
+          end
+        end
+
         # Process headers from the event payload
         sig { params(event: ActiveSupport::Notifications::Event, options: T::Hash[Symbol, T.untyped]).void }
         def process_headers(event, options)
@@ -119,9 +151,11 @@ module LogStruct
           custom_options_proc = LogStruct.config.integrations.lograge_custom_options
           return unless custom_options_proc&.respond_to?(:call)
 
-          # Call the proc with the event and options
-          # The proc can modify the options hash directly
-          custom_options_proc.call(event, options)
+          # The proc can change options, or return a Hash of fields to add, as Lograge's custom_options do
+          result = custom_options_proc.call(event, options)
+          return if !result.is_a?(Hash) || result.equal?(options)
+
+          options.merge!(result.to_h { |key, value| [key.to_s.to_sym, value] })
         end
 
         sig { params(data: T::Hash[T.any(Symbol, String), T.untyped]).returns(Log::Request) }
@@ -152,7 +186,8 @@ module LogStruct
             params: params,
             source_ip: normalized_data[:source_ip]&.to_s,
             user_agent: normalized_data[:user_agent]&.to_s,
-            referer: normalized_data[:referer]&.to_s,
+            # Without its query, which can carry reset tokens and OAuth codes
+            referer: StringScrubber.without_query(normalized_data[:referer]&.to_s),
             host: normalized_data[:host]&.to_s,
             content_type: normalized_data[:content_type]&.to_s,
             accept: normalized_data[:accept]&.to_s,

data/lib/log_struct/integrations/puma.rb

@@ -13,6 +13,7 @@ module LogStruct
           boot_emitted: false,
           shutdown_emitted: false,
           handler_pending_started: false,
+          signals_trapped: false,
           start_info: {
             mode: nil,
             puma_version: nil,
@@ -67,8 +68,9 @@ module LogStruct
               handle_integration_error(e)
             end
             begin
-              %w[TERM INT].each do |sig|
-                Signal.trap(sig) { emit_shutdown!(sig) }
+              unless STATE[:signals_trapped]
+                STATE[:signals_trapped] = true
+                %w[TERM INT].each { |signal| trap_shutdown_signal(signal) }
               end
             rescue => e
               handle_integration_error(e)
@@ -95,32 +97,30 @@ module LogStruct
           begin
             begin
               require "puma"
-            rescue => e
-              handle_integration_error(e)
+            rescue LoadError
+              # Puma isn't installed (another server, or a command with "server" in its arguments)
+              STATE[:installed] = false
+              return
             end
-            puma_mod = ::Object.const_defined?(:Puma) ? T.unsafe(::Object.const_get(:Puma)) : nil # rubocop:disable Sorbet/ConstantsFromStrings
+            puma_mod = ::Object.const_defined?(:Puma) ? ::Object.const_get(:Puma) : nil # rubocop:disable Sorbet/ConstantsFromStrings
             # rubocop:disable Sorbet/ConstantsFromStrings
             if puma_mod&.const_defined?(:LogWriter)
-              T.unsafe(::Object.const_get("Puma::LogWriter")).prepend(LogWriterPatch)
+              ::Object.const_get("Puma::LogWriter").prepend(LogWriterPatch)
+            end
+            if puma_mod&.const_defined?(:ErrorLogger)
+              ::Object.const_get("Puma::ErrorLogger").prepend(ErrorLoggerPatch)
             end
             if puma_mod&.const_defined?(:Events)
-              ev = T.unsafe(::Object.const_get("Puma::Events"))
+              ev = ::Object.const_get("Puma::Events")
               ev.prepend(EventsPatch)
             end
-            if puma_mod&.const_defined?(:Cluster)
-              cluster_mod = T.cast(puma_mod.const_get(:Cluster), Module)
-              if cluster_mod.const_defined?(:Worker)
-                worker_class = T.cast(cluster_mod.const_get(:Worker), T::Class[T.anything])
-                worker_class.prepend(ClusterWorkerPatch)
-              end
-            end
             # Patch Rack::Handler::Puma.run to emit lifecycle logs using options
             if ::Object.const_defined?(:Rack)
-              rack_mod = T.unsafe(::Object.const_get(:Rack))
+              rack_mod = ::Object.const_get(:Rack)
               if rack_mod.const_defined?(:Handler)
-                handler_mod = T.unsafe(rack_mod.const_get(:Handler))
+                handler_mod = rack_mod.const_get(:Handler)
                 if handler_mod.const_defined?(:Puma)
-                  handler = T.unsafe(handler_mod.const_get(:Puma))
+                  handler = handler_mod.const_get(:Puma)
                   handler.singleton_class.prepend(RackHandlerPatch)
                 end
               end
@@ -141,7 +141,8 @@ module LogStruct
           if defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env.test? && !server_mode
             raise e
           else
-            LogStruct.handle_exception(e, source: Source::Puma)
+            # LogStruct's own error: logged in production, so Puma keeps running
+            LogStruct.handle_exception(e, source: Source::Internal, context: {integration: :puma})
           end
         end
 
@@ -231,7 +232,7 @@ module LogStruct
           if (m = l.match(/^\*?\s*Listening on (.+)$/))
             si = T.cast(STATE[:start_info], T::Hash[Symbol, T.untyped])
             list = T.cast(si[:listening], T::Array[T.untyped])
-            address = T.must(m[1])
+            address = m[1].to_s
             list << address unless list.include?(address)
             # Emit started when we see the first listening address
             if !STATE[:started_emitted]
@@ -313,6 +314,31 @@ module LogStruct
           # Only use LogStruct; SemanticLogger routes to STDOUT in test
         end
 
+        # Logs the shutdown when the signal arrives, then runs the handler that was there before
+        # (Puma's, which stops the server gracefully), or does what the signal does by default
+        sig { params(signal: String).void }
+        def trap_shutdown_signal(signal)
+          previous = T.let(nil, T.untyped)
+          previous = Signal.trap(signal) do |signal_number|
+            emit_shutdown!(signal)
+            run_previous_signal_handler(previous, signal, signal_number)
+          end
+        end
+
+        sig { params(previous: T.untyped, signal: String, signal_number: T.untyped).void }
+        def run_previous_signal_handler(previous, signal, signal_number)
+          if previous.respond_to?(:call)
+            (previous.respond_to?(:arity) && previous.arity == 0) ? previous.call : previous.call(signal_number)
+          elsif previous == "EXIT"
+            Kernel.exit
+          elsif previous.nil? || previous == "DEFAULT" || previous == "SYSTEM_DEFAULT"
+            # Put back the default and send the signal again, so the process ends as it would have
+            Signal.trap(signal, previous || "DEFAULT")
+            Process.kill(signal, Process.pid)
+          end
+          # "IGNORE": nothing more to do
+        end
+
         sig { params(_message: String).void }
         def emit_shutdown!(_message)
           return if STATE[:shutdown_emitted]
@@ -366,7 +392,7 @@ module LogStruct
             return nil
           end
           if ::Kernel.instance_variables.include?(:@stdout)
-            io = T.unsafe(::Kernel.instance_variable_get(:@stdout))
+            io = ::Kernel.instance_variable_get(:@stdout)
             return io.puts(msg)
           end
           super
@@ -379,6 +405,34 @@ module LogStruct
         end
       end
 
+      # Puma::ErrorLogger writes request errors (an exception the app didn't handle, a malformed
+      # request, an SSL error) as plain text to STDERR, with the request's query string. Log them
+      # as structured lines, with the method and path but not the query string, which LogStruct
+      # can't filter there.
+      module ErrorLoggerPatch
+        extend T::Sig
+
+        sig { params(options: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
+        def info(options = {})
+          error = options[:error]
+          return super unless error.is_a?(Exception)
+
+          env = options[:req]&.env
+          ::LogStruct.error(::LogStruct::Log::Puma::Error.new(
+            error_class: error.class,
+            message: error.message,
+            backtrace: error.backtrace,
+            error_context: options[:text]&.to_s,
+            http_method: env&.dig("REQUEST_METHOD"),
+            path: env && (env["REQUEST_PATH"] || env["PATH_INFO"])
+          ))
+          nil
+        rescue => e
+          ::LogStruct::Integrations::Puma.handle_integration_error(e)
+          super
+        end
+      end
+
       # Patch Puma::Events as a fallback for some versions where Events handles output
       module EventsPatch
         extend T::Sig
@@ -390,20 +444,6 @@ module LogStruct
         end
       end
 
-      module ClusterWorkerPatch
-        extend T::Sig
-
-        sig { returns(T.untyped) }
-        def run
-          begin
-            ::SemanticLogger.reopen
-          rescue => e
-            ::LogStruct::Integrations::Puma.handle_integration_error(e)
-          end
-          super
-        end
-      end
-
       # Hook Rack::Handler::Puma.run to emit structured started/shutdown
       module RackHandlerPatch
         extend T::Sig

data/lib/log_struct/integrations/rack_error_handler/debug_exceptions_logging.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "error_lines"
+
+module LogStruct
+  module Integrations
+    module RackErrorHandler
+      # Prepended to ActionDispatch::DebugExceptions. For an error the app didn't handle, Rails logs a
+      # block of text (the error, its source code and its trace) before ShowExceptions renders the
+      # error page. LogStruct writes an error line instead.
+      module DebugExceptionsLogging
+        extend T::Sig
+        extend T::Helpers
+
+        requires_ancestor { ::ActionDispatch::DebugExceptions }
+
+        private
+
+        sig { params(request: ::ActionDispatch::Request, wrapper: T.untyped).returns(T.untyped) }
+        def log_error(request, wrapper)
+          return super unless ErrorLines.enabled?
+          # As Rails does: config.action_dispatch.log_rescued_responses = false leaves out the errors
+          # Rails turns into a response of their own (404 for a routing error, 422 for CSRF)
+          return if !request.get_header("action_dispatch.log_rescued_responses") && wrapper.rescue_response?
+
+          ErrorLines.log_unhandled(request, wrapper)
+        rescue => e
+          LogStruct.handle_exception(e, source: Source::Internal, context: {integration: :rack_error_handler})
+          super
+        end
+      end
+    end
+  end
+end