logstruct 0.1.11 → 0.2.0

data/lib/log_struct/integrations/shrine.rb

@@ -16,6 +16,10 @@ module LogStruct
 
       SHRINE_EVENTS = T.let(%i[upload exists download delete metadata open].freeze, T::Array[Symbol])
 
+      # The file name in a Content-Disposition (attachment; filename="..."; filename*=UTF-8''...). A quoted name
+      # can hold a semicolon, and whatever follows a quote (malformed or not) goes too.
+      DISPOSITION_FILENAME_REGEX = /(\bfilename\*?\s*=\s*)(?:"(?:[^"\\]|\\.)*"?)?[^;]*/i
+
       # Set up Shrine structured logging
       sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
@@ -25,8 +29,8 @@ module LogStruct
 
         # Create a structured log subscriber for Shrine
         # ActiveSupport::Notifications::Event has name, time, end, transaction_id, payload, and duration
-        shrine_log_subscriber = T.unsafe(lambda do |event|
-          payload = event.payload.except(:io, :metadata, :name).dup
+        shrine_log_subscriber = lambda do |event|
+          payload = event.payload.except(:io, :name).dup
 
           # Map event name to Event type
           event_type = case event.name
@@ -34,9 +38,8 @@ module LogStruct
           when :download then Event::Download
           when :open then Event::Download
           when :delete then Event::Delete
-          when :metadata then Event::Metadata
           when :exists then Event::Exist
-          else Event::Unknown
+          else Event::Metadata
           end
 
           # Create structured log data
@@ -45,11 +48,15 @@ module LogStruct
 
           log_data = case event_type
           when Event::Upload
+            metadata = payload[:metadata].is_a?(Hash) ? payload[:metadata] : {}
+            size = metadata["size"]
             Log::Shrine::Upload.new(
               storage: storage_sym,
               location: payload[:location],
+              mime_type: metadata["mime_type"]&.to_s,
+              size: size.is_a?(Integer) ? size : nil,
               uploader: payload[:uploader]&.to_s,
-              upload_options: payload[:upload_options],
+              upload_options: without_file_names(payload[:upload_options]),
               options: payload[:options],
               duration_ms: event.duration.to_f
             )
@@ -64,95 +71,63 @@ module LogStruct
               storage: storage_sym,
               location: payload[:location]
             )
-          when Event::Metadata
-            metadata_params = {
-              storage: storage_sym,
-              metadata: payload[:metadata]
-            }
-            metadata_params[:location] = payload[:location] if payload[:location]
-            Log::Shrine::Metadata.new(**metadata_params)
           when Event::Exist
             Log::Shrine::Exist.new(
               storage: storage_sym,
-              location: payload[:location],
-              exist: payload[:exist]
+              location: payload[:location]
             )
           else
-            unknown_params = {storage: storage_sym, metadata: payload[:metadata]}
-            unknown_params[:location] = payload[:location] if payload[:location]
-            Log::Shrine::Metadata.new(**unknown_params)
+            # metadata, the only other event in SHRINE_EVENTS
+            Log::Shrine::Metadata.new(storage: storage_sym, duration_ms: event.duration.to_f)
           end
 
           # Log directly through SemanticLogger, NOT through Shrine.logger
           # Shrine.logger is a basic Logger that would just call .to_s on the struct
           ::SemanticLogger[::Shrine].info(log_data)
-        end)
-
-        # Check if instrumentation plugin is already loaded
-        # If so, we need to replace the existing subscribers, not add duplicates
-        if instrumentation_already_configured?
-          replace_existing_subscribers(shrine_log_subscriber)
-        else
-          # First time setup - configure the instrumentation plugin
-          ::Shrine.plugin :instrumentation,
-            events: SHRINE_EVENTS,
-            log_subscriber: shrine_log_subscriber
         end
 
-        true
-      end
+        # Load the instrumentation plugin without Shrine's default log subscriber, which logs
+        # each event as a line of text (a no-op if the app has loaded it already). Shrine
+        # ignores a subscriber that's already subscribed.
+        ::Shrine.plugin :instrumentation, log_subscriber: nil
+        SHRINE_EVENTS.each do |event_name|
+          ::Shrine.subscribe(event_name, &shrine_log_subscriber)
+        end
 
