logstruct 0.1.11 → 0.2.0

data/lib/log_struct/integrations/active_record.rb

@@ -24,9 +24,10 @@ module LogStruct
     # - Smart filtering reduces log volume for repetitive queries
     #
     # ## Security:
-    # - SQL queries are always parameterized (safe)
-    # - Bind parameters filtered through LogStruct's param filters
-    # - Sensitive patterns automatically scrubbed
+    # - Bind parameters are filtered by their column names, like request params, and values that
+    #   look like tokens or hashes are filtered too
+    # - The SQL is scrubbed like any string (emails, card numbers), but it isn't filtered: it can
+    #   hold literal values (string conditions, or every value when prepared_statements is off)
     #
     # ## Configuration:
     # ```ruby
@@ -55,7 +56,7 @@ module LogStruct
         # is enabled. We still receive notifications via ActiveSupport.
         if defined?(::ActiveRecord::LogSubscriber)
           begin
-            ::ActiveRecord::LogSubscriber.detach_from(:active_record)
+            RailsLogSubscribers.detach(::ActiveRecord::LogSubscriber, :active_record)
           rescue => e
             LogStruct.handle_exception(e, source: LogStruct::Source::Internal)
           end
@@ -63,9 +64,8 @@ module LogStruct
 
         # Disable verbose query logs ("↳ caller") since LogStruct provides
         # structured context and these lines are noisy/unstructured.
-        if ::ActiveRecord::Base.respond_to?(:verbose_query_logs=)
-          T.unsafe(::ActiveRecord::Base).verbose_query_logs = false
-        end
+        # (A setting on the ActiveRecord module, so ActiveRecord::Base isn't loaded early.)
+        ::ActiveRecord.verbose_query_logs = false
 
         subscribe_to_sql_notifications
         true
@@ -175,14 +175,35 @@ module LogStruct
       def self.extract_and_filter_binds(payload)
         return nil unless LogStruct.config.integrations.sql_log_bind_params
 
-        # Prefer type_casted_binds as they're more readable
-        binds = payload[:type_casted_binds] || payload[:binds]
-        return nil unless binds
+        binds = payload[:binds]
+        # The values as the database gets them, which Rails passes as a lambda since 6.0
+        casted_binds = payload[:type_casted_binds]
+        casted_binds = casted_binds.call if casted_binds.respond_to?(:call)
+        return nil unless binds.is_a?(Array) || casted_binds.is_a?(Array)
+
+        attributes = binds.is_a?(Array) ? binds : []
+        values = casted_binds.is_a?(Array) ? casted_binds : attributes
+        values.each_with_index.map do |value, index|
+          filter_bind(attributes[index], value)
+        end
+      end
 
-        # Filter sensitive data from bind parameters
-        binds.map do |bind|
-          filter_bind_parameter(bind)
+      # A bind's value, filtered by its column name like Rails' own SQL log lines
+      # (ActiveRecord::LogSubscriber#render_bind)
+      sig { params(attribute: T.untyped, value: T.untyped).returns(T.untyped) }
+      def self.filter_bind(attribute, value)
+        name = if attribute.is_a?(Array)
+          attribute.first&.name
+        elsif attribute.respond_to?(:name)
+          attribute.name
         end
+        value = attribute.value_for_database if value.equal?(attribute) && attribute.respond_to?(:value_for_database)
+        if attribute.respond_to?(:type) && attribute.type.respond_to?(:binary?) && attribute.type.binary? && !value.nil?
+          return "<#{value.to_s.bytesize} bytes of binary data>"
+        end
+        return "[FILTERED]" if name && ParamFilters.should_filter_key?(name.to_s, value)
+
+        filter_bind_parameter(value)
       end
 
       # Extract database name from connection
@@ -270,16 +291,23 @@ module LogStruct
         end
       end
 
-      # Check if a string value looks sensitive and should be filtered
+      # Whether a String value is shaped like a secret: a token, a digest or a Bearer header. Values are
+      # filtered by their column names first; this catches binds without one. Text that mentions a
+      # password or a key isn't a secret.
       sig { params(value: String).returns(T::Boolean) }
       def self.looks_sensitive?(value)
