ddtrace 1.12.1 → 1.13.0

data/lib/datadog/core/utils/hash.rb

@@ -26,6 +26,53 @@ module Datadog
             end
           end
         end
+
+        # A minimal {Hash} wrapper that provides case-insensitive access
+        # to hash keys, without the overhead of copying the original hash.
+        #
+        # This class should be used when the original hash is short lived *and*
+        # each hash key is only accesses a few times.
+        # For other cases, create a copy of the original hash with the keys
+        # normalized adequate to your use case.
+        class CaseInsensitiveWrapper
+          def initialize(hash)
+            raise ArgumentError, "must be a hash, but was #{hash.class}: #{hash.inspect}" unless hash.is_a?(::Hash)
+
+            @hash = hash
+          end
+
+          def [](key)
+            return nil unless key.is_a?(::String)
+
+            @hash.each do |k, value|
+              return value if key.casecmp(k) == 0
+            end
+
+            nil
+          end
+
+          def key?(key)
+            return false unless key.is_a?(::String)
+
+            @hash.each_key do |k|
+              return true if key.casecmp(k) == 0
+            end
+
+            false
+          end
+
+          def empty?
+            @hash.empty?
+          end
+
+          def length
+            @hash.length
+          end
+
+          def original_hash
+            @hash
+          end
+        end
       end
     end
   end

data/lib/datadog/core/utils/network.rb

@@ -101,7 +101,7 @@ module Datadog
           end
 
           def strip_ipv6_port(ip)
-            if /\[(.*)\](?::\d+)?/ =~ ip
+            if /\[([^\]]*+)\](?::\d+)?/ =~ ip
               Regexp.last_match(1)
             else
               ip

data/lib/datadog/core/utils/safe_dup.rb

@@ -1,40 +1,47 @@
+require_relative '../backport'
+
 module Datadog
   module Core
     module Utils
       # Helper methods for safer dup
       module SafeDup
-        if RUBY_VERSION < '2.2' # nil.dup only fails in Ruby 2.1
-          # Ensures #initialize can call nil.dup safely
-          module RefineNil
-            refine NilClass do
-              def dup
-                self
-              end
-            end
-          end
-
-          using RefineNil
-        end
-
         # String#+@ was introduced in Ruby 2.3
         if String.method_defined?(:+@) && String.method_defined?(:-@)
           def self.frozen_or_dup(v)
-            # If the string is not frozen, the +(-v) will:
-            # - first create a frozen deduplicated copy with -v
-            # - then it will dup it more efficiently with +v
-            v.frozen? ? v : +(-v)
+            # For the case of a String we use the methods +@ and -@.
+            # Those methods are only for String objects
+            # they are faster and chepaer on the memory side.
+            # Check the benchmark on
+            # https://github.com/DataDog/dd-trace-rb/pull/2704
+            if v.is_a?(String)
+              # If the string is not frozen, the +(-v) will:
+              # - first create a frozen deduplicated copy with -v
+              # - then it will dup it more efficiently with +v
+              v.frozen? ? v : +(-v)
+            else
+              v.frozen? ? v : Core::BackportFrom24.dup(v)
+            end
           end
 
           def self.frozen_dup(v)
-            -v if v
+            # For the case of a String we use the methods -@
+            # That method are only for String objects
+            # they are faster and chepaer on the memory side.
+            # Check the benchmark on
+            # https://github.com/DataDog/dd-trace-rb/pull/2704
+            if v.is_a?(String)
+              -v if v
+            else
+              v.frozen? ? v : Core::BackportFrom24.dup(v).freeze
+            end
           end
         else
           def self.frozen_or_dup(v)
-            v.frozen? ? v : v.dup
+            v.frozen? ? v : Core::BackportFrom24.dup(v)
           end
 
           def self.frozen_dup(v)
-            v.frozen? ? v : v.dup.freeze
+            v.frozen? ? v : Core::BackportFrom24.dup(v).freeze
           end
         end
       end

data/lib/datadog/core/utils.rb

@@ -67,7 +67,7 @@ module Datadog
       # @!visibility private
       def self.without_warnings
         # This is typically used when monkey patching functions such as
-        # intialize, which Ruby advices you not to. Use cautiously.
+        # initialize, which Ruby advices you not to. Use cautiously.
         v = $VERBOSE
         $VERBOSE = nil
         begin

data/lib/datadog/core/workers/async.rb

@@ -90,7 +90,7 @@ module Datadog
             :result
 
           def mutex
