julewire-active_job 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a82446be20c0ec6d8ac39b204411837b4759cb57f94ddb9b2138173d16b5fc3d
+  data.tar.gz: 949f9196d2e54d90248b66bce79f34d20bd4be6fbae26667febe548527829cd1
+SHA512:
+  metadata.gz: f0acd8d095c2b529f8bb865b3757bafa62a97e7997e5009d8a8960bd2b8c96e4ffbb2c3e7eb6345318f2150b0113f28e4236212571c0251eab74a89075dad694
+  data.tar.gz: fcf079813dfde620139088138f2705db70ad6a0ab62aa8f2655b977a3b9ccbcd04c27790d9582aabc6928f211fc2d182dfb488261d99d3e006fa5164571d70d1

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+## Unreleased
+
+## 1.0.0 - 2026-06-21
+
+- Initial release: ActiveJob execution summaries, structured events,
+  continuations, and propagation through job serialization.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Alexander Grebennik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# Julewire Active Job
+
+Active Job integration for Julewire.
+
+It records job execution summaries, Active Job structured events, and Julewire
+propagation carriers in serialized job data.
+
+## Quickstart
+
+```ruby
+gem "julewire-active_job"
+```
+
+In Rails, the Railtie installs the integration. Defaults are on:
+
+```ruby
+config.julewire_active_job.execution = true
+config.julewire_active_job.structured_events = true
+config.julewire_active_job.propagation = true
+```
+
+Outside Rails, install it after Active Job is loaded:
+
+```ruby
+Julewire::ActiveJob.install!(base: ActiveJob::Base)
+```
+
+Default behavior:
+
+- job execution scopes emit `job.completed` summaries
+- Active Job structured events become point records
+- carriers restore upstream Julewire context before `perform`
+- Active Job default text subscriber output is detached
+
+Generic job metadata also appears in the record's `neutral` section as `job.*`
+formatter-coordination fields. Full Active Job detail lives under
+`attributes.active_job`. Propagated Julewire context stays separate and small.
+
+## Docs
+
+- [Configuration](docs/configuration.md)
+- [Advanced Configuration](docs/advanced-configuration.md)
+- [Propagation](docs/propagation.md)
+- [Continuations](docs/continuations.md)
+- [Boundaries](docs/boundaries.md)

data/docs/advanced-configuration.md

@@ -0,0 +1,12 @@
+# Advanced Configuration
+
+These options are stable knobs for unusual job serialization or event naming
+needs.
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `carrier_key` | `Julewire::Core::Propagation::Carrier::DEFAULT_KEY` | Carrier key inside propagation envelopes. |
+| `serialized_carrier_key` | `"julewire.carrier"` | Key used in serialized Active Job data. |
+| `summary_event` | `"job.completed"` | Event name for job summaries. |
+| `summary_severity` | `:info` | Severity for successful job summaries. |
+| `event_prefixes` | `["active_job."]` | Structured event prefixes to emit. |

data/docs/boundaries.md

@@ -0,0 +1,13 @@
+# Boundaries
+
+This gem instruments Active Job.
+
+It does not own:
+
+- queue backend transport
+- process supervisors
+- queue-backend lifecycle hooks
+- durable job delivery
+- retry policy
+
+Application logger calls made inside jobs remain normal Julewire records.

data/docs/configuration.md

@@ -0,0 +1,27 @@
+# Configuration
+
+Rails apps configure this gem through `config.julewire_active_job`. Non-Rails
+apps pass a `Configuration` instance to `install!`.
+
+## Default Path
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `enabled` | `true` | Install the integration. |
+| `execution` | `true` | Wrap job perform calls in Julewire executions. |
+| `structured_events` | `true` | Emit Active Job structured events. |
+| `propagation` | `true` | Store and restore Julewire carriers in job data. |
+| `source` | `"active_job"` | Source value on Active Job records. |
+
+## Common Knobs
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `carrier_max_bytes` | `nil` | Omit oversized carriers from serialized jobs. |
+| `silence_log_subscriber` | `true` | Detach Active Job default text subscriber output. |
+
+Example:
+
+```ruby
+config.julewire_active_job.carrier_max_bytes = 16_384
+```

data/docs/continuations.md