-        # Filter very long strings that might be tokens
-        return true if value.length > 50
+        # A long value with no spaces, which might be a token
+        return true if value.length > 50 && !value.match?(/\s/)
 
         # Filter strings that look like hashed passwords, API keys, tokens
         return true if value.match?(/\A[a-f0-9]{32,}\z/i)  # MD5, SHA, etc.
         return true if value.match?(/\A[A-Za-z0-9+\/]{20,}={0,2}\z/)  # Base64
-        return true if value.match?(/(password|secret|token|key|auth)/i)
+
+        # Filter JWT tokens (header.payload.signature format, starts with "ey")
+        return true if value.match?(/\Aey[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\z/)
+
+        # Filter Bearer tokens
+        return true if value.match?(/\ABearer\s+/i)
 
         false
       end

data/lib/log_struct/integrations/active_storage.rb

@@ -19,14 +19,29 @@ module LogStruct
         return nil unless config.enabled
         return nil unless config.integrations.enable_activestorage
 
+        detach_rails_log_subscriber
+
         # Subscribe to all ActiveStorage service events
         ::ActiveSupport::Notifications.subscribe(/service_.*\.active_storage/) do |*args|
           process_active_storage_event(::ActiveSupport::Notifications::Event.new(*args), config)
+        rescue => e
+          # A problem with a line mustn't fail the upload or download it describes
+          LogStruct.handle_exception(e, source: Source::Internal, context: {integration: :active_storage})
         end
 
         true
       end
 
+      # LogStruct's lines replace Rails' own ActiveStorage lines. Rails loads its log subscriber with
+      # the storage service, after LogStruct is set up, so it's loaded here to detach it.
+      sig { void }
+      def self.detach_rails_log_subscriber
+        require "active_storage/log_subscriber"
+        RailsLogSubscribers.detach(::ActiveStorage::LogSubscriber, :active_storage)
+      rescue LoadError
+        nil
+      end
+
       private_class_method
 
       # Process ActiveStorage events and create structured logs
@@ -54,19 +69,15 @@ module LogStruct
           Event::Exist
         when "service_url"
           Event::Url
-        when "service_download_chunk"
+        when "service_download_chunk", "service_streaming_download"
           Event::Download
-        when "service_stream"
-          Event::Stream
         when "service_update_metadata"
           Event::Metadata
         else
-          Event::Unknown
+          # Events with no line of their own, such as service_mirror
+          return
         end
 
-        # Map the event name to an operation
-        event_name.sub(/^service_/, "").to_sym
-
         # Create structured log event using generated classes
         log_data = case event_type
         when Event::Upload
@@ -74,30 +85,27 @@ module LogStruct
             storage: service_name.to_sym,
             file_id: event.payload[:key]&.to_s,
             checksum: event.payload[:checksum]&.to_s,
-            duration_ms: duration_ms,
-            metadata: event.payload[:metadata],
-            filename: event.payload[:filename],
-            mime_type: event.payload[:content_type],
-            size: event.payload[:byte_size]
+            duration_ms: duration_ms
           )
         when Event::Download
           Log::ActiveStorage::Download.new(
             storage: service_name.to_sym,
             file_id: event.payload[:key]&.to_s,
-            filename: event.payload[:filename],
             range: event.payload[:range],
             duration_ms: duration_ms
           )
         when Event::Delete
+          # delete_prefixed has a prefix instead of a key
           Log::ActiveStorage::Delete.new(
             storage: service_name.to_sym,
-            file_id: event.payload[:key]&.to_s
+            file_id: event.payload[:key]&.to_s,
+            prefix: event.payload[:prefix]&.to_s
           )
         when Event::Metadata
           Log::ActiveStorage::Metadata.new(
             storage: service_name.to_sym,
             file_id: event.payload[:key]&.to_s,
-            metadata: event.payload[:metadata]
+            mime_type: event.payload[:content_type]&.to_s
           )
         when Event::Exist
           Log::ActiveStorage::Exist.new(
@@ -105,28 +113,20 @@ module LogStruct
             file_id: event.payload[:key]&.to_s,
             exist: event.payload[:exist]
           )
-        when Event::Stream
-          Log::ActiveStorage::Stream.new(
-            storage: service_name.to_sym,
-            file_id: event.payload[:key]&.to_s,
-            prefix: event.payload[:prefix]
-          )
         when Event::Url
