opentelemetry-instrumentation-active_job 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9883ad6f02901443d677d0b85537cd4091a4a423409ae6a4e341da2ac272309b
-  data.tar.gz: bdff117ee07172051d7c46b8419732c0ea8cef8e4117417eed7cb8b9155f8435
+  metadata.gz: beffc5272c390fbbd9ea98797106691f5e48d45b4f82cbd41c40856e051bab2b
+  data.tar.gz: 98a1656bebf82443f7ba8a7fd6037f05c260ba41d2430fd8376e7ebe073ef113
 SHA512:
-  metadata.gz: 0ce37abfec5100fc8a231d5efb96d92b3ab38aae81c54cb1e60f851b5068ca481c4685e3dcee11e41c6161f7d4154da707815559445f0ccd0310b81a413cc688
-  data.tar.gz: a1c6f5bcdaee79d0800e9abb098c4ea97a5db49ec745a503cb30d83341b2a2b259f0ac36bc6771ea8ffb5bed415dfa2e9d906769f45beef8e2ff26e4d10cdbc9
+  metadata.gz: 49516a6e6edc52fc8c431d3ee99c707e61c4c5437fb3c3c4fe13658e544528a0299ba645e8f5d413dc6bb2297d0d2d5d792b1421ce639aa339ac3aaecc739207
+  data.tar.gz: dc85ceb2997eccf9557fd22b25f90fe78892c0663b6d19ce80355d0b19721970b13a9ce861dc38b26e360eee484601dc7cc93d4c6dd45a842a7f3ef3d6286f5c

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Release History: opentelemetry-instrumentation-active_job
 