@@ -0,0 +1,21 @@
+# Continuations
+
+Rails continuation events run inside the Julewire job execution scope when the
+execution callback is installed.
+
+The job summary records these values under `attributes.active_job`:
+
+- `continuation_steps_started`
+- `continuation_steps_completed`
+- `continuation_steps_interrupted`
+- `continuation_steps_failed`
+- `continuation_steps_skipped`
+- `continuation_interruptions`
+- `continuation_resumptions`
+- `continuation_description`
+- `continuation_interrupt_reason`
+- `continuation_last_step`
+- `continuation_last_step_cursor`
+- `continuation_last_step_resumed`
+- `continuation_last_step_state`
+- `continuation_status`

data/docs/propagation.md

@@ -0,0 +1,17 @@
+# Propagation
+
+When a job is serialized, the gem stores a Julewire carrier under
+`julewire.carrier`. When the job performs, the carrier is restored before the
+job execution scope starts.
+
+That lets upstream context flow into the job without emitting propagation-only
+data by default.
+
+Set `carrier_max_bytes` to omit oversized carriers from serialized job payloads.
+When omitted, the job still runs normally; it starts without upstream Julewire
+context.
+
+Generic job metadata such as class, id, queue, priority, execution count,
+timestamps, and status is emitted in the record's `neutral` section as `job.*`
+formatter-coordination fields. Full Active Job metadata, including framework-
+specific status and exception fields, is emitted under `attributes.active_job`.

data/julewire-active_job.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "lib/julewire/active_job/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "julewire-active_job"
+  spec.version = Julewire::ActiveJob::VERSION
+  spec.authors = ["Alexander Grebennik"]
+  spec.email = ["slbug@users.noreply.github.com", "sl.bug.sl@gmail.com"]
+
+  spec.summary = "Active Job integration for Julewire structured logging."
+  spec.description =
+    "Execution-scoped Active Job instrumentation, structured event capture, " \
+    "and propagation carrier support for Julewire."
+  spec.homepage = "https://github.com/slbug/julewire"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.4"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/slbug/julewire/tree/main/gems/active_job"
+  spec.metadata["changelog_uri"] = "https://github.com/slbug/julewire/blob/main/gems/active_job/CHANGELOG.md"
+
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    Dir[
+      "CHANGELOG.md",
+      "LICENSE.txt",
+      "README.md",
+      "docs/**/*.md",
+      "julewire-active_job.gemspec",
+      "lib/**/*.rb"
+    ]
+  end
+  spec.executables = []
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activejob", ">= 8.1"
+  spec.add_dependency "julewire-core", ">= 1.0"
+  spec.add_dependency "julewire-rails_support", ">= 1.0"
+  spec.add_dependency "zeitwerk", ">= 2.8.1"
+end

data/lib/julewire/active_job/configuration.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Julewire
+  module ActiveJob
+    class Configuration
+      DEFAULT_SERIALIZED_CARRIER_KEY = "julewire.carrier"
+
+      include Julewire::Core::Integration::Settings
+
+      setting :enabled, default: true, predicate: true
+      setting :execution, default: true, predicate: true
+      setting :structured_events, default: true, predicate: true
+      setting :silence_log_subscriber, default: true, predicate: true
+      setting :propagation, default: true, predicate: true
+      setting :carrier_key, default: Julewire::Core::Propagation::Carrier::DEFAULT_KEY
+      setting :carrier_max_bytes, validate: byte_limit
+      setting :serialized_carrier_key, default: DEFAULT_SERIALIZED_CARRIER_KEY
+      setting :source, default: "active_job"
+      setting :summary_event, default: "job.completed"
+      setting :summary_severity, default: :info
+      setting :event_prefixes, default: ["active_job."]
+    end
+  end
+end