+          # Without the URL: it's signed, and anyone who has it can read the file until it expires
           Log::ActiveStorage::Url.new(
             storage: service_name.to_sym,
-            file_id: event.payload[:key]&.to_s,
-            url: event.payload[:url]
-          )
-        else
-          Log::ActiveStorage::Metadata.new(
-            storage: service_name.to_sym,
-            file_id: event.payload[:key]&.to_s,
-            metadata: event.payload[:metadata]
+            file_id: event.payload[:key]&.to_s
           )
         end
 
-        # Log structured data
-        LogStruct.info(log_data)
+        # Rails logs existence checks and URLs at debug level: an app generates a URL for each file it shows
+        if event_type == Event::Exist || event_type == Event::Url
+          LogStruct.debug(log_data)
+        else
+          LogStruct.info(log_data)
+        end
       end
     end
   end

data/lib/log_struct/integrations/ahoy.rb

@@ -16,38 +16,42 @@ module LogStruct
           mod = Module.new do
             extend T::Sig
 
-            sig { params(name: T.untyped, properties: T.nilable(T::Hash[T.untyped, T.untyped]), options: T.untyped).returns(T.untyped) }
-            def track(name, properties = nil, options = {})
+            # Takes whatever Ahoy's track takes and passes it on as given, so Ahoy's defaults still apply
+            sig { params(name: T.untyped, args: T.untyped).returns(T.untyped) }
+            def track(name, *args)
               result = super
               begin
-                # Emit a lightweight structured log about the analytics event
-                data = {
-                  ahoy_event: T.let(name, T.untyped)
-                }
-                data[:properties] = properties if properties
                 LogStruct.info(
                   LogStruct::Log::Ahoy.new(
                     message: "ahoy.track",
-                    ahoy_event: T.must(T.let(name, T.nilable(String))),
-                    properties: T.let(
-                      properties && properties.transform_keys { |k| k.to_sym },
-                      T.nilable(T::Hash[Symbol, T.untyped])
-                    )
+                    ahoy_event: name.to_s,
+                    properties: Integrations::Ahoy.properties_for_log(args.first)
                   )
                 )
               rescue => e
-                # Never raise from logging; rely on global error handling policies
-                LogStruct.handle_exception(e, source: LogStruct::Source::App, context: {integration: :ahoy})
+                # A problem with the log line is LogStruct's, and never fails the app's tracking call in production
+                LogStruct.handle_exception(e, source: LogStruct::Source::Internal, context: {integration: :ahoy})
               end
               result
             end
           end
 
-          T.unsafe(::Ahoy::Tracker).prepend(mod)
+          ::Ahoy::Tracker.prepend(mod)
         end
 
         true
       end
+
+      # Event properties can come from the browser, so they can be anything; a non-Hash is logged as its class
+      sig { params(properties: T.untyped).returns(T.nilable(T::Hash[Symbol, T.untyped])) }
+      def self.properties_for_log(properties)
+        properties = properties.to_unsafe_h if properties.respond_to?(:to_unsafe_h)
+        case properties
+        when nil then nil
+        when Hash then properties.to_h { |key, value| [key.to_s.to_sym, value] }
+        else {_class: properties.class.name}
+        end
+      end
     end
   end
 end

data/lib/log_struct/integrations/carrierwave.rb

@@ -27,78 +27,82 @@ module LogStruct
         true
       end
 
-      # Methods to add logging to CarrierWave operations
+      # Logs the operations that store, delete or fetch a file: store! (an upload, when there's a
+      # cached file to store), remove! (a delete) and download! (a remote URL fetched into the cache).
+      # retrieve_from_store! isn't logged: it only points the uploader at a stored file, and runs
+      # each time a record's mounted file is read.
       module LoggingMethods
         extend T::Sig
         extend T::Helpers
         requires_ancestor { ::CarrierWave::Uploader::Base }
 
-        # Log file storage operations
         sig { params(args: T.untyped).returns(T.untyped) }
         def store!(*args)
+          # CarrierWave only stores a cached file; a record's save calls store! on every uploader
+          storing = !cache_only && (cached? || !args.first.nil?)
           start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           result = super
-          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+          return result unless storing && !cached?
 
