rails-otel-context 0.9.9 → 0.9.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4eb35396c5cddc8f420624441b7f2bdacf2d1ef005510db0855cb9803cfb4635
-  data.tar.gz: e8a3ffbb994abad920bf7ccbc66903777d380952711237ca4ce0cd7ef153c7c0
+  metadata.gz: 2aec3d090a6f44452bd03610c73ccc2f06793896736c2d71c46433ac06f508a9
+  data.tar.gz: 3eb8e4627ec08271bfba16bca39b205e09bd1ee60f40bc218fbb745a138ad18b
 SHA512:
-  metadata.gz: b1c75e3474d1d922f96427658daafbe73b7ca41e9f8f59a6654f7cc2ef4576a7d055287d1fb95b75161a1c178848350672f7b05f798ef080aef50236d6d36824
-  data.tar.gz: e2708c7b6dfa266cd62f66d7b302f54aa181108b47fa7fc589fe5e5a0645a42bab0a4d73753f3fd3c326df24c99280052b025808995cda86815662d7848bb573
+  metadata.gz: a080a6664fac57852d9f774390cd6b938aaef8b4d2149cd204815d31248855d396dd4e8023ba1f111bd63b222351f42668d2908256477dca46170256edf8792a
+  data.tar.gz: 5b22380700691214524ba6539084748c47de7e76cd2238c905f3aee788823126ebcdd624169252cef54fe2693267c7535d141e2849ee4c7c22f4e5780a4a747b

data/README.md

@@ -140,8 +140,8 @@ RailsOtelContext.configure do |c|
   c.span_name_formatter = lambda { |original, ar| ... }
 end
 
-RailsOtelContext.install! # registers AR hooks, around_action, and the span processor
-
+# Configure the OTel SDK before calling install! so the processor is
+# registered on the real TracerProvider, not the pre-configure proxy.
 require 'opentelemetry/sdk'
 require 'opentelemetry/exporter/otlp'
 require 'opentelemetry/instrumentation/all'
@@ -150,10 +150,25 @@ OpenTelemetry::SDK.configure do |c|
   c.service_name = ENV.fetch('OTEL_SERVICE_NAME', 'my_app')
   c.use_all
 end
+
+RailsOtelContext.install! # registers AR hooks, around_action, and the span processor
 ```
 
 `install!` is idempotent — the railtie calls it automatically via `after_initialize`, so apps that let Bundler auto-require the gem do not need to call it.
 
+### Two-initializer pattern
+
+If your OTel SDK setup lives in a separate initializer that loads after the gem (e.g., Rails loads `rails_otel_context.rb` before `tracing.rb` alphabetically), call `install_processor!` at the end of the SDK initializer. Since 0.9.10, `install_processor!` tracks provider identity and re-registers automatically when `SDK.configure` has replaced the provider:
+
+```ruby
+# config/initializers/tracing.rb  (loads after rails_otel_context.rb)
+OpenTelemetry::SDK.configure do |c|
+  c.use_all
+end
+
+RailsOtelContext.install_processor! if defined?(RailsOtelContext)
+```
+
 ## How `code.namespace` / `code.function` works
 
 On every span start, the gem walks the Ruby call stack (`Thread.each_caller_location`) and finds the first frame inside `Rails.root`. That frame becomes the four `code.*` attributes.

data/lib/rails_otel_context/activerecord_context.rb

@@ -46,6 +46,16 @@ module RailsOtelContext
       def singleton_method_added(name)
         super
 
+        # Internal aliases created below (and by ScopeNameTracking) re-trigger
+        # this hook; wrapping them would route calls back through the wrapper
+        # and break receiver dispatch.
+        return if name.to_s.start_with?('__otel')
+
+        # ScopeNameTracking's redefinition of a scope method also re-triggers
+        # this hook. That method is already wrapped — wrapping it again would
+        # add a useless closure hop and leak a __otel_cm_orig_* alias.
+        return if @_otel_wrapped_scopes&.key?(name)
+
         @_otel_wrapped_class_methods ||= {}
         return if @_otel_wrapped_class_methods[name]
 
@@ -63,11 +73,14 @@ module RailsOtelContext
 
         # Mark before define_singleton_method to prevent re-entrancy for this name
         @_otel_wrapped_class_methods[name] = true
-        name_str = name.to_s.freeze
-        original = method(name)
+        name_str   = name.to_s.freeze
+        alias_name = :"__otel_cm_orig_#{name}"
+        # Alias instead of capturing a bound Method so inherited class methods
+        # keep self = the actual receiver (see ScopeNameTracking).
+        singleton_class.alias_method(alias_name, name)
 
         define_singleton_method(name) do |*args, **kwargs, &blk|
-          result = original.call(*args, **kwargs, &blk)
+          result = send(alias_name, *args, **kwargs, &blk)
           if defined?(::ActiveRecord::Relation) && result.is_a?(::ActiveRecord::Relation)
             result.instance_variable_set(:@_otel_scope_name, name_str)
           end
@@ -132,26 +145,40 @@ module RailsOtelContext
     # Wraps scope-generated class methods to store the scope name on the Relation.
     module ScopeNameTracking
       def scope(name, body, &)
-        super
-
-        # Guard against double-wrapping on class reload in development
+        # Guard against double-wrapping on class reload in development.
+        # Marked BEFORE super so ClassMethodScopeTracking's
+        # singleton_method_added hook (which fires for both the scope macro's
+        # definition and our redefinition below) sees the name as owned by
+        # this module and skips it.
         @_otel_wrapped_scopes ||= {}
-        return if @_otel_wrapped_scopes[name]
+        return super if @_otel_wrapped_scopes[name]
 
-        name_str = name.to_s.freeze
-        original = method(name)
-        define_singleton_method(name) do |*args|
-          relation = original.call(*args)
+        @_otel_wrapped_scopes[name] = true
+        super
+
+        name_str   = name.to_s.freeze
+        alias_name = :"__otel_scope_orig_#{name}"
+        # Alias instead of capturing a bound Method: a bound Method locks self
+        # to the defining class, so inherited scopes would run with self =
+        # parent and re-evaluate default_scope in the wrong class context.
+        # send(alias_name) dispatches with self = the actual receiver.
+        singleton_class.alias_method(alias_name, name)
+        define_singleton_method(name) do |*args, **kwargs, &blk|
+          relation = send(alias_name, *args, **kwargs, &blk)
           if relation.is_a?(::ActiveRecord::Relation)
             relation.instance_variable_set(:@_otel_scope_name, name_str)
           end
           relation
         end
-        @_otel_wrapped_scopes[name] = true
       end
     end
 
     # Captures scope name from Relation at SQL materialization time.
+    #
+    # exec_queries covers record-loading (.to_a, .load). Aggregate and existence
+    # queries take separate paths that never call exec_queries -- count/sum/etc.
+    # go through #calculate, and #pluck / #exists? are their own methods -- so each
+    # needs the same scope-key capture to tag its sql.active_record span.
     module RelationScopeCapture
       def exec_queries(&)
         scope_name = instance_variable_get(:@_otel_scope_name)
@@ -160,6 +187,30 @@ module RailsOtelContext
       ensure
         Thread.current[SCOPE_THREAD_KEY] = nil
       end
+
+      def calculate(*args, **kwargs, &)
+        scope_name = instance_variable_get(:@_otel_scope_name)
+        Thread.current[SCOPE_THREAD_KEY] = scope_name if scope_name
+        super
+      ensure
+        Thread.current[SCOPE_THREAD_KEY] = nil
+      end
+
+      def pluck(*args, &)
+        scope_name = instance_variable_get(:@_otel_scope_name)
+        Thread.current[SCOPE_THREAD_KEY] = scope_name if scope_name
+        super
+      ensure
+        Thread.current[SCOPE_THREAD_KEY] = nil
+      end
+
+      def exists?(*args)
+        scope_name = instance_variable_get(:@_otel_scope_name)
+        Thread.current[SCOPE_THREAD_KEY] = scope_name if scope_name
+        super
+      ensure
+        Thread.current[SCOPE_THREAD_KEY] = nil
+      end
     end
 
     module_function

data/lib/rails_otel_context/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsOtelContext
-  VERSION = '0.9.9'
+  VERSION = '0.9.11'
 end

data/lib/rails_otel_context.rb

@@ -51,22 +51,35 @@ module RailsOtelContext
     end
 
     # Registers CallContextProcessor with the OTel tracer_provider.
-    # Called automatically by install!. Call this manually only when the OTel
-    # SDK is configured after install! has already run (rare):
+    # Called automatically by install!. Safe to call manually after a second
+    # OpenTelemetry::SDK.configure call replaces the tracer_provider — the
+    # method detects the provider change and re-registers automatically:
     #
     #   RailsOtelContext.install!          # hooks up AR/request context
-    #   OpenTelemetry::SDK.configure { … } # SDK configured later
-    #   RailsOtelContext.install_processor! # add processor to the now-real provider
+    #   OpenTelemetry::SDK.configure { … } # second SDK configure (replaces provider)
+    #   RailsOtelContext.install_processor! # re-registers on the new provider
     #
-    # Safe to call multiple times — idempotent.
+    # Idempotent per provider instance: re-registers when OpenTelemetry::SDK.configure
+    # is called again (which replaces the global tracer_provider with a new object),
+    # but skips registration when called multiple times against the same provider.
     def install_processor!
-      return if @processor_installed
       return unless defined?(Rails) && Rails.root
-      return unless OpenTelemetry.tracer_provider.respond_to?(:add_span_processor)
+      return unless defined?(OpenTelemetry)
+
+      # Capture once: tracer_provider is a global that SDK.configure can replace
+      # on another thread. A single local read makes the rest of the method consistent.
+      provider = OpenTelemetry.tracer_provider
+      return unless provider.respond_to?(:add_span_processor)
+
+      # Use object identity, not a boolean flag. SDK.configure creates a new
+      # TracerProvider instance each time, so equal? detects provider replacement
+      # and triggers re-registration, while guarding against double-registration
+      # on the same provider.
+      return if @processor_registered_on.equal?(provider)
 
-      @processor_installed = true
+      @processor_registered_on = provider
       processor = RailsOtelContext::CallContextProcessor.new(app_root: Rails.root)
-      OpenTelemetry.tracer_provider.add_span_processor(processor)
+      provider.add_span_processor(processor)
     end
 
     private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-otel-context
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.9.11
 platform: ruby
 authors:
 - Last9