data/lib/julewire/active_job/installer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Julewire
+  module ActiveJob
+    module Installer
+      EXECUTION_INSTALL = Core::Integration::IvarState.new(:@julewire_active_job_execution)
+
+      class << self
+        def install!(base: nil, event_reporter: nil, configuration: Configuration.new)
+          return unless configuration.enabled?
+
+          Julewire::ActiveJob.config = configuration
+          base ||= active_job_base
+          raise Error, "ActiveJob::Base is not available" unless base
+
+          install_serialization(base, configuration)
+          install_execution_callback(base, configuration)
+          if configuration.structured_events?
+            Subscribers::Event.install!(configuration, event_reporter: event_reporter)
+          else
+            Subscribers::Event.reset!
+          end
+          LogSubscriberSilencer.silence! if configuration.silence_log_subscriber?
+          base
+        end
+
+        private
+
+        def active_job_base
+          require "active_job/base"
+          ::ActiveJob::Base
+        end
+
+        def install_serialization(base, configuration)
+          install_serialization_configuration(base, configuration)
+          return if base < JobSerialization
+
+          base.prepend(JobSerialization)
+        end
+
+        def install_serialization_configuration(base, configuration)
+          if base.respond_to?(:class_attribute)
+            unless base.respond_to?(JobSerialization::CONFIGURATION_METHOD)
+              base.class_attribute(
+                JobSerialization::CONFIGURATION_METHOD,
+                instance_accessor: false,
+                instance_predicate: false
+              )
+            end
+            base.public_send("#{JobSerialization::CONFIGURATION_METHOD}=", configuration)
+          else
+            base.instance_variable_set(JobSerialization::CONFIGURATION_IVAR, configuration)
+          end
+        end
+
+        def install_execution_callback(base, configuration)
+          return unless configuration.execution?
+
+          installed = EXECUTION_INSTALL.fetch(base)
+          if installed
+            installed.configuration = configuration
+            return installed
+          end
+
+          callback = ExecutionCallback.new(configuration)
+          # Rails callbacks are easier to update in place than to remove safely.
+          base.around_perform do |job, block|
+            callback.call(job, &block)
+          end
+          EXECUTION_INSTALL.store(base, callback)
+        end
+      end
+
+      class ExecutionCallback
+        def initialize(configuration)
+          @configuration = configuration
+        end
+
+        attr_writer :configuration
+
+        def call(job, &)
+          Julewire::ActiveJob::JobExecution.call(job, configuration: @configuration, &)
+        end
+      end
+      private_constant :ExecutionCallback
+    end
+  end
+end

data/lib/julewire/active_job/job_attributes.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+
+module Julewire
+  module ActiveJob
+    module JobAttributes
+      JOB_NAME_KEYS = %i[job_class class_name job_name].freeze
+      JOB_ID_KEYS = %i[job_id id].freeze
+      JOB_PROVIDER_ID_KEYS = %i[provider_job_id].freeze
+      JOB_QUEUE_NAME_KEYS = %i[queue queue_name].freeze
+      JOB_PRIORITY_KEYS = %i[priority].freeze
+      JOB_EXECUTION_COUNT_KEYS = %i[executions].freeze
+      JOB_ENQUEUED_AT_KEYS = %i[enqueued_at].freeze
+      JOB_SCHEDULED_AT_KEYS = %i[scheduled_at].freeze
+      JOB_STATUS_KEYS = %i[status].freeze
+      private_constant :JOB_NAME_KEYS
+      private_constant :JOB_ID_KEYS
+      private_constant :JOB_PROVIDER_ID_KEYS
+      private_constant :JOB_QUEUE_NAME_KEYS
+      private_constant :JOB_PRIORITY_KEYS
+      private_constant :JOB_EXECUTION_COUNT_KEYS
+      private_constant :JOB_ENQUEUED_AT_KEYS
+      private_constant :JOB_SCHEDULED_AT_KEYS
+      private_constant :JOB_STATUS_KEYS
+
+      class << self
+        def call(fields)
+          Core::Fields::AttributeKeys.fields(
+            Core::Fields::AttributeKeys::JOB_SYSTEM => "active_job",
+            Core::Fields::AttributeKeys::JOB_NAME => first_value(fields, keys: JOB_NAME_KEYS),
+            Core::Fields::AttributeKeys::JOB_ID => first_value(fields, keys: JOB_ID_KEYS),
+            Core::Fields::AttributeKeys::JOB_PROVIDER_ID => first_value(fields, keys: JOB_PROVIDER_ID_KEYS),
+            Core::Fields::AttributeKeys::JOB_QUEUE_NAME => first_value(fields, keys: JOB_QUEUE_NAME_KEYS),
+            Core::Fields::AttributeKeys::JOB_PRIORITY => first_value(fields, keys: JOB_PRIORITY_KEYS),
+            Core::Fields::AttributeKeys::JOB_EXECUTION_COUNT => first_value(fields, keys: JOB_EXECUTION_COUNT_KEYS),
+            Core::Fields::AttributeKeys::JOB_ENQUEUED_AT => first_value(fields, keys: JOB_ENQUEUED_AT_KEYS),
+            Core::Fields::AttributeKeys::JOB_SCHEDULED_AT => first_value(fields, keys: JOB_SCHEDULED_AT_KEYS),
+            Core::Fields::AttributeKeys::JOB_STATUS => first_value(fields, keys: JOB_STATUS_KEYS)
+          )
+        end
+
+        private
+
+        def first_value(fields, keys:)
+          Core::Integration::Values::Read.first_value(fields, keys: keys)
+        end
+      end
+    end
+  end
+end

