refactor(ruby): drop the job extension registry

Author: solnic

sentry-ruby/lib/sentry-ruby.rb

@@ -66,8 +66,6 @@ module Sentry
     exception_locals_tp
   ].freeze
 
-  JOB_EXTENSIONS = JobExtensions::Registry.new
-
   class << self
     # @!visibility private
     def exception_locals_tp
@@ -153,27 +151,6 @@ def register_integration(name, version)
       integrations[name.to_s] = meta
     end
 
-    ##### Job Extensions #####
-
-    # Returns the process-wide registry of background-job extensions.
-    #
-    # @return [JobExtensions::Registry]
-    def job_extensions
-      JOB_EXTENSIONS
-    end
-
-    # Registers a background-job extension built by a backend gem. It can be
-    # called at load time, before or after {Sentry.init}.
-    #
-    # @param extension [JobExtensions::Extension] an extension instance,
-    #   constructed with its own configuration and collaborators
-    # @return [JobExtensions::Extension] the registered extension
-    # @raise [ArgumentError] if the argument is not a {JobExtensions::Extension}
-    #   instance, or an extension with the same name is already registered
-    def register_job_extension(extension)
-      job_extensions.register(extension)
-    end
-
     ##### Method Delegation #####
 
     extend Forwardable

sentry-ruby/lib/sentry/job_extensions.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "sentry/job_extensions/extension"
-require "sentry/job_extensions/registry"
 require "sentry/job_extensions/instrumentation"
 require "sentry/job_extensions/consumer"
 require "sentry/job_extensions/producer"

sentry-ruby/lib/sentry/job_extensions/consumer.rb

@@ -7,15 +7,14 @@ class Consumer < Instrumentation
       OP_NAME = "queue.process"
 
       def apply_scope_data(scope, job)
-        data = registry.for(job).scope_data(job: job)
+        data = extension.scope_data(job: job)
         scope.set_contexts(data[:contexts]) if data[:contexts]
         scope.set_tags(data[:tags]) if data[:tags]
         scope.set_extras(data[:extra]) if data[:extra]
         scope.set_user(data[:user]) if data[:user]
       end
 
       def start_transaction(scope, job, trace_headers: {})
-        extension = registry.for(job)
         options = {
           name: scope.transaction_name,
           source: scope.transaction_source,
@@ -31,9 +30,9 @@ def start_transaction(scope, job, trace_headers: {})
         return unless transaction
 
         scope.set_span(transaction)
-        safely(extension, "record the messaging data") do
+        safely("record the messaging data") do
           set_messaging_data(transaction, extension.messaging_data(job: job))
-          set_retry_count(transaction, extension, job)
+          set_retry_count(transaction, job)
         end
 
         transaction
@@ -47,15 +46,14 @@ def finish_transaction(transaction, status)
       end
 
       def report_exception?(job, exception)
-        registry.for(job).report_exception?(job: job, exception: exception)
+        extension.report_exception?(job: job, exception: exception)
       end
 
       def report_retried_exception?(job, exception)
-        registry.for(job).report_retried_exception?(job: job, exception: exception)
+        extension.report_retried_exception?(job: job, exception: exception)
       end
 
       def capture_exception(job, exception, contexts: {}, tags: {}, extra: {})
-        extension = registry.for(job)
         error_data = additive_error_data(extension.error_data(job: job, exception: exception))
 
         options = {

sentry-ruby/lib/sentry/job_extensions/extension.rb

@@ -5,26 +5,12 @@ module JobExtensions
     # Base class for objects that let a background-job backend enrich Sentry's
     # job integrations.
     #
-    # A backend gem subclasses this class, receives everything the extension
-    # depends on (configuration, collaborators) through its constructor, and
-    # registers one instance with {Sentry.register_job_extension}. Sentry treats
-    # jobs as opaque objects: only the extension interprets the job it is given.
-    #
-    # @example Defining and registering an extension
-    #   class MyBackend::SentryJobExtension < Sentry::JobExtensions::Extension
-    #     def initialize(config:)
-    #       super(name: "my_backend")
-    #       @config = config
-    #     end
-    #
-    #     def handles?(job)
-    #       job.class.queue_adapter_name.to_s == "my_backend"
-    #     end
-    #   end
-    #
-    #   Sentry.register_job_extension(MyBackend::SentryJobExtension.new(config: MyBackend.config))
+    # A backend gem subclasses this class and receives everything the extension
+    # depends on (configuration, collaborators) through its constructor. Sentry
+    # treats jobs as opaque objects: only the extension interprets the job it is
+    # given.
     class Extension
-      # The extension's unique name. No two registered extensions can share it.
+      # The extension's name, used to identify it in SDK log messages.
       #
       # @return [String]
       attr_reader :name
@@ -40,22 +26,10 @@ def initialize(name:)
         @name = name.to_s.dup.freeze
       end
 
-      # Whether this extension handles the given job. Override it to claim
-      # the jobs run by the extension's backend.
-      #
-      # If this method raises a StandardError, the failure is logged through the
-      # SDK logger and the extension is treated as not handling the job.
-      #
-      # @param job [Object] the job, as passed by the job integration
-      # @return [Boolean] false unless overridden
-      def handles?(job)
-        false
-      end
-
       # @!group Hooks
       #
-      # Hooks are called directly by job integrations on the extension that
-      # handles the job. Each hook maps its input to data and must not mutate
+      # Hooks are called directly by job integrations on the extension they
+      # are given. Each hook maps its input to data and must not mutate
       # the objects it is given; the job integration applies the returned
       # data. Override only the hooks the backend can supply.
 

sentry-ruby/lib/sentry/job_extensions/instrumentation.rb

@@ -13,15 +13,15 @@ class Instrumentation
         receive_latency: Span::DataConventions::MESSAGING_MESSAGE_RECEIVE_LATENCY
       }.freeze
 
-      attr_reader :registry
+      attr_reader :extension
 
-      def initialize(registry: Sentry.job_extensions)
-        @registry = registry
+      def initialize(extension:)
+        @extension = extension
       end
 
       private
 
-      def safely(extension, context, fallback: nil)
+      def safely(context, fallback: nil)
         yield
       rescue StandardError => e
         log_error("Job extension #{extension.name.inspect} failed to #{context}", e)
@@ -34,7 +34,7 @@ def set_messaging_data(span, data)
         end
       end
 
-      def set_retry_count(span, extension, job)
+      def set_retry_count(span, job)
         span.set_data(Span::DataConventions::MESSAGING_MESSAGE_RETRY_COUNT, extension.retry_info(job: job)[:count])
       end
 

sentry-ruby/lib/sentry/job_extensions/producer.rb

@@ -7,10 +7,8 @@ class Producer < Instrumentation
       OP_NAME = "queue.publish"
 
       def record_span(job)
-        extension = registry.for(job)
-
         Sentry.with_child_span(op: OP_NAME) do |span|
-          safely(extension, "record the publish span") { describe_span(span, extension, job) } if span
+          safely("record the publish span") { describe_span(span, job) } if span
 
           yield
         end
@@ -21,16 +19,16 @@ def prepare_payload(job, payload)
       end
 
       def inject_trace_headers(job, payload, headers)
-        registry.for(job).inject_trace_headers(job: job, payload: payload, headers: headers)
+        extension.inject_trace_headers(job: job, payload: payload, headers: headers)
       end
 
       private
 
-      def describe_span(span, extension, job)
+      def describe_span(span, job)
         span.set_description(extension.publish_description(job: job))
         span.set_origin(extension.span_origin(job: job))
         set_messaging_data(span, extension.publish_messaging_data(job: job))
-        set_retry_count(span, extension, job)
+        set_retry_count(span, job)
       end
 
       class Delegated < Producer

sentry-ruby/lib/sentry/job_extensions/registry.rb

@@ -15,16 +15,12 @@ module TestJobsIntegration
   let(:string_io) { StringIO.new }
 
   def consumer(**hooks)
-    registry = Sentry::JobExtensions::Registry.new
-    registry.register(
-      Class.new(Sentry::JobExtensions::Extension) do
-        define_method(:handles?) { |_job| true }
-        define_method(:span_origin) { |job:| "auto.queue.test" }
-        define_method(:integration) { |job:| Sentry::TestJobsIntegration }
-        hooks.each { |hook, body| define_method(hook, &body) }
-      end.new(name: "test_backend")
-    )
-    described_class.new(registry: registry)
+    extension = Class.new(Sentry::JobExtensions::Extension) do
+      define_method(:span_origin) { |job:| "auto.queue.test" }
+      define_method(:integration) { |job:| Sentry::TestJobsIntegration }
+      hooks.each { |hook, body| define_method(hook, &body) }
+    end.new(name: "test_backend")
+    described_class.new(extension: extension)
   end
 
   def scope

sentry-ruby/spec/sentry/job_extensions/consumer_spec.rb

@@ -5,16 +5,12 @@
   let(:string_io) { StringIO.new }
 
   def producer(**hooks)
-    registry = Sentry::JobExtensions::Registry.new
-    registry.register(
-      Class.new(Sentry::JobExtensions::Extension) do
-        define_method(:handles?) { |_job| true }
-        define_method(:span_origin) { |job:| "auto.queue.test" }
-        define_method(:publish_description) { |job:| "TestJob" }
-        hooks.each { |hook, body| define_method(hook, &body) }
-      end.new(name: "test_backend")
-    )
-    described_class.new(registry: registry)
+    extension = Class.new(Sentry::JobExtensions::Extension) do
+      define_method(:span_origin) { |job:| "auto.queue.test" }
+      define_method(:publish_description) { |job:| "TestJob" }
+      hooks.each { |hook, body| define_method(hook, &body) }
+    end.new(name: "test_backend")
+    described_class.new(extension: extension)
   end
 
   def enriching_producer