-      sig { returns(T::Boolean) }
-      def self.instrumentation_already_configured?
-        return false unless defined?(::Shrine)
+        # The app may load the plugin with the default log subscriber too, before or after this
+        ::Shrine::Plugins::Instrumentation::LogSubscriber.singleton_class.prepend(SkipLoggedEvents)
 
-        opts = T.unsafe(::Shrine).opts
-        return false unless opts.is_a?(Hash)
+        # Other plugins' log subscribers and Shrine's warnings write text to Shrine.logger
+        ::Shrine.logger = ::SemanticLogger[::Shrine]
 
-        instrumentation_opts = opts[:instrumentation]
-        return false unless instrumentation_opts.is_a?(Hash)
+        true
+      end
 
-        subscribers = instrumentation_opts[:subscribers]
-        return false unless subscribers.is_a?(Hash)
+      # Upload options with the file names taken out of a Content-Disposition (upload_options:
+      # {content_disposition: ...}, which the upload_options plugin often sets): they can name a person
+      sig { params(options: T.untyped).returns(T.untyped) }
+      def self.without_file_names(options)
+        return options unless options.is_a?(Hash)
 
-        !subscribers.empty?
+        options.to_h do |key, value|
+          if value.is_a?(String) && KeyWords.normalize(key).include?("disposition")
+            [key, value.gsub(DISPOSITION_FILENAME_REGEX, '\1[FILENAME]')]
+          else
+            [key, value]
+          end
+        end
       end
 
-      sig { params(new_subscriber: T.untyped).void }
-      def self.replace_existing_subscribers(new_subscriber)
-        opts = T.unsafe(::Shrine).opts
-        instrumentation_opts = opts[:instrumentation]
-        subscribers = instrumentation_opts[:subscribers]
+      # Prepended to Shrine's default instrumentation log subscriber, so it doesn't log the
+      # events that LogStruct logs
+      module SkipLoggedEvents
+        extend T::Sig
 
-        # Clear all existing subscribers and add our new one
-        SHRINE_EVENTS.each do |event_name|
-          # Clear existing subscribers for this event
-          subscribers[event_name] = [] if subscribers[event_name]
-
-          # Add our subscriber
-          subscribers[event_name] ||= []
-          subscribers[event_name] << new_subscriber
-
-          # Also re-subscribe via ActiveSupport::Notifications
-          # Shrine uses "shrine.#{event_name}" as the notification name
-          notification_name = "shrine.#{event_name}"
-
-          # Unsubscribe existing listeners for this event
-          # ActiveSupport::Notifications stores subscriptions, we need to find and remove them
-          notifier = ::ActiveSupport::Notifications.notifier
-          if notifier.respond_to?(:listeners_for)
-            # Rails 7.0+ uses listeners_for
-            listeners = notifier.listeners_for(notification_name)
-            listeners.each do |listener|
-              ::ActiveSupport::Notifications.unsubscribe(listener)
-            end
-          end
+        sig { params(event: T.untyped).returns(T.untyped) }
+        def call(event)
+          return if SHRINE_EVENTS.include?(event.name)
 
-          # Subscribe our new subscriber
-          ::ActiveSupport::Notifications.subscribe(notification_name) do |*args|
-            event = ::ActiveSupport::Notifications::Event.new(*args)
-            new_subscriber.call(event)
-          end
+          super
         end
       end
     end

data/lib/log_struct/integrations/sidekiq/job_context_middleware.rb

@@ -0,0 +1,32 @@
+# typed: strict
+# frozen_string_literal: true
+
+module LogStruct
+  module Integrations
+    module Sidekiq
+      # Sidekiq server middleware that adds the running job's ID and class to every line
+      # logged while it runs, in the same `ctx` field as Sidekiq's own log lines. A query
+      # on ctx.jid then returns every line for one job run.
+      class JobContextMiddleware
+        extend T::Sig
+
+        sig do
+          params(
+            job_instance: T.untyped,
+            job_hash: T::Hash[String, T.untyped],
+            queue: String,
+            block: T.proc.returns(T.untyped)
+          ).returns(T.untyped)
+        end
+        def call(job_instance, job_hash, queue, &block)
+          context = {
+            jid: job_hash["jid"],
+            # Same precedence as Sidekiq's own context, so ActiveJob jobs show their class
+            class: job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
+          }
+          ::SemanticLogger.named_tagged(sidekiq_context: context, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -16,32 +16,40 @@ module LogStruct
         Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
       end
 
-      # Custom Logger for Sidekiq that creates LogStruct::Log::Sidekiq entries
+      # Custom Logger for Sidekiq that creates LogStruct::Log::Sidekiq::Log entries
       class Logger < LogStruct::SemanticLogger::Logger
         extend T::Sig
 
         # Override log methods to create Sidekiq log structs
         %i[debug info warn error fatal].each do |level|
           define_method(level) do |message = nil, payload = nil, &block|
-            # Ensure message is a String (Sidekiq may pass Hash for config logs)
-            msg = if message.nil?
-              block ? block.call.to_s : ""
-            else
-              message.to_s
+            # Hashes, LogStruct log entries and exceptions are logged as they are, so their keys are
+            # filtered (Sidekiq logs some settings as a Hash)
+            unless message.nil? || message.is_a?(String)
+              next super(message, payload, &block)
             end
+            # A message with an exception is an error line with both
+            next super(message, payload, &block) if payload.is_a?(Exception)
+
+            msg = message || (block ? block.call.to_s : "")
+            # Lines logged outside a job have no context
+            context = ::Sidekiq::Context.current
 
             # Create a Sidekiq log struct with the message
-            log_struct = Log::Sidekiq.new(
+            log_struct = Log::Sidekiq::Log.new(
               level: LogStruct::Level.from_severity(level.to_s.upcase),
               event: Event::Log,
               message: msg,
               process_id: ::Process.pid,
               thread_id: Sidekiq.tid,
-              context: ::Sidekiq::Context.current || {}
+              # Log a copy: SemanticLogger may still be serializing the struct on its appender
+              # thread when Sidekiq adds :elapsed to the live context after the job finishes.
+              context: context.blank? ? nil : context.dup,
+              additional_data: payload.is_a?(Hash) ? payload : nil
             )
 
             # Pass the struct to SemanticLogger
-            super(log_struct, payload, &nil)
+            super(log_struct, nil, &nil)
           end
         end
       end

data/lib/log_struct/integrations/sidekiq.rb

@@ -6,7 +6,10 @@ begin
 rescue LoadError
   # Sidekiq gem is not available, integration will be skipped
 end
-require_relative "sidekiq/logger" if defined?(::Sidekiq)
+if defined?(::Sidekiq)
+  require_relative "sidekiq/logger"
+  require_relative "sidekiq/job_context_middleware"
+end
 
 module LogStruct
   module Integrations
@@ -15,6 +18,8 @@ module LogStruct
       extend T::Sig
       extend IntegrationInterface
 
+      @original_logger = T.let(nil, T.untyped)
+
       # Set up Sidekiq structured logging
       sig { override.params(config: LogStruct::Configuration).returns(T.nilable(T::Boolean)) }
       def self.setup(config)
@@ -22,18 +27,104 @@ module LogStruct
         return nil unless config.enabled
         return nil unless config.integrations.enable_sidekiq
 
-        # Configure Sidekiq server (worker) to use our logger
+        configure_logger
+
         ::Sidekiq.configure_server do |sidekiq_config|
-          sidekiq_config.logger = LogStruct::Integrations::Sidekiq::Logger.new("Sidekiq-Server")
-        end
+          # First in the chain, so lines logged by other middleware include the job too
+          sidekiq_config.server_middleware do |chain|
+            chain.prepend LogStruct::Integrations::Sidekiq::JobContextMiddleware
+          end
 
-        # Configure Sidekiq client (Rails app) to use our logger
-        ::Sidekiq.configure_client do |sidekiq_config|
-          sidekiq_config.logger = LogStruct::Integrations::Sidekiq::Logger.new("Sidekiq-Client")
+          replace_default_error_handler(sidekiq_config)
         end
 
         true
       end
+
+      # Use LogStruct's logger for Sidekiq's own lines. The Railtie calls this as soon as it replaces
+      # Rails.logger, before config/initializers run, because an initializer that configures Sidekiq
+      # (connecting to Redis, setting up a fetcher) logs with Sidekiq's logger straight away.
+      sig { void }
+      def self.configure_logger
+        return unless defined?(::Sidekiq)
+
+        current = sidekiq_logger_config.logger
+        return if current.is_a?(LogStruct::Integrations::Sidekiq::Logger)
+
+        @original_logger = current
+        name = ::Sidekiq.server? ? "Sidekiq-Server" : "Sidekiq-Client"
+        sidekiq_logger_config.logger = LogStruct::Integrations::Sidekiq::Logger.new(name)
+      end
+
+      # Put Sidekiq's own logger back, when an initializer turned LogStruct or this integration off
+      # after configure_logger ran
+      sig { void }
+      def self.restore_logger
+        return unless defined?(::Sidekiq)
+        return if @original_logger.nil?
+
+        sidekiq_logger_config.logger = @original_logger
+        @original_logger = nil
+      end
+
+      # Sidekiq 7 keeps the logger on its default configuration, Sidekiq 6 on the module
+      sig { returns(T.untyped) }
+      def self.sidekiq_logger_config
+        ::Sidekiq.respond_to?(:default_configuration) ? ::Sidekiq.default_configuration : ::Sidekiq
+      end
+
+      # Sidekiq's default error handler logs three lines for each failed job: the job (with its
+      # arguments) as a JSON string, the error, and the backtrace. Log one structured line instead,
+      # without the arguments, which LogStruct can't filter inside a JSON string.
+      sig { params(sidekiq_config: T.untyped).void }
+      def self.replace_default_error_handler(sidekiq_config)
+        return unless defined?(::Sidekiq::Config::ERROR_HANDLER)
+
+        handlers = sidekiq_config.error_handlers
+        return unless handlers.delete(::Sidekiq::Config::ERROR_HANDLER)
+
+        handlers.unshift(JOB_ERROR_HANDLER)
+      end
+
+      # The line has the job's ID and class in ctx, like the lines logged while the job ran (Sidekiq
+      # calls its error handlers after the job's middleware has finished).
+      sig { params(error: Exception, context: T::Hash[T.untyped, T.untyped]).void }
+      def self.log_job_error(error, context)
+        # LogStruct's ActiveJob integration logs the errors it sees an ActiveJob job raise. An
+        # error raised before ActiveJob ran the job (a job class a deploy removed, say) is logged
+        # here.
+        return if LogStruct::LoggedErrors.logged?(error)
+
+        job = context[:job]
+        job = nil unless job.is_a?(Hash)
+        error_context = context[:context]
+
+        line = Log::Sidekiq::Error.new(
+          error_class: error.class,
+          message: error.message,
+          backtrace: error.backtrace,
+          error_context: error_context&.to_s,
+          queue_name: job&.dig("queue")&.to_s,
+          retry_count: job&.dig("retry_count")
+        )
+        if job.nil?
+          ::Rails.logger.warn(line)
+          return
+        end
+
+        job_context = {
+          jid: job["jid"],
+          class: job["display_class"] || job["wrapped"] || job["class"]
+        }.compact
+        ::SemanticLogger.named_tagged(sidekiq_context: job_context) { ::Rails.logger.warn(line) }
+      end
+
+      JOB_ERROR_HANDLER = T.let(
+        ->(error, context, _config = nil) { log_job_error(error, context) },
+        T.proc.params(error: Exception, context: T::Hash[T.untyped, T.untyped], config: T.untyped).void
+      )
+
+      private_class_method :sidekiq_logger_config, :replace_default_error_handler, :log_job_error
     end
   end
 end

data/lib/log_struct/integrations/sorbet.rb

@@ -17,12 +17,10 @@ module LogStruct
       def self.setup(config)
         return nil unless config.integrations.enable_sorbet_error_handlers
 
-        clear_sig_error_handler!
-        install_error_handler!
-
         # Install inline type error handler
         # Called when T.let, T.cast, T.must, etc. fail
         T::Configuration.inline_type_error_handler = lambda do |error, _opts|
+          add_backtrace(error)
           LogStruct.handle_exception(error, source: LogStruct::Source::TypeChecking)
         end
 
@@ -30,67 +28,33 @@ module LogStruct
         # Called when method signature validation fails
         T::Configuration.call_validation_error_handler = lambda do |_signature, opts|
           error = TypeError.new(opts[:pretty_message])
+          add_backtrace(error)
           LogStruct.handle_exception(error, source: LogStruct::Source::TypeChecking)
         end
 
         # Install sig builder error handler
         # Called when there's a problem with a signature definition
         T::Configuration.sig_builder_error_handler = lambda do |error, _location|
+          add_backtrace(error)
           LogStruct.handle_exception(error, source: LogStruct::Source::TypeChecking)
         end
 
         # Install sig validation error handler
         # Called when there's a problem with a signature validation
         T::Configuration.sig_validation_error_handler = lambda do |error, _opts|
+          add_backtrace(error)
           LogStruct.handle_exception(error, source: LogStruct::Source::TypeChecking)
         end
 
         true
       end
 
-      @installed = T.let(false, T::Boolean)
-
-      class << self
-        extend T::Sig
-
-        private
-
-        sig { void }
-        def install_error_handler!
-          return if installed?
-
-          T::Configuration.sig_builder_error_handler = lambda do |error, source|
-            LogStruct.handle_exception(error, source: source, context: nil)
-          end
-
-          @installed = true
-        end
-
-        sig do
-          returns(
-            T.nilable(
-              T.proc.params(error: StandardError, location: Thread::Backtrace::Location).void
-            )
-          )
-        end
-        def clear_sig_error_handler!
-          previous_handler = T.cast(
-            T::Configuration.instance_variable_get(:@sig_builder_error_handler),
-            T.nilable(
-              T.proc.params(error: StandardError, location: Thread::Backtrace::Location).void
-            )
-          )
-          T::Configuration.sig_builder_error_handler = nil
-
-          @installed = false
-
-          previous_handler
-        end
-
-        sig { returns(T::Boolean) }
-        def installed?
-          @installed
-        end
+      # Starts the error's backtrace at the code that failed, below sorbet-runtime's frames (and this file's).
+      # sorbet-runtime passes some errors without raising them, which have no backtrace at all.
+      sig { params(error: Exception).void }
+      def self.add_backtrace(error)
+        frames = error.backtrace || caller
+        error.set_backtrace(frames.drop_while { |frame| frame.include?(__FILE__) || frame.include?("sorbet-runtime") })
       end
     end
   end

data/lib/log_struct/integrations.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "integrations/integration_interface"
+require_relative "integrations/rails_log_subscribers"
 require_relative "integrations/request_context"
 require_relative "integrations/active_job"
 require_relative "integrations/active_record"
@@ -33,8 +34,8 @@ module LogStruct
         LogStruct::Integrations::Dotenv.intercept_logger_setter!
       end
 
-      # Decide which set of boot logs to emit after user initializers
-      railtie.initializer "logstruct.resolve_boot_logs", after: :load_config_initializers do
+      # Decide which set of boot logs to emit once `enabled` is final
+      railtie.initializer "logstruct.resolve_boot_logs", after: "logstruct.setup" do
         LogStruct::Integrations::Dotenv.resolve_boot_logs!
       end
     end

data/lib/log_struct/log/{good_job/enqueue.rb → active_job/discard.rb}

@@ -19,26 +19,26 @@ require_relative "../../enums/log_field"
 
 module LogStruct
   module Log
-    class GoodJob
-      class Enqueue < T::Struct
+    class ActiveJob
+      class Discard < T::Struct
         extend T::Sig
 
         # Shared/common fields
         const :source, Source::Job, default: Source::Job
-        const :event, Event, default: Event::Enqueue
+        const :event, Event, default: Event::Discard
         const :timestamp, Time, factory: -> { Time.now }
         const :level, Level, default: Level::Info
 
-        const :job_id, T.nilable(String), default: nil
-        const :job_class, T.nilable(String), default: nil
+        const :job_id, String
+        const :job_class, String
         const :queue_name, T.nilable(Symbol), default: nil
         const :arguments, T.nilable(T::Array[T.untyped]), default: nil
         const :executions, T.nilable(Integer), default: nil
+        const :provider_job_id, T.nilable(String), default: nil
 
         # Event-specific fields
-        const :duration_ms, Float
-        const :scheduled_at, T.nilable(Time), default: nil
-        const :enqueue_caller, T.nilable(String), default: nil
+        const :error_class, T.class_of(Exception)
+        const :message, String
 
         # Serialize shared fields
         include LogStruct::Log::Interfaces::CommonFields
@@ -47,14 +47,14 @@ module LogStruct
         sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
         def to_h
           h = T.let({}, T::Hash[LogStruct::LogField, T.untyped])
-          h[LogField::JobId] = job_id unless job_id.nil?
-          h[LogField::JobClass] = job_class unless job_class.nil?
+          h[LogField::JobId] = job_id
+          h[LogField::JobClass] = job_class
           h[LogField::QueueName] = queue_name unless queue_name.nil?
           h[LogField::Arguments] = arguments unless arguments.nil?
           h[LogField::Executions] = executions unless executions.nil?
-          h[LogField::DurationMs] = duration_ms
-          h[LogField::ScheduledAt] = scheduled_at unless scheduled_at.nil?
-          h[LogField::EnqueueCaller] = enqueue_caller unless enqueue_caller.nil?
+          h[LogField::ProviderJobId] = provider_job_id unless provider_job_id.nil?
+          h[LogField::ErrorClass] = error_class
+          h[LogField::Message] = message
           h
         end
       end

data/lib/log_struct/log/active_job/enqueue.rb

@@ -36,9 +36,6 @@ module LogStruct
         const :executions, T.nilable(Integer), default: nil
         const :provider_job_id, T.nilable(String), default: nil
 
-        # Event-specific fields
-        const :retries, T.nilable(Integer), default: nil
-
         # Serialize shared fields
         include LogStruct::Log::Interfaces::CommonFields
         include LogStruct::Log::Shared::SerializeCommon
@@ -52,7 +49,6 @@ module LogStruct
           h[LogField::Arguments] = arguments unless arguments.nil?
           h[LogField::Executions] = executions unless executions.nil?
           h[LogField::ProviderJobId] = provider_job_id unless provider_job_id.nil?
-          h[LogField::Retries] = retries unless retries.nil?
           h
         end
       end

data/lib/log_struct/log/{good_job/schedule.rb → active_job/error.rb}

@@ -19,27 +19,27 @@ require_relative "../../enums/log_field"
 
 module LogStruct
   module Log
-    class GoodJob
-      class Schedule < T::Struct
+    class ActiveJob
+      class Error < T::Struct
         extend T::Sig
 
         # Shared/common fields
         const :source, Source::Job, default: Source::Job
-        const :event, Event, default: Event::Schedule
+        const :event, Event, default: Event::Error
         const :timestamp, Time, factory: -> { Time.now }
         const :level, Level, default: Level::Info
 
-        const :job_id, T.nilable(String), default: nil
-        const :job_class, T.nilable(String), default: nil
+        const :job_id, String
+        const :job_class, String
         const :queue_name, T.nilable(Symbol), default: nil
         const :arguments, T.nilable(T::Array[T.untyped]), default: nil
         const :executions, T.nilable(Integer), default: nil
+        const :provider_job_id, T.nilable(String), default: nil
 
         # Event-specific fields
-        const :duration_ms, Float
-        const :scheduled_at, Time
-        const :priority, T.nilable(Integer), default: nil
-        const :cron_key, T.nilable(String), default: nil
+        const :error_class, T.class_of(Exception)
+        const :message, String
+        const :backtrace, T.nilable(T::Array[String]), default: nil
 
         # Serialize shared fields
         include LogStruct::Log::Interfaces::CommonFields
@@ -48,15 +48,15 @@ module LogStruct
         sig { returns(T::Hash[LogStruct::LogField, T.untyped]) }
         def to_h
           h = T.let({}, T::Hash[LogStruct::LogField, T.untyped])
-          h[LogField::JobId] = job_id unless job_id.nil?
-          h[LogField::JobClass] = job_class unless job_class.nil?
+          h[LogField::JobId] = job_id
+          h[LogField::JobClass] = job_class
           h[LogField::QueueName] = queue_name unless queue_name.nil?
           h[LogField::Arguments] = arguments unless arguments.nil?
           h[LogField::Executions] = executions unless executions.nil?
-          h[LogField::DurationMs] = duration_ms
-          h[LogField::ScheduledAt] = scheduled_at
-          h[LogField::Priority] = priority unless priority.nil?
-          h[LogField::CronKey] = cron_key unless cron_key.nil?
+          h[LogField::ProviderJobId] = provider_job_id unless provider_job_id.nil?
+          h[LogField::ErrorClass] = error_class
+          h[LogField::Message] = message
+          h[LogField::Backtrace] = backtrace unless backtrace.nil?
           h
         end
       end