-            @mutex || MUTEX_INIT.synchronize { @mutex ||= Mutex.new }
+            (defined?(@mutex) && @mutex) || MUTEX_INIT.synchronize { @mutex ||= Mutex.new }
           end
 
           def after_fork
@@ -103,7 +103,7 @@ module Datadog
             :pid
 
           def mutex_after_fork
-            @mutex_after_fork || MUTEX_INIT.synchronize { @mutex_after_fork ||= Mutex.new }
+            (defined?(@mutex_after_fork) && @mutex_after_fork) || MUTEX_INIT.synchronize { @mutex_after_fork ||= Mutex.new }
           end
 
           def worker

data/lib/datadog/kit/appsec/events.rb

@@ -9,109 +9,159 @@ module Datadog
       module Events
         LOGIN_SUCCESS_EVENT = 'users.login.success'
         LOGIN_FAILURE_EVENT = 'users.login.failure'
-
-        # Attach login success event information to the trace
-        #
-        # This method is experimental and may change in the future.
-        #
-        # @param trace [TraceOperation] Trace to attach data to. Defaults to
-        #   active trace.
-        # @param span [SpanOperation] Span to attach data to. Defaults to
-        #   active span on trace. Note that this should be a service entry span.
-        #   When AppSec is enabled, the expected span and trace are automatically
-        #   used as defaults.
-        # @param user [Hash<Symbol, String>] User information to pass to
-        #   Datadog::Kit::Identity.set_user. Must contain at least :id as key.
-        # @param others [Hash<String || Symbol, String>] Additional free-form
-        #   event information to attach to the trace.
-        def self.track_login_success(trace = nil, span = nil, user:, **others)
-          if (appsec_scope = Datadog::AppSec.active_scope)
-            trace = appsec_scope.trace
-            span = appsec_scope.service_entry_span
+        SIGNUP_EVENT = 'users.signup'
+
+        class << self
+          # Attach login success event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param user [Hash<Symbol, String>] User information to pass to
+          #   Datadog::Kit::Identity.set_user. Must contain at least :id as key.
+          # @param others [Hash<String || Symbol, String>] Additional free-form
+          #   event information to attach to the trace.
+          def track_login_success(trace = nil, span = nil, user:, **others)
+            set_trace_and_span_context('track_login_success', trace, span) do |active_trace, active_span|
+              user_options = user.dup
+              user_id = user_options.delete(:id)
+
+              raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
+
+              track(LOGIN_SUCCESS_EVENT, active_trace, active_span, **others)
+
+              Kit::Identity.set_user(active_trace, active_span, id: user_id, **user_options)
+            end
           end
 
-          trace ||= Datadog::Tracing.active_trace
-          span ||= trace.active_span || Datadog::Tracing.active_span
-
-          raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
-
-          track(LOGIN_SUCCESS_EVENT, trace, span, **others)
-
-          user_options = user.dup
-          user_id = user_options.delete(:id)
-
-          raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
+          # Attach login failure event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param user_id [String] User id that attempted login
+          # @param user_exists [bool] Whether the user id that did a login attempt exists.
+          # @param others [Hash<String || Symbol, String>] Additional free-form
+          #   event information to attach to the trace.
+          def track_login_failure(trace = nil, span = nil, user_id:, user_exists:, **others)
+            set_trace_and_span_context('track_login_failure', trace, span) do |active_trace, active_span|
+              raise ArgumentError, 'user_id cannot be nil' if user_id.nil?
+
+              track(LOGIN_FAILURE_EVENT, active_trace, active_span, **others)
+
+              active_span.set_tag('appsec.events.users.login.failure.usr.id', user_id)
+              active_span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists)
+            end
+          end
 
-          Kit::Identity.set_user(trace, span, id: user_id, **user_options)
-        end
+          # Attach signup event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param user [Hash<Symbol, String>] User information to pass to
+          #   Datadog::Kit::Identity.set_user. Must contain at least :id as key.
+          # @param others [Hash<String || Symbol, String>] Additional free-form
+          #   event information to attach to the trace.
+          def track_signup(trace = nil, span = nil, user:, **others)
+            set_trace_and_span_context('track_signup', trace, span) do |active_trace, active_span|
+              user_options = user.dup
+              user_id = user_options.delete(:id)
+
+              raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
+
+              track(SIGNUP_EVENT, active_trace, active_span, **others)
+
+              Kit::Identity.set_user(trace, id: user_id, **user_options)
+            end
+          end
 
