rails-otel-context 0.9.10 → 0.9.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85776a38085568bcfb92c95343e435b3c3838d7e215c75d4242397c136b3aaed
-  data.tar.gz: dec0e60af1f7757c68788ed55475cf9cead5bb8d3a3c7f15461708be3b8edf6f
+  metadata.gz: 2aec3d090a6f44452bd03610c73ccc2f06793896736c2d71c46433ac06f508a9
+  data.tar.gz: 3eb8e4627ec08271bfba16bca39b205e09bd1ee60f40bc218fbb745a138ad18b
 SHA512:
-  metadata.gz: 4ea73be1284f26a3e18984aef619a51f8812861ab75305165e8a5eb2218c7149baacaca130081e2f2a2e90e3054f2e9aca2d1a5724f86365d502a6dcddde109a
-  data.tar.gz: 3945fff4851e07829f334a9b7170ed116c206cb52f84d432bff81a188447b1c25d17a25122983912b21da380af4efd01a6915def6bfdedef4b317a4c13ee273d
+  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.10'
+  VERSION = '0.9.11'
 end

metadata

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