-          # Extract file information
-          file_size = file.size if file.respond_to?(:size)
-          {
-            identifier: identifier,
-            filename: file.filename,
-            content_type: file.content_type,
-            size: file_size,
-            store_path: store_path,
-            extension: file.extension
-          }
-
-          # Log the store operation with structured data
-          log_data = Log::CarrierWave::Upload.new(
-            storage: storage.class.name.split("::").last.downcase.to_sym,
-            file_id: identifier,
-            filename: file.filename,
-            mime_type: file.content_type,
-            size: file_size,
-            duration_ms: (duration * 1000.0).to_f,
-            uploader: self.class.name,
-            model: model.class.name,
-            mount_point: mounted_as.to_s,
-            version: version_name.to_s,
-            store_path: store_path,
-            extension: file.extension
-          )
+          duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000.0
+          log_file_operation do
+            # file_fields is a Hash Sorbet can't check against the struct's keyword arguments
+            Log::CarrierWave::Upload.new(
+              **T.unsafe(file_fields),
+              filename: file&.filename,
+              mime_type: file&.content_type,
+              size: file&.size,
+              duration_ms: duration_ms
+            )
+          end
+          result
+        end
 
-          ::Rails.logger.info(log_data)
+        sig { returns(T.untyped) }
+        def remove!
+          fields = file ? file_fields : nil
+          result = super
+          log_file_operation { Log::CarrierWave::Delete.new(**T.unsafe(fields)) } if fields
           result
         end
 
-        # Log file retrieve operations
-        sig { params(identifier: T.untyped, args: T.untyped).returns(T.untyped) }
-        def retrieve_from_store!(identifier, *args)
-          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        sig { params(uri: T.untyped, remote_headers: T.untyped).returns(T.untyped) }
+        def download!(uri, remote_headers = {})
           result = super
-          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          log_file_operation do
+            Log::CarrierWave::Download.new(
+              **T.unsafe(file_fields),
+              filename: file&.filename,
+              mime_type: file&.content_type,
+              size: file&.size
+            )
+          end
+          result
+        end
 
-          # Extract file information if available
-          file_size = file.size if file&.respond_to?(:size)
+        private
 
-          # Log the retrieve operation with structured data
-          log_data = Log::CarrierWave::Download.new(
-            storage: storage.class.name.split("::").last.downcase.to_sym,
-            file_id: identifier,
-            filename: file&.filename,
-            mime_type: file&.content_type,
-            size: file_size,
-            # No duration field on Download event schema
+        # The fields every CarrierWave line has
+        sig { returns(T::Hash[Symbol, T.untyped]) }
+        def file_fields
+          {
+            storage: storage.class.name.to_s.split("::").last.to_s.downcase.to_sym,
+            file_id: identifier.to_s,
             uploader: self.class.name,
-            model: model.class.name,
-            mount_point: mounted_as.to_s,
-            version: version_name.to_s,
+            model: model&.class&.name,
+            mount_point: mounted_as&.to_s,
+            version: version_name&.to_s,
             store_path: store_path,
             extension: file&.extension
-          )
+          }
+        end
 
-          ::Rails.logger.info(log_data)
-          result
+        # A problem with a log line mustn't stop the file operation that has already happened
+        sig { params(block: T.proc.returns(Log::Interfaces::CommonFields)).void }
+        def log_file_operation(&block)
+          LogStruct.info(yield)
+        rescue => e
+          LogStruct.handle_exception(e, source: Source::Internal, context: {integration: :carrierwave})
         end
       end
     end

data/lib/log_struct/integrations/dotenv.rb

@@ -48,6 +48,12 @@ module LogStruct
           end
         end
 
+        # A problem with a Dotenv log line is LogStruct's own: raised in development and test, logged in production
+        sig { params(error: StandardError).void }
+        def handle_log_error(error)
+          LogStruct.handle_exception(error, source: LogStruct::Source::Internal, context: {integration: :dotenv})
+        end
+
         sig { void }
         def subscribe!
           # Guard against double subscription
@@ -66,11 +72,7 @@ module LogStruct
             ts = event.time ? Time.at(event.time) : Time.now
             LogStruct.info(Log::Dotenv::Load.new(file: file, timestamp: ts))
           rescue => e
-            if defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env == "test"
-              raise
-            else
-              LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
-            end
+            handle_log_error(e)
           end
 
           instrumenter.subscribe("update.dotenv") do |*args|
@@ -82,11 +84,7 @@ module LogStruct
             ts = event.time ? Time.at(event.time) : Time.now
             LogStruct.debug(Log::Dotenv::Update.new(vars: vars, timestamp: ts))
           rescue => e
-            if defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env == "test"
-              raise
-            else
-              LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
-            end
+            handle_log_error(e)
           end
 
           instrumenter.subscribe("save.dotenv") do |*args|