+### v0.7.0 / 2023-11-22
+
+* BREAKING CHANGE: Drop Rails 6.0 EOL
+
+* ADDED: Drop Rails 6.0 EOL
+
+* BREAKING CHANGE: Use ActiveSupport Instrumentation instead of Monkey Patches
+
+* CHANGED: Use ActiveSupport Instrumentation instead of Money Patches [#677](https://github.com/open-telemetry/opentelemetry-ruby-contrib/pull/677)
+
 ### v0.6.1 / 2023-10-16
 
 * FIXED: Add Rails 7.1 compatibility

data/README.md

@@ -30,6 +30,64 @@ OpenTelemetry::SDK.configure do |c|
 end
 ```
 
+## Active Support Instrumentation
+
+Earlier versions of this instrumentation relied on registering custom `around_perform` hooks in order to deal with limitations
+in `ActiveSupport::Notifications`, however those patches resulted in error reports and inconsistent behavior when combined with other gems.
+
+This instrumentation now relies entirely on `ActiveSupport::Notifications` and registers a custom Subscriber that listens to relevant events to report as spans.
+
+See the table below for details of what [Rails Framework Hook Events](https://guides.rubyonrails.org/active_support_instrumentation.html#active-job) are recorded by this instrumentation:
+
+| Event Name | Creates Span? | Notes |
+| - | - | - |
+| `enqueue_at.active_job` | :white_check_mark: | Creates an egress span with kind `producer` |
+| `enqueue.active_job` | :white_check_mark: | Creates an egress span with kind `producer` |
+| `enqueue_retry.active_job` | :white_check_mark: | Creates an `internal` span |
+| `perform_start.active_job` | :x: | This is invoked prior to the appropriate ingress point and is therefore ignored |
+| `perform.active_job` | :white_check_mark: | Creates an ingress span with kind `consumer` |
+| `retry_stopped.active_job` | :white_check_mark: | Creates and `internal` span with an `exception` event |
+| `discard.active_job` | :white_check_mark: | Creates and `internal` span with an `exception` event |
+
+## Semantic Conventions
+
+This instrumentation generally uses [Messaging semantic conventions](https://opentelemetry.io/docs/specs/semconv/messaging/messaging-spans/) by treating job enqueuers as `producers` and workers as `consumers`.
+
+Internal spans are named using the name of the `ActiveSupport` event that was provided.
+
+Attributes that are specific to this instrumentation are recorded under `messaging.active_job.*`:
+
+| Attribute Name | Type | Notes |
+| - | - | - |
+| `code.namespace` | String | `ActiveJob` class name |
+| `messaging.system` | String | Static value set to `active_job` |
+| `messaging.destination` | String | Set from `ActiveJob#queue_name` |
+| `messaging.message.id` | String | Set from `ActiveJob#job_id` |
+| `messaging.active_job.adapter.name` | String | The name of the `ActiveJob` adapter implementation |
+| `messaging.active_job.message.priority` | String | Present when set by the client from `ActiveJob#priority` |
+| `messaging.active_job.message.provider_job_id` | String | Present if the underlying adapter has backend specific message ids |
+
+## Differences between ActiveJob versions
+
+### ActiveJob 6.1
+
+`perform.active_job` events do not include timings for `ActiveJob` callbacks therefore time spent in `before` and `after` hooks will be missing
+
+### ActiveJob 7+
+
+`perform.active_job` no longer includes exceptions handled using `rescue_from` in the payload.
+
+In order to preserve this behavior you will have to update the span yourself, e.g.
+
+```ruby
+  rescue_from MyCustomError do |e|
+    # Custom code to handle the error
+    span = OpenTelemetry::Instrumentation::ActiveJob.current_span
+    span.record_exception(e)
+    span.status = OpenTelemetry::Trace::Status.error('Job failed')
+  end
+```
+
 ## Examples
 
 Example usage can be seen in the `./example/active_job.rb` file [here](https://github.com/open-telemetry/opentelemetry-ruby-contrib/blob/main/instrumentation/active_job/example/active_job.rb)

data/lib/opentelemetry/instrumentation/active_job/handlers/default.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module ActiveJob
+      module Handlers
+        # Default handler to create internal spans for events
+        # This class provides default template methods that derived classes may override to generate spans and register contexts.
+        class Default
+          # @param parent_span_provider [Object] provides access to the top most parent span (usually the ingress span)
+          # @param mapper [Callable] converts ActiveSupport::Notifications payloads to span attributes
+          # @param config [Hash] of instrumentation options
+          def initialize(parent_span_provider, mapper, config)
+            @mapper = mapper
+            @config = config
+            @parent_span_provider = parent_span_provider
+          end
+
+          # Invoked by ActiveSupport::Notifications at the start of the instrumentation block
+          # It amends the otel context of a Span and Context tokens to the payload
+          #
+          # @param name [String] of the Event
+          # @param id [String] of the event
+          # @param payload [Hash] containing job run information
+          # @return [Hash] the payload passed as a method argument
+          def start(name, id, payload)
+            payload.merge!(__otel: start_span(name, id, payload))
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          end
+
+          # Creates a span and registers it with the current context
+          #
+          # @param name [String] of the Event
+          # @param id [String] of the event
+          # @param payload [Hash] containing job run information
+          # @return [Hash] with the span and generated context tokens
+          def start_span(name, _id, payload)
+            span = tracer.start_span(name, attributes: @mapper.call(payload))
+            tokens = [OpenTelemetry::Context.attach(OpenTelemetry::Trace.context_with_span(span))]
+
+            { span: span, ctx_tokens: tokens }
+          end
+
+          # Creates a span and registers it with the current context
+          #
+          # @param _name [String] of the Event (unused)
+          # @param _id [String] of the event (unused)
+          # @param payload [Hash] containing job run information
+          # @return [Hash] with the span and generated context tokens
+          def finish(_name, _id, payload)
+            otel = payload.delete(:__otel)
+            span = otel&.fetch(:span)
+            tokens = otel&.fetch(:ctx_tokens)
+
+            on_exception((payload[:error] || payload[:exception_object]), span)
+          rescue StandardError => e
+            OpenTelemetry.handle_error(exception: e)
+          ensure
+            finish_span(span, tokens)
+          end
+
+          # Finishes the provided spans and also detaches the associated contexts
+          #
+          # @param span [OpenTelemetry::Trace::Span]
+          # @param tokens [Array] to unregister
+          def finish_span(span, tokens)
+            # closes the span after all attributes have been finalized
+            begin
+              if span&.recording?
+                span.status = OpenTelemetry::Trace::Status.ok if span.status.code == OpenTelemetry::Trace::Status::UNSET
+                span.finish
+              end
+            rescue StandardError => e
+              OpenTelemetry.handle_error(exception: e)
+            end
+
+            # pops the context stack
+            tokens&.reverse&.each do |token|
+              OpenTelemetry::Context.detach(token)
+            rescue StandardError => e
+              OpenTelemetry.handle_error(exception: e)
+            end
+          end
+
+          # Records exceptions on spans and sets Span statuses to `Error`
+          #
+          # Handled exceptions are recorded on internal spans related to the event. E.g. `discard` events are recorded on the `discard.active_job` span
+          # Handled exceptions _are not_ copied to the ingress span, but it does set the status to `Error` making it easier to know that a job has failed
+          # Unhandled exceptions bubble up to the ingress span and are recorded there.
+          #
+          # @param [Exception] exception to report as a Span Event
+          # @param [OpenTelemetry::Trace::Span] the currently active span used to record the exception and set the status
+          def on_exception(exception, span)
+            return unless exception && span
+
+            span.record_exception(exception)
+            span.status =
+              @parent_span_provider.current_span.status =
+                OpenTelemetry::Trace::Status.error("Unexpected ActiveJob Error #{exception.class.name}")
+          end
+
+          def tracer
+            OpenTelemetry::Instrumentation::ActiveJob::Instrumentation.instance.tracer
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/active_job/handlers/enqueue.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module ActiveJob
+      module Handlers
+        # Handles `enqueue.active_job` and `enqueue_at.active_job` to generate egress spans
+        class Enqueue < Default
+          def initialize(...)
+            super
+            @span_name_formatter = if @config[:span_naming] == :job_class
+                                     ->(job) { "#{job.class.name} publish" }
+                                   else
+                                     ->(job) { "#{job.queue_name} publish" }
+                                   end
+          end
+
+          # Overrides the `Default#start_span` method to create an egress span
+          # and registers it with the current context
+          #
+          # @param name [String] of the Event
+          # @param id [String] of the event
+          # @param payload [Hash] containing job run information
+          # @return [Hash] with the span and generated context tokens
+          def start_span(name, _id, payload)
+            job = payload.fetch(:job)
+            span = tracer.start_span(@span_name_formatter.call(job), kind: :producer, attributes: @mapper.call(payload))
+            tokens = [OpenTelemetry::Context.attach(OpenTelemetry::Trace.context_with_span(span))]
+            OpenTelemetry.propagation.inject(job.__otel_headers) # This must be transmitted over the wire
+            { span: span, ctx_tokens: tokens }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/active_job/handlers/perform.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module ActiveJob
+      module Handlers
+        # Handles perform.active_job to generate ingress spans
+        class Perform < Default
+          def initialize(...)
+            super
+            @span_name_formatter = if @config[:span_naming] == :job_class
+                                     ->(job) { "#{job.class.name} process" }
+                                   else
+                                     ->(job) { "#{job.queue_name} process" }
+                                   end
+          end
+
+          # Overrides the `Default#start_span` method to create an ingress span
+          # and registers it with the current context
+          #
+          # @param name [String] of the Event
+          # @param id [String] of the event
+          # @param payload [Hash] containing job run information
+          # @return [Hash] with the span and generated context tokens
+          def start_span(name, _id, payload)
+            tokens = []
+            job = payload.fetch(:job)
+            parent_context = OpenTelemetry.propagation.extract(job.__otel_headers)
+
+            span_name = @span_name_formatter.call(job)
+
+            # TODO: Refactor into a propagation strategy
+            propagation_style = @config[:propagation_style]
+            if propagation_style == :child
+              tokens << OpenTelemetry::Context.attach(parent_context)
+              span = tracer.start_span(span_name, kind: :consumer, attributes: @mapper.call(payload))
+            else
+              span_context = OpenTelemetry::Trace.current_span(parent_context).context
+              links = [OpenTelemetry::Trace::Link.new(span_context)] if span_context.valid? && propagation_style == :link
+              span = tracer.start_root_span(span_name, kind: :consumer, attributes: @mapper.call(payload), links: links)
+            end
+
+            tokens.concat(attach_consumer_context(span))
+
+            { span: span, ctx_tokens: tokens }
+          end
+
+          # This method attaches a span to multiple contexts:
+          # 1. Registers the ingress span as the top level ActiveJob span.
+          #    This is used later to enrich the ingress span in children, e.g. setting span status to error when a child event like `discard` terminates due to an error
+          # 2. Registers the ingress span as the "active" span, which is the default behavior of the SDK.
+          # @param span [OpenTelemetry::Trace::Span] the currently active span used to record the exception and set the status
+          # @return [Array] Context tokens that must be detached when finished
+          def attach_consumer_context(span)
+            consumer_context = OpenTelemetry::Trace.context_with_span(span)
+            internal_context = OpenTelemetry::Instrumentation::ActiveJob.context_with_span(span, parent_context: consumer_context)
+
+            [consumer_context, internal_context].map { |context| OpenTelemetry::Context.attach(context) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/active_job/handlers.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require_relative 'mappers/attribute'
+require_relative 'handlers/default'
+require_relative 'handlers/enqueue'
+require_relative 'handlers/perform'
+
+module OpenTelemetry
+  module Instrumentation
+    module ActiveJob
+      # Module that contains custom event handlers, which are used to generate spans per event
+      module Handlers
+        module_function
+
+        # Subscribes Event Handlers to relevant ActiveJob notifications
+        #
+        # The following events are recorded as spans:
+        # - enqueue
+        # - enqueue_at
+        # - enqueue_retry
+        # - perform
+        # - retry_stopped
+        # - discard
+        #
+        # Ingress and Egress spans (perform, enqueue, enqueue_at) use Messaging semantic conventions for naming the span,
+        # while internal spans keep their ActiveSupport event name.
+        #
+        # @note this method is not thread safe and should not be used in a multi-threaded context
+        # @note Why no perform_start?
+        #       This event causes much heartache as it is the first in a series of events that is triggered.
+        #       It should not be the ingress span because it does not measure anything.
+        #       https://github.com/rails/rails/blob/v6.1.7.6/activejob/lib/active_job/instrumentation.rb#L14
+        #       https://github.com/rails/rails/blob/v7.0.8/activejob/lib/active_job/instrumentation.rb#L19
+        def subscribe
+          return unless Array(@subscriptions).empty?
+
+          mapper = Mappers::Attribute.new
+          config = ActiveJob::Instrumentation.instance.config
+          parent_span_provider = OpenTelemetry::Instrumentation::ActiveJob
+
+          # TODO, use delegation instead of inheritance
+          default_handler = Handlers::Default.new(parent_span_provider, mapper, config)
+          enqueue_handler = Handlers::Enqueue.new(parent_span_provider, mapper, config)
+          perform_handler = Handlers::Perform.new(parent_span_provider, mapper, config)
+
+          handlers_by_pattern = {
+            'enqueue' => enqueue_handler,
+            'enqueue_at' => enqueue_handler,
+            'enqueue_retry' => default_handler,
+            'perform' => perform_handler,
+            'retry_stopped' => default_handler,
+            'discard' => default_handler
+          }
+
+          @subscriptions = handlers_by_pattern.map do |key, handler|
+            ::ActiveSupport::Notifications.subscribe("#{key}.active_job", handler)
+          end
+        end
+
+        # Removes Event Handler Subscriptions for ActiveJob notifications
+        # @note this method is not thread-safe and should not be used in a multi-threaded context
+        def unsubscribe
+          @subscriptions&.each { |subscriber| ActiveSupport::Notifications.unsubscribe(subscriber) }
+          @subscriptions = nil
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/active_job/instrumentation.rb

@@ -9,7 +9,7 @@ module OpenTelemetry
     module ActiveJob
       # The Instrumentation class contains logic to detect and install the ActiveJob instrumentation
       class Instrumentation < OpenTelemetry::Instrumentation::Base
-        MINIMUM_VERSION = Gem::Version.new('6.0.0')
+        MINIMUM_VERSION = Gem::Version.new('6.1.0')
 
         install do |_config|
           require_dependencies
@@ -17,7 +17,7 @@ module OpenTelemetry
         end
 
         present do
-          defined?(::ActiveJob)
+          defined?(::ActiveJob) && defined?(::ActiveSupport)
         end
 
         compatible do
@@ -64,12 +64,13 @@ module OpenTelemetry
 
         def require_dependencies
           require_relative 'patches/base'
-          require_relative 'patches/active_job_callbacks'
+          require_relative 'handlers'
         end
 
         def patch_activejob
-          ::ActiveJob::Base.prepend(Patches::Base)
-          ::ActiveJob::Base.prepend(Patches::ActiveJobCallbacks)
+          ::ActiveJob::Base.prepend(Patches::Base) unless ::ActiveJob::Base.ancestors.include?(Patches::Base)
+
+          Handlers.subscribe
         end
       end
     end

data/lib/opentelemetry/instrumentation/active_job/mappers/attribute.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module ActiveJob
+      module Mappers
+        # Maps ActiveJob Attributes to Semantic Conventions
+        class Attribute
+          # Generates a set of attributes to add to a span using
+          # general and messaging semantic conventions as well as
+          # using `rails.active_job.*` namespace for custom attributes
+          #
+          # @param payload [Hash] of an ActiveSupport::Notifications payload
+          # @return [Hash<String, Object>] of semantic attributes
+          def call(payload)
+            job = payload.fetch(:job)
+
+            otel_attributes = {
+              'code.namespace' => job.class.name,
+              'messaging.system' => 'active_job',
+              'messaging.destination' => job.queue_name,
+              'messaging.message.id' => job.job_id,
+              'messaging.active_job.adapter.name' => job.class.queue_adapter_name
+            }
+
+            # Not all adapters generate or provide back end specific ids for messages
+            otel_attributes['messaging.active_job.message.provider_job_id'] = job.provider_job_id.to_s if job.provider_job_id
+            # This can be problematic if programs use invalid attribute types like Symbols for priority instead of using Integers.
+            otel_attributes['messaging.active_job.message.priority'] = job.priority.to_s if job.priority
+
+            otel_attributes.compact!
+
+            otel_attributes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/active_job/patches/base.rb

@@ -12,22 +12,33 @@ module OpenTelemetry
         module Base
           def self.prepended(base)
             base.class_eval do
-              attr_accessor :metadata
+              attr_accessor :__otel_headers
             end
           end
 
-          def initialize(*args)
-            @metadata = {}
+          def initialize(...)
+            @__otel_headers = {}
             super
           end
-          ruby2_keywords(:initialize) if respond_to?(:ruby2_keywords, true)
 
           def serialize
-            super.merge('metadata' => serialize_arguments(metadata))
+            message = super
+
+            begin
+              message.merge!('__otel_headers' => serialize_arguments(@__otel_headers))
+            rescue StandardError => e
+              OpenTelemetry.handle_error(exception: e)
+            end
+
+            message
           end
 
           def deserialize(job_data)
-            self.metadata = deserialize_arguments(job_data['metadata'] || []).to_h
+            begin
+              @__otel_headers = deserialize_arguments(job_data.delete('__otel_headers') || []).to_h
+            rescue StandardError => e
+              OpenTelemetry.handle_error(exception: e)
+            end
             super
           end
         end

data/lib/opentelemetry/instrumentation/active_job/version.rb

@@ -7,7 +7,7 @@
 module OpenTelemetry
   module Instrumentation
     module ActiveJob
-      VERSION = '0.6.1'
+      VERSION = '0.7.0'
     end
   end
 end

data/lib/opentelemetry/instrumentation/active_job.rb

@@ -11,6 +11,39 @@ module OpenTelemetry
   module Instrumentation
     # Contains the OpenTelemetry instrumentation for the ActiveJob gem
     module ActiveJob
+      extend self
+
+      CURRENT_SPAN_KEY = Context.create_key('current-span')
+      private_constant :CURRENT_SPAN_KEY
+
+      # Returns the current span from the current or provided context
+      #
+      # @param [optional Context] context The context to lookup the current
+      #   {Span} from. Defaults to Context.current
+      def current_span(context = nil)
+        context ||= Context.current
+        context.value(CURRENT_SPAN_KEY) || OpenTelemetry::Trace::Span::INVALID
+      end
+
+      # Returns a context containing the span, derived from the optional parent
+      # context, or the current context if one was not provided.
+      #
+      # @param [optional Context] context The context to use as the parent for
+      #   the returned context
+      def context_with_span(span, parent_context: Context.current)
+        parent_context.set_value(CURRENT_SPAN_KEY, span)
+      end
+
+      # Activates/deactivates the Span within the current Context, which makes the "current span"
+      # available implicitly.
+      #
+      # On exit, the Span that was active before calling this method will be reactivated.
+      #
+      # @param [Span] span the span to activate
+      # @yield [span, context] yields span and a context containing the span to the block.
+      def with_span(span)
+        Context.with_value(CURRENT_SPAN_KEY, span) { |c, s| yield s, c }
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-instrumentation-active_job
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-16 00:00:00.000000000 Z
+date: 2023-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: '6.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -122,20 +122,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -220,18 +206,22 @@ files:
 - lib/opentelemetry-instrumentation-active_job.rb
 - lib/opentelemetry/instrumentation.rb
 - lib/opentelemetry/instrumentation/active_job.rb
+- lib/opentelemetry/instrumentation/active_job/handlers.rb
+- lib/opentelemetry/instrumentation/active_job/handlers/default.rb
+- lib/opentelemetry/instrumentation/active_job/handlers/enqueue.rb
+- lib/opentelemetry/instrumentation/active_job/handlers/perform.rb
 - lib/opentelemetry/instrumentation/active_job/instrumentation.rb
-- lib/opentelemetry/instrumentation/active_job/patches/active_job_callbacks.rb
+- lib/opentelemetry/instrumentation/active_job/mappers/attribute.rb
 - lib/opentelemetry/instrumentation/active_job/patches/base.rb
 - lib/opentelemetry/instrumentation/active_job/version.rb
 homepage: https://github.com/open-telemetry/opentelemetry-ruby-contrib
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-active_job/0.6.1/file/CHANGELOG.md
+  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-active_job/0.7.0/file/CHANGELOG.md
   source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/tree/main/instrumentation/active_job
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/issues
-  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-active_job/0.6.1
+  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-active_job/0.7.0
 post_install_message: 
 rdoc_options: []
 require_paths:

data/lib/opentelemetry/instrumentation/active_job/patches/active_job_callbacks.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module Instrumentation
-    module ActiveJob
-      module Patches
-        # Module to prepend to ActiveJob::Base for instrumentation.
-        module ActiveJobCallbacks
-          def self.prepended(base)
-            base.class_eval do
-              around_enqueue do |job, block|
-                span_kind = job.class.queue_adapter_name == 'inline' ? :client : :producer
-                span_name = "#{otel_config[:span_naming] == :job_class ? job.class : job.queue_name} publish"
-                span_attributes = job_attributes(job)
-                otel_tracer.in_span(span_name, attributes: span_attributes, kind: span_kind) do
-                  OpenTelemetry.propagation.inject(job.metadata)
-                  block.call
-                end
-              end
-            end
-          end
-
-          def perform_now
-            span_kind = self.class.queue_adapter_name == 'inline' ? :server : :consumer
-            span_name = "#{otel_config[:span_naming] == :job_class ? self.class : queue_name} process"
-            span_attributes = job_attributes(self).merge('messaging.operation' => 'process', 'code.function' => 'perform_now')
-            executions_count = (executions || 0) + 1 # because we run before the count is incremented in ActiveJob::Execution
-
-            extracted_context = OpenTelemetry.propagation.extract(metadata)
-            OpenTelemetry::Context.with_current(extracted_context) do
-              if otel_config[:propagation_style] == :child
-                otel_tracer.in_span(span_name, attributes: span_attributes, kind: span_kind) do |span|
-                  span.set_attribute('messaging.active_job.executions', executions_count)
-                  super
-                end
-              else
-                span_links = []
-                if otel_config[:propagation_style] == :link
-                  span_context = OpenTelemetry::Trace.current_span(extracted_context).context
-                  span_links << OpenTelemetry::Trace::Link.new(span_context) if span_context.valid?
-                end
-
-                root_span = otel_tracer.start_root_span(span_name, attributes: span_attributes, links: span_links, kind: span_kind)
-                OpenTelemetry::Trace.with_span(root_span) do |span|
-                  span.set_attribute('messaging.active_job.executions', executions_count)
-                  super
-                rescue Exception => e # rubocop:disable Lint/RescueException
-                  span.record_exception(e)
-                  span.status = OpenTelemetry::Trace::Status.error("Unhandled exception of type: #{e.class}")
-                  raise e
-                ensure
-                  root_span.finish
-                end
-              end
-            end
-          ensure
-            # We may be in a job system (eg: resque) that forks and kills worker processes often.
-            # We don't want to lose spans by not flushing any span processors, so we optionally force it here.
-            OpenTelemetry.tracer_provider.force_flush if otel_config[:force_flush]
-          end
-
-          private
-
-          def job_attributes(job)
-            otel_attributes = {
-              'code.namespace' => job.class.name,
-              'messaging.destination_kind' => 'queue',
-              'messaging.system' => job.class.queue_adapter_name,
-              'messaging.destination' => job.queue_name,
-              'messaging.message_id' => job.job_id,
-              'messaging.active_job.provider_job_id' => job.provider_job_id,
-              'messaging.active_job.scheduled_at' => job.scheduled_at&.to_f,
-              'messaging.active_job.priority' => job.priority
-            }
-
-            otel_attributes['net.transport'] = 'inproc' if %w[async inline].include?(job.class.queue_adapter_name)
-
-            otel_attributes.compact
-          end
-
-          def otel_tracer
-            ActiveJob::Instrumentation.instance.tracer
-          end
-
-          def otel_config
-            ActiveJob::Instrumentation.instance.config
-          end
-        end
-      end
-    end
-  end
-end