data/lib/julewire/active_job/job_execution.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "time"
+
+module Julewire
+  module ActiveJob
+    module JobExecution
+      class << self
+        def call(job, configuration: Configuration.new, &)
+          carrier = carrier_for(job)
+          return perform_job(job, configuration, &) unless configuration.propagation?
+
+          Julewire::Core::Propagation::Carrier.restore(carrier, key: configuration.carrier_key) do
+            perform_job(job, configuration, &)
+          end
+        end
+
+        private
+
+        def perform_job(job, configuration, &)
+          fields = job_fields(job)
+          Core::Integration::Facade.with_execution(**execution_options(job, configuration, fields)) do
+            install_context(fields)
+            perform_with_summary(&)
+          end
+        end
+
+        def carrier_for(job)
+          job.instance_variable_get(CARRIER_IVAR) || {}
+        rescue StandardError
+          {}
+        end
+
+        def execution_options(job, configuration, fields)
+          options = {
+            type: :job,
+            fields: { job_class: fields[:job_class] || job.class.name },
+            attributes: attributes_for(fields),
+            neutral: neutral_for(fields),
+            inherit_attributes: false,
+            summary_event: configuration.summary_event,
+            summary_severity: configuration.summary_severity,
+            summary_source: configuration.source
+          }
+          job_id = fields[:job_id]
+          options[:id] = job_id if job_id
+          options
+        end
+
+        def install_context(fields)
+          job_id = fields[:job_id]
+          Core::Integration::Facade.add_context(job_id: job_id) if job_id
+        end
+
+        def perform_with_summary
+          result = yield
+          add_summary(status: "ok")
+          result
+        rescue StandardError => e
+          add_summary(status: "error", exception_class: e.class.name)
+          raise
+        end
+
+        def add_summary(fields)
+          add_summary_neutral(fields)
+          Core::Integration::Facade.add_summary_attributes(completion_attributes(fields))
+        rescue StandardError
+          nil
+        end
+
+        def job_fields(job)
+          values = Core::Integration::Values::Shape
+          fields = { job_class: job.class.name }
+          values.append_field(fields, :job_id, job_id(job))
+          values.append_field(fields, :provider_job_id, safe_call(job, :provider_job_id))
+          values.append_field(fields, :queue, safe_call(job, :queue_name))
+          values.append_field(fields, :priority, safe_call(job, :priority))
+          values.append_field(fields, :executions, safe_call(job, :executions))
+          values.append_field(
+            fields,
+            :enqueued_at,
+            values.timestamp(safe_call(job, :enqueued_at))
+          )
+          values.append_field(
+            fields,
+            :scheduled_at,
+            values.timestamp(safe_call(job, :scheduled_at))
+          )
+          fields
+        end
+
+        def job_id(job)
+          safe_call(job, :job_id)
+        end
+
+        def attributes_for(fields)
+          { active_job: fields }
+        end
+
+        def neutral_for(fields)
+          JobAttributes.call(fields)
+        end
+
+        def add_summary_neutral(fields)
+          Core::Integration::Facade.add_summary_neutral(JobAttributes.call(fields))
+        end
+
+        def completion_attributes(fields)
+          { active_job: fields }
+        end
+
+        def safe_call(object, method_name)
+          Core::Integration::Values::Read.value(object, method_name)
+        end
+      end
+    end
+  end
+end