@@ -95,11 +93,7 @@ module LogStruct
             ts = event.time ? Time.at(event.time) : Time.now
             LogStruct.info(Log::Dotenv::Save.new(snapshot: true, timestamp: ts))
           rescue => e
-            if defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env == "test"
-              raise
-            else
-              LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
-            end
+            handle_log_error(e)
           end
 
           instrumenter.subscribe("restore.dotenv") do |*args|
@@ -111,11 +105,7 @@ module LogStruct
             ts = event.time ? Time.at(event.time) : Time.now
             LogStruct.info(Log::Dotenv::Restore.new(vars: vars, timestamp: ts))
           rescue => e
-            if defined?(::Rails) && ::Rails.respond_to?(:env) && ::Rails.env == "test"
-              raise
-            else
-              LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
-            end
+            handle_log_error(e)
           end
 
           STATE.subscribed = true
@@ -130,8 +120,8 @@ module LogStruct
         return unless defined?(::ActiveSupport::Notifications)
 
         instrumenter = if Object.const_defined?(:Dotenv)
-          dm = T.unsafe(Object.const_get(:Dotenv))
-          dm.respond_to?(:instrumenter) ? T.unsafe(dm).instrumenter : ::ActiveSupport::Notifications
+          dm = Object.const_get(:Dotenv)
+          dm.respond_to?(:instrumenter) ? dm.instrumenter : ::ActiveSupport::Notifications
         else
           ::ActiveSupport::Notifications
         end
@@ -143,7 +133,7 @@ module LogStruct
           ts = event.time ? Time.at(event.time) : Time.now
           LogStruct::BootBuffer.add(Log::Dotenv::Load.new(file: file, timestamp: ts))
         rescue => e
-          LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+          handle_log_error(e)
         end
 
         instrumenter.subscribe("update.dotenv") do |*args|
@@ -153,7 +143,7 @@ module LogStruct
           ts = event.time ? Time.at(event.time) : Time.now
           LogStruct::BootBuffer.add(Log::Dotenv::Update.new(vars: vars, timestamp: ts))
         rescue => e
-          LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+          handle_log_error(e)
         end
 
         instrumenter.subscribe("save.dotenv") do |*args|
@@ -161,7 +151,7 @@ module LogStruct
           ts = event.time ? Time.at(event.time) : Time.now
           LogStruct::BootBuffer.add(Log::Dotenv::Save.new(snapshot: true, timestamp: ts))
         rescue => e
-          LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+          handle_log_error(e)
         end
 
         instrumenter.subscribe("restore.dotenv") do |*args|
@@ -171,7 +161,7 @@ module LogStruct
           ts = event.time ? Time.at(event.time) : Time.now
           LogStruct::BootBuffer.add(Log::Dotenv::Restore.new(vars: vars, timestamp: ts))
         rescue => e
-          LogStruct.handle_exception(e, source: LogStruct::Source::Dotenv)
+          handle_log_error(e)
         end
 
         @@boot_subscribed = true
@@ -183,9 +173,9 @@ module LogStruct
         return unless Object.const_defined?(:Dotenv)
         # Do not intercept when LogStruct is disabled; allow original dotenv replay
         return unless LogStruct.enabled?
-        dotenv_mod = T.unsafe(Object.const_get(:Dotenv))
+        dotenv_mod = Object.const_get(:Dotenv)
         return unless dotenv_mod.const_defined?(:Rails)
-        klass = T.unsafe(dotenv_mod.const_get(:Rails))
+        klass = dotenv_mod.const_get(:Rails)
         return if klass.instance_variable_defined?(:@_logstruct_replay_patched)
 
         original = klass.instance_method(:logger=)
@@ -212,15 +202,15 @@ module LogStruct
       def self.resolve_boot_logs!
         # If LogStruct is disabled, do not alter dotenv behavior at all
         return unless LogStruct.enabled?
-        dotenv_mod = Object.const_defined?(:Dotenv) ? T.unsafe(Object.const_get(:Dotenv)) : nil
-        klass = dotenv_mod&.const_defined?(:Rails) ? T.unsafe(dotenv_mod.const_get(:Rails)) : nil
+        dotenv_mod = Object.const_defined?(:Dotenv) ? Object.const_get(:Dotenv) : nil
+        klass = dotenv_mod&.const_defined?(:Rails) ? dotenv_mod.const_get(:Rails) : nil
 
         pending_logger = nil
         railtie_instance = nil
         if klass&.respond_to?(:instance)
           railtie_instance = klass.instance
           if railtie_instance.respond_to?(:logstruct_pending_dotenv_logger)