-        # Attach login failure event information to the trace
-        #
-        # This method is experimental and may change in the future.
-        #
-        # @param trace [TraceOperation] Trace to attach data to. Defaults to
-        #   active trace.
-        # @param span [SpanOperation] Span to attach data to. Defaults to
-        #   active span on trace. Note that this should be a service entry span.
-        #   When AppSec is enabled, the expected span and trace are automatically
-        #   used as defaults.
-        # @param user_id [String] User id that attempted login
-        # @param user_exists [bool] Whether the user id that did a login attempt exists.
-        # @param others [Hash<String || Symbol, String>] Additional free-form
-        #   event information to attach to the trace.
-        def self.track_login_failure(trace = nil, span = nil, user_id:, user_exists:, **others)
-          if (appsec_scope = Datadog::AppSec.active_scope)
-            trace = appsec_scope.trace
-            span = appsec_scope.service_entry_span
+          # Attach custom event information to the trace
+          #
+          # This method is experimental and may change in the future.
+          #
+          # @param event [String] Mandatory. Event code.
+          # @param trace [TraceOperation] Trace to attach data to. Defaults to
+          #   active trace.
+          # @param span [SpanOperation] Span to attach data to. Defaults to
+          #   active span on trace. Note that this should be a service entry span.
+          #   When AppSec is enabled, the expected span and trace are automatically
+          #   used as defaults.
+          # @param others [Hash<Symbol, String>] Additional free-form
+          #   event information to attach to the trace. Key must not
+          #   be :track.
+          def track(event, trace = nil, span = nil, **others)
+            if trace && span
+              check_trace_span_integrity(trace, span)
+
+              span.set_tag("appsec.events.#{event}.track", 'true')
+              span.set_tag("_dd.appsec.events.#{event}.sdk", 'true')
+
+              others.each do |k, v|
+                raise ArgumentError, 'key cannot be :track' if k.to_sym == :track
+
+                span.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
+              end
+
+              trace.keep!
+            else
+              set_trace_and_span_context('track', trace, span) do |active_trace, active_span|
+                active_span.set_tag("appsec.events.#{event}.track", 'true')
+                active_span.set_tag("_dd.appsec.events.#{event}.sdk", 'true')
+
+                others.each do |k, v|
+                  raise ArgumentError, 'key cannot be :track' if k.to_sym == :track
+
+                  active_span.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
+                end
+
+                active_trace.keep!
+              end
+            end
           end
 
-          trace ||= Datadog::Tracing.active_trace
-          span ||= trace.active_span || Datadog::Tracing.active_span
+          private
 
-          raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+          def set_trace_and_span_context(method, trace = nil, span = nil)
+            if (appsec_scope = Datadog::AppSec.active_scope)
+              trace = appsec_scope.trace
+              span = appsec_scope.service_entry_span
+            end
 
-          track(LOGIN_FAILURE_EVENT, trace, span, **others)
+            trace ||= Datadog::Tracing.active_trace
+            span ||=  trace && trace.active_span || Datadog::Tracing.active_span
 
-          raise ArgumentError, 'user_id cannot be nil' if user_id.nil?
+            unless trace && span
+              Datadog.logger.debug(
+                "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}"\
+                ' to track this events'
+              )
+              return
+            end
 
-          span.set_tag('appsec.events.users.login.failure.usr.id', user_id)
-          span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists)
-        end
+            check_trace_span_integrity(trace, span)
 
-        # Attach custom event information to the trace
-        #
-        # This method is experimental and may change in the future.
-        #
-        # @param event [String] Mandatory. Event code.
-        # @param trace [TraceOperation] Trace to attach data to. Defaults to
-        #   active trace.
-        # @param span [SpanOperation] Span to attach data to. Defaults to
-        #   active span on trace. Note that this should be a service entry span.
-        #   When AppSec is enabled, the expected span and trace are automatically
-        #   used as defaults.
-        # @param others [Hash<Symbol, String>] Additional free-form
-        #   event information to attach to the trace. Key must not
-        #   be :track.
-        def self.track(event, trace = nil, span = nil, **others)
-          if (appsec_scope = Datadog::AppSec.active_scope)
-            trace = appsec_scope.trace
-            span = appsec_scope.service_entry_span
+            yield(trace, span)
           end
 