data/lib/julewire/active_job/job_serialization.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Julewire
+  module ActiveJob
+    module JobSerialization
+      CONFIGURATION_IVAR = :@julewire_active_job_configuration
+      CONFIGURATION_METHOD = :julewire_active_job_configuration
+
+      def serialize
+        super.tap do |job_data|
+          inject_julewire_carrier(job_data)
+        end
+      end
+
+      def deserialize(job_data)
+        extract_julewire_carrier(job_data)
+        super
+      end
+
+      private
+
+      def inject_julewire_carrier(job_data)
+        configuration = julewire_active_job_configuration
+        return unless configuration.propagation?
+
+        carrier = Julewire::Core::Propagation::Carrier.inject(
+          {},
+          key: configuration.carrier_key,
+          max_bytes: configuration.carrier_max_bytes
+        )
+        return unless carrier
+
+        value = carrier[configuration.carrier_key.to_s]
+        job_data[configuration.serialized_carrier_key] = value if value
+        IntegrationHealth.record_success(action: :carrier_inject, component: :job_serialization)
+      rescue StandardError => e
+        IntegrationHealth.record_failure(e, action: :carrier_inject, component: :job_serialization)
+      end
+
+      def extract_julewire_carrier(job_data)
+        configuration = julewire_active_job_configuration
+        unless configuration.propagation?
+          instance_variable_set(CARRIER_IVAR, {})
+          return
+        end
+
+        value = job_data[configuration.serialized_carrier_key]
+        instance_variable_set(CARRIER_IVAR, value ? { configuration.carrier_key => value } : {})
+        IntegrationHealth.record_success(action: :carrier_extract, component: :job_serialization)
+      rescue StandardError => e
+        IntegrationHealth.record_failure(e, action: :carrier_extract, component: :job_serialization)
+        instance_variable_set(CARRIER_IVAR, {})
+      end
+
+      def julewire_active_job_configuration
+        if self.class.respond_to?(CONFIGURATION_METHOD)
+          configuration = self.class.public_send(CONFIGURATION_METHOD)
+          return configuration if configuration
+        end
+
+        self.class.ancestors.each do |ancestor|
+          next unless ancestor.instance_variable_defined?(CONFIGURATION_IVAR)
+
+          return ancestor.instance_variable_get(CONFIGURATION_IVAR)
+        end
+        Julewire::ActiveJob.config
+      rescue StandardError
+        Julewire::ActiveJob.config
+      end
+    end
+  end
+end

data/lib/julewire/active_job/log_subscriber_silencer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Julewire
+  module ActiveJob
+    module LogSubscriberSilencer
+      class << self
+        def silence!
+          Core::Integration::Lifecycle.require_optional("active_job/log_subscriber")
+          subscriber_class = active_job_log_subscriber
+          return unless subscriber_class
+
+          subscriber_class.detach_from(:active_job) if subscriber_class.respond_to?(:detach_from)
+          Julewire::RailsSupport::EventReporter.unsubscribe_log_subscriber(subscriber_class)
+        end
+
+        private
+
+        def active_job_log_subscriber
+          ::ActiveJob::LogSubscriber if defined?(::ActiveJob::LogSubscriber)
+        end
+      end
+    end
+  end
+end

data/lib/julewire/active_job/railtie.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Julewire
+  module ActiveJob
+    class Railtie < ::Rails::Railtie
+      config.julewire_active_job = Julewire::ActiveJob.config
+
+      initializer "julewire.active_job" do |app|
+        Julewire::ActiveJob::Railtie.install_active_job!(app.config.julewire_active_job)
+      end
+
+      class << self
+        def install_active_job!(settings)
+          return unless settings.enabled?
+
+          ActiveSupport.on_load(:active_job) do
+            Julewire::ActiveJob.install!(base: self, configuration: settings)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/julewire/active_job/subscribers/event.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Julewire
+  module ActiveJob
+    module Subscribers
+      class Event
+        include Core::Integration::EventSubscriber
+
+        STRUCTURED_EVENT_FILE = "active_job/structured_event_subscriber"
+        ERROR_EVENTS = %w[
+          active_job.retry_stopped
+          active_job.discarded
+        ].freeze
+
+        event_subscriber integration_health: IntegrationHealth, configuration_class: Configuration
+
+        class << self
+          include Core::Integration::SubscriberInstall
+
+          def install!(configuration, event_reporter: nil)
+            return reset! unless configuration.structured_events?
+
+            Core::Integration::Lifecycle.require_optional(STRUCTURED_EVENT_FILE)
+            reporter = event_reporter || Julewire::RailsSupport::EventReporter.default
+            return unless Julewire::RailsSupport::EventReporter.subscribable?(reporter)
+
+            install_subscriber(configuration, enabled: true) do |subscriber|
+              Julewire::RailsSupport::EventReporter.subscribe(reporter, subscriber) { subscriber.accept?(it) }
+            end
+          end
+        end
+
+        def accept?(event)
+          return false unless @configuration.structured_events?
+
+          prefixes = @configuration.event_prefixes
+          return true if prefixes.nil?
+
+          name = event[:name].to_s
+          Array(prefixes).any? { name.start_with?(it.to_s) }
+        end
+
+        private
+
+        def emit_event(event)
+          name = event[:name].to_s
+          record = record_for(event, name)
+          enrich_continuation_summary(name, record.dig(:attributes, :active_job) || {})
+          Core::Integration::Facade.emit(record)
+        end
+
+        def record_for(event, name)
+          values = Core::Integration::Values::Shape
+          payload = values.payload_hash(event[:payload])
+          record = base_record(event, name, payload)
+          record[:error] = error_payload(payload) if exception_payload?(payload)
+          record
+        end
+
+        def base_record(event, name, payload)
+          values = Core::Integration::Values::Shape
+          record = {
+            severity: severity_for(name, payload),
+            event: name,
+            logger: "ActiveJob.event",
+            context: values.hash_or_empty(event[:context]),
+            attributes: attributes_for(event, payload),
+            neutral: neutral_for(event, payload)
+          }
+          values.append_field(record, :timestamp, values.timestamp(event[:timestamp]))
+          values.append_field(record, :source, @configuration.source)
+          record
+        end
+
+        def attributes_for(event, payload)
+          values = Core::Integration::Values::Shape
+          active_job = payload.empty? ? {} : payload
+          values.append_compact_field(active_job, :tags, values.hash_or_empty(event[:tags]))
+          { active_job: active_job }
+        end
+
+        def neutral_for(event, payload)
+          values = Core::Integration::Values::Shape
+          Core::Fields::FieldSet.merge!(
+            JobAttributes.call(payload),
+            values.source_location_attributes(event[:source_location])
+          )
+        end
+
+        def severity_for(name, payload)
+          return :error if ERROR_EVENTS.include?(name)
+          return :error if exception_payload?(payload)
+
+          :info
+        end
+
+        def exception_payload?(payload)
+          return false unless payload.is_a?(Hash)
+
+          payload.key?(:exception_class) ||
+            payload.key?(:exception_message) ||
+            payload.key?(:exception_backtrace)
+        end
+
+        def error_payload(payload)
+          {
+            class: payload[:exception_class],
+            message: payload[:exception_message],
+            backtrace: payload[:exception_backtrace]
+          }.compact
+        end
+
+        def enrich_continuation_summary(name, payload)
+          return unless Core::Integration::Facade.summary_active?
+
+          case name
+          when "active_job.step_started"
+            increment_summary(:continuation_steps_started)
+            add_step_summary(payload, state: "started")
+          when "active_job.step"
+            enrich_completed_step_summary(payload)
+          when "active_job.step_skipped"
+            increment_summary(:continuation_steps_skipped)
+            add_step_summary(payload, state: "skipped")
+          when "active_job.interrupt"
+            enrich_interrupt_summary(payload)
+          when "active_job.resume"
+            enrich_resume_summary(payload)
+          end
+        rescue StandardError
+          nil
+        end
+
+        def enrich_interrupt_summary(payload)
+          increment_summary(:continuation_interruptions)
+          Core::Integration::Facade.add_summary_attributes(
+            active_job: {
+              continuation_status: "interrupted",
+              continuation_description: payload[:description],
+              continuation_interrupt_reason: payload[:reason]
+            }
+          )
+        end
+
+        def enrich_resume_summary(payload)
+          increment_summary(:continuation_resumptions)
+          Core::Integration::Facade.add_summary_attributes(
+            active_job: {
+              continuation_status: "resumed",
+              continuation_description: payload[:description]
+            }
+          )
+        end
+
+        def enrich_completed_step_summary(payload)
+          if payload[:interrupted]
+            increment_summary(:continuation_steps_interrupted)
+            add_step_summary(payload, state: "interrupted")
+          elsif exception_payload?(payload)
+            increment_summary(:continuation_steps_failed)
+            add_step_summary(payload, state: "failed")
+          else
+            increment_summary(:continuation_steps_completed)
+            add_step_summary(payload, state: "completed")
+          end
+        end
+
+        def add_step_summary(payload, state:)
+          Core::Integration::Facade.add_summary_attributes(
+            active_job: {
+              continuation_last_step: payload[:step],
+              continuation_last_step_cursor: payload[:cursor],
+              continuation_last_step_state: state,
+              continuation_last_step_resumed: payload[:resumed]
+            }
+          )
+        end
+
+        def increment_summary(key)
+          Core::Integration::Facade.increment_summary_attribute(:active_job, key)
+        end
+      end
+    end
+  end
+end

data/lib/julewire/active_job/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Julewire
+  module ActiveJob
+    VERSION = "1.0.0"
+  end
+end

data/lib/julewire/active_job.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "julewire/core"
+require "julewire/rails_support"
+
+module Julewire
+  module ActiveJob
+    class Error < Julewire::Error; end
+    CARRIER_IVAR = :@julewire_carrier
+    IntegrationHealth = Core::Integration::Health.scoped(:active_job)
+    private_constant :CARRIER_IVAR
+
+    extend Core::Integration::Configurable
+
+    configurable_with { Configuration }
+
+    class << self
+      def install!(base: nil, event_reporter: nil, configuration: config)
+        Installer.install!(base: base, event_reporter: event_reporter, configuration: configuration)
+      end
+
+      def perform(job, &)
+        JobExecution.call(job, configuration: config, &)
+      end
+
+      def load_railtie_if_rails!
+        Railtie if defined?(::Rails::Railtie)
+      end
+    end
+  end
+
+  loader = Zeitwerk::Loader.for_gem_extension(self)
+  # Rails-only autoload, skipped when non-Rails processes eager load the gem.
+  loader.do_not_eager_load("#{__dir__}/active_job/railtie.rb")
+  loader.setup
+  Julewire::ActiveJob.load_railtie_if_rails!
+end

data/lib/julewire-active_job.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "julewire/active_job"

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: julewire-active_job
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Alexander Grebennik
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '8.1'
+- !ruby/object:Gem::Dependency
+  name: julewire-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: julewire-rails_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.1
+description: Execution-scoped Active Job instrumentation, structured event capture,
+  and propagation carrier support for Julewire.
+email:
+- slbug@users.noreply.github.com
+- sl.bug.sl@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- docs/advanced-configuration.md
+- docs/boundaries.md
+- docs/configuration.md
+- docs/continuations.md
+- docs/propagation.md
+- julewire-active_job.gemspec
+- lib/julewire-active_job.rb
+- lib/julewire/active_job.rb
+- lib/julewire/active_job/configuration.rb
+- lib/julewire/active_job/installer.rb
+- lib/julewire/active_job/job_attributes.rb
+- lib/julewire/active_job/job_execution.rb
+- lib/julewire/active_job/job_serialization.rb
+- lib/julewire/active_job/log_subscriber_silencer.rb
+- lib/julewire/active_job/railtie.rb
+- lib/julewire/active_job/subscribers/event.rb
+- lib/julewire/active_job/version.rb
+homepage: https://github.com/slbug/julewire
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/slbug/julewire
+  source_code_uri: https://github.com/slbug/julewire/tree/main/gems/active_job
+  changelog_uri: https://github.com/slbug/julewire/blob/main/gems/active_job/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.14
+specification_version: 4
+summary: Active Job integration for Julewire structured logging.
+test_files: []