-            pending_logger = T.unsafe(railtie_instance).logstruct_pending_dotenv_logger
+            pending_logger = railtie_instance.logstruct_pending_dotenv_logger
           end
         end
 
@@ -242,7 +232,7 @@ module LogStruct
 
           # Detach original subscriber and subscribe runtime structured
           if dotenv_mod&.const_defined?(:LogSubscriber)
-            T.unsafe(dotenv_mod.const_get(:LogSubscriber)).detach_from(:dotenv)
+            dotenv_mod.const_get(:LogSubscriber).detach_from(:dotenv)
           end
           LogStruct::Integrations::Dotenv.subscribe!
 

data/lib/log_struct/integrations/good_job/logger.rb

@@ -10,16 +10,8 @@ module LogStruct
     module GoodJob
       # Custom Logger for GoodJob that creates LogStruct::Log::GoodJob entries
       #
-      # This logger extends LogStruct's SemanticLogger to provide optimal logging
-      # performance while creating structured log entries specifically for GoodJob
-      # operations and events.
-      #
-      # ## Benefits:
-      # - High-performance logging with SemanticLogger backend
-      # - Structured GoodJob-specific log entries
-      # - Automatic job context capture
-      # - Thread and process information
-      # - Performance metrics and timing data
+      # GoodJob's own messages are logged as Log::GoodJob::Log lines with the process and thread,
+      # and, during a job, the job's ID, class, queue, execution count, scheduled time and priority.
       #
       # ## Usage:
       # This logger is automatically configured when the GoodJob integration
@@ -30,22 +22,15 @@ module LogStruct
 
         # Override log methods to create GoodJob-specific log structs
         %i[debug info warn error fatal].each do |level|
-          define_method(level) do |message = nil, payload = nil, &block|
-            # Extract basic job context from thread-local variables
-            job_context = {}
-
-            if Thread.current[:good_job_execution]
-              execution = Thread.current[:good_job_execution]
-              if execution.respond_to?(:job_id)
-                job_context[:job_id] = execution.job_id
-                job_context[:job_class] = execution.job_class if execution.respond_to?(:job_class)
-                job_context[:queue_name] = execution.queue_name if execution.respond_to?(:queue_name)
-                job_context[:executions] = execution.executions if execution.respond_to?(:executions)
-                job_context[:scheduled_at] = execution.scheduled_at if execution.respond_to?(:scheduled_at)
-                job_context[:priority] = execution.priority if execution.respond_to?(:priority)
-              end
+          define_method(level) do |message = nil, payload = nil, exception = nil, &block|
+            # LogStruct log entries and Hashes (like the thread error handler's) are logged as they are, and a
+            # message with an exception is an error line with both
+            if !(message.nil? || message.is_a?(String)) || exception || payload.is_a?(Exception)
+              next super(message, payload, exception, &block)
             end
 
+            job_context = Logger.current_job_context
+
             log_struct = Log::GoodJob::Log.new(
               message: message || (block ? block.call : ""),
               process_id: ::Process.pid,
@@ -61,6 +46,27 @@ module LogStruct
             super(log_struct, payload, &nil)
           end
         end
+
+        # The job GoodJob is running on this thread: CurrentThread.job (a GoodJob::Job) in GoodJob 4,
+        # CurrentThread.execution in GoodJob 3
+        sig { returns(T::Hash[Symbol, T.untyped]) }
+        def self.current_job_context
+          return {} unless defined?(::GoodJob::CurrentThread)
+
+          current = ::GoodJob::CurrentThread
+          job = (current.job if current.respond_to?(:job)) || (current.execution if current.respond_to?(:execution))
+          return {} unless job
+
+          job_class = job.try(:job_class) || job.try(:serialized_params)&.dig("job_class")
+          {
+            job_id: job.try(:active_job_id)&.to_s,
+            job_class: job_class&.to_s,
+            queue_name: job.try(:queue_name)&.to_sym,
+            executions: job.try(:executions_count) || job.try(:executions),
+            scheduled_at: job.try(:scheduled_at),
+            priority: job.try(:priority)
+          }
+        end
       end
     end
   end