-          trace ||= Datadog::Tracing.active_trace
-          span ||= trace.active_span || Datadog::Tracing.active_span
-
-          raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
-
-          span.set_tag("appsec.events.#{event}.track", 'true')
-
-          others.each do |k, v|
-            raise ArgumentError, 'key cannot be :track' if k.to_sym == :track
-
-            span.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
+          def check_trace_span_integrity(trace, span)
+            raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
           end
-
-          trace.keep!
         end
       end
     end

data/lib/datadog/kit/identity.rb

@@ -6,84 +6,99 @@ module Datadog
   module Kit
     # Tracking identity via traces
     module Identity
-      # Attach user information to the trace
-      #
-      # @param trace [TraceOperation] Trace to attach data to. Defaults to
-      #   active trace.
-      # @param span [SpanOperation] Span to attach data to. Defaults to
-      #   active span on trace. Note that this should be a service entry span.
-      #   When AppSec is enabled, the expected span and trace are automatically
-      #   used as defaults.
-      # @param id [String] Mandatory. Username or client id extracted
-      #   from the access token or Authorization header in the inbound request
-      #   from outside the system.
-      # @param email [String] Email of the authenticated user associated
-      #   to the trace.
-      # @param name [String] User-friendly name. To be displayed in the
-      #   UI if set.
-      # @param session_id [String] Session ID of the authenticated user.
-      # @param role [String] Actual/assumed role the client is making
-      #   the request under extracted from token or application security
-      #   context.
-      # @param scope [String] Scopes or granted authorities the client
-      #   currently possesses extracted from token or application security
-      #   context. The value would come from the scope associated with an OAuth
-      #   2.0 Access Token or an attribute value in a SAML 2.0 Assertion.
-      # @param others [Hash<Symbol, String>] Additional free-form
-      #   user information to attach to the trace.
-      #
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
-      # rubocop:disable Metrics/AbcSize
-      def self.set_user(
-        trace = nil, span = nil, id:, email: nil, name: nil, session_id: nil, role: nil, scope: nil, **others
-      )
-        raise ArgumentError, 'missing required key: :id' if id.nil?
+      class << self
+        # Attach user information to the trace
+        #
+        # @param trace [TraceOperation] Trace to attach data to. Defaults to
+        #   active trace.
+        # @param span [SpanOperation] Span to attach data to. Defaults to
+        #   active span on trace. Note that this should be a service entry span.
+        #   When AppSec is enabled, the expected span and trace are automatically
+        #   used as defaults.
+        # @param id [String] Mandatory. Username or client id extracted
+        #   from the access token or Authorization header in the inbound request
+        #   from outside the system.
+        # @param email [String] Email of the authenticated user associated
+        #   to the trace.
+        # @param name [String] User-friendly name. To be displayed in the
+        #   UI if set.
+        # @param session_id [String] Session ID of the authenticated user.
+        # @param role [String] Actual/assumed role the client is making
+        #   the request under extracted from token or application security
+        #   context.
+        # @param scope [String] Scopes or granted authorities the client
+        #   currently possesses extracted from token or application security
+        #   context. The value would come from the scope associated with an OAuth
+        #   2.0 Access Token or an attribute value in a SAML 2.0 Assertion.
+        # @param others [Hash<Symbol, String>] Additional free-form
+        #   user information to attach to the trace.
+        #
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def set_user(
+          trace = nil, span = nil, id:, email: nil, name: nil, session_id: nil, role: nil, scope: nil, **others
+        )
+          raise ArgumentError, 'missing required key: :id' if id.nil?
 
-        # enforce types
+          # enforce types
 
-        raise TypeError, ':id must be a String'         unless id.is_a?(String)
-        raise TypeError, ':email must be a String'      unless email.nil? || email.is_a?(String)
-        raise TypeError, ':name must be a String'       unless name.nil? || name.is_a?(String)
-        raise TypeError, ':session_id must be a String' unless session_id.nil? || session_id.is_a?(String)
-        raise TypeError, ':role must be a String'       unless role.nil? || role.is_a?(String)
-        raise TypeError, ':scope must be a String'      unless scope.nil? || scope.is_a?(String)
+          raise TypeError, ':id must be a String'         unless id.is_a?(String)
+          raise TypeError, ':email must be a String'      unless email.nil? || email.is_a?(String)
+          raise TypeError, ':name must be a String'       unless name.nil? || name.is_a?(String)
+          raise TypeError, ':session_id must be a String' unless session_id.nil? || session_id.is_a?(String)
+          raise TypeError, ':role must be a String'       unless role.nil? || role.is_a?(String)
+          raise TypeError, ':scope must be a String'      unless scope.nil? || scope.is_a?(String)
 
-        others.each do |k, v|
-          raise TypeError, "#{k.inspect} must be a String" unless v.nil? || v.is_a?(String)
-        end
+          others.each do |k, v|
+            raise TypeError, "#{k.inspect} must be a String" unless v.nil? || v.is_a?(String)
+          end
+
+          set_trace_and_span_context('set_user', trace, span) do |_active_trace, active_span|
+            # set tags once data is known consistent
+            active_span.set_tag('usr.id', id)
+            active_span.set_tag('usr.email', email)           unless email.nil?
+            active_span.set_tag('usr.name', name)             unless name.nil?
+            active_span.set_tag('usr.session_id', session_id) unless session_id.nil?
+            active_span.set_tag('usr.role', role)             unless role.nil?
+            active_span.set_tag('usr.scope', scope)           unless scope.nil?
 
-        if (appsec_scope = Datadog::AppSec.active_scope)
-          trace = appsec_scope.trace
-          span = appsec_scope.service_entry_span
+            others.each do |k, v|
+              active_span.set_tag("usr.#{k}", v) unless v.nil?
+            end
+
+            if Datadog::AppSec.active_scope
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+          end
         end
+        # rubocop:enable Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
 
-        trace ||= Datadog::Tracing.active_trace
-        span ||= trace.active_span || Datadog::Tracing.active_span
+        private
 
-        raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+        def set_trace_and_span_context(method, trace = nil, span = nil)
+          if (appsec_scope = Datadog::AppSec.active_scope)
+            trace = appsec_scope.trace
+            span = appsec_scope.service_entry_span
+          end
 
-        # set tags once data is known consistent
+          trace ||= Datadog::Tracing.active_trace
+          span ||= trace && trace.active_span || Datadog::Tracing.active_span
 
-        span.set_tag('usr.id', id)
-        span.set_tag('usr.email', email)           unless email.nil?
-        span.set_tag('usr.name', name)             unless name.nil?
-        span.set_tag('usr.session_id', session_id) unless session_id.nil?
-        span.set_tag('usr.role', role)             unless role.nil?
-        span.set_tag('usr.scope', scope)           unless scope.nil?
+          unless trace && span
+            Datadog.logger.debug(
+              "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}"\
+              ' to track this events'
+            )
+            return
+          end
 
-        others.each do |k, v|
-          span.set_tag("usr.#{k}", v) unless v.nil?
-        end
+          raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
 
-        if appsec_scope
-          user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id)
-          ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+          yield(trace, span)
         end
       end
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/PerceivedComplexity
-      # rubocop:enable Metrics/CyclomaticComplexity
     end
   end
 end

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -21,11 +21,13 @@ module Datadog
           gc_profiling_enabled:,
           allocation_counting_enabled:,
           no_signals_workaround_enabled:,
+          timeline_enabled:,
           thread_context_collector: ThreadContext.new(
             recorder: recorder,
             max_frames: max_frames,
             tracer: tracer,
             endpoint_collection_enabled: endpoint_collection_enabled,
+            timeline_enabled: timeline_enabled,
           ),
           idle_sampling_helper: IdleSamplingHelper.new,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
@@ -76,6 +78,7 @@ module Datadog
                 )
               end
             end
+            @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
           end
 
           true

data/lib/datadog/profiling/collectors/idle_sampling_helper.rb

@@ -42,6 +42,7 @@ module Datadog
                 )
               end
             end
+            @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
           end
 
           true

data/lib/datadog/profiling/collectors/thread_context.rb

@@ -14,9 +14,16 @@ module Datadog
       #
       # Methods prefixed with _native_ are implemented in `collectors_thread_context.c`
       class ThreadContext
-        def initialize(recorder:, max_frames:, tracer:, endpoint_collection_enabled:)
+        def initialize(recorder:, max_frames:, tracer:, endpoint_collection_enabled:, timeline_enabled:)
           tracer_context_key = safely_extract_context_key_from(tracer)
-          self.class._native_initialize(self, recorder, max_frames, tracer_context_key, endpoint_collection_enabled)
+          self.class._native_initialize(
+            self,
+            recorder,
+            max_frames,
+            tracer_context_key,
+            endpoint_collection_enabled,
+            timeline_enabled,
+          )
         end
 
         def inspect