datadog 2.3.0 → 2.4.0

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

@@ -20,6 +20,8 @@ module Datadog
           tracer:,
           endpoint_collection_enabled:,
           timeline_enabled:,
+          waiting_for_gvl_threshold_ns:,
+          otel_context_enabled:,
           allocation_type_enabled: true
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
@@ -30,10 +32,34 @@ module Datadog
             tracer_context_key,
             endpoint_collection_enabled,
             timeline_enabled,
+            waiting_for_gvl_threshold_ns,
+            otel_context_enabled,
             allocation_type_enabled,
           )
         end
 
+        def self.for_testing(
+          recorder:,
+          max_frames: 400,
+          tracer: nil,
+          endpoint_collection_enabled: false,
+          timeline_enabled: false,
+          waiting_for_gvl_threshold_ns: 10_000_000,
+          otel_context_enabled: false,
+          **options
+        )
+          new(
+            recorder: recorder,
+            max_frames: max_frames,
+            tracer: tracer,
+            endpoint_collection_enabled: endpoint_collection_enabled,
+            timeline_enabled: timeline_enabled,
+            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
+            otel_context_enabled: otel_context_enabled,
+            **options,
+          )
+        end
+
         def inspect
           # Compose Ruby's default inspect with our custom inspect for the native parts
           result = super()

data/lib/datadog/profiling/component.rb

@@ -62,6 +62,7 @@ module Datadog
           dynamic_sampling_rate_overhead_target_percentage: overhead_target_percentage,
           allocation_profiling_enabled: allocation_profiling_enabled,
           allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
+          gvl_profiling_enabled: enable_gvl_profiling?(settings),
         )
 
         internal_metadata = {
@@ -89,6 +90,8 @@ module Datadog
           tracer: optional_tracer,
           endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
           timeline_enabled: timeline_enabled,
+          waiting_for_gvl_threshold_ns: settings.profiling.advanced.waiting_for_gvl_threshold_ns,
+          otel_context_enabled: settings.profiling.advanced.preview_otel_context_enabled,
         )
       end
 
@@ -252,6 +255,7 @@ module Datadog
         legacy_ruby_that_should_use_workaround = RUBY_VERSION.start_with?("2.5.")
 
         unless [true, false, :auto].include?(setting_value)
+          # TODO: Replace with a warning instead.
           Datadog.logger.error(
             "Ignoring invalid value for profiling no_signals_workaround_enabled setting: #{setting_value.inspect}. " \
             "Valid options are `true`, `false` or (default) `:auto`."
@@ -394,6 +398,7 @@ module Datadog
         if overhead_target_percentage > 0 && overhead_target_percentage <= 20
           overhead_target_percentage
         else
+          # TODO: Replace with a warning instead.
           Datadog.logger.error(
             "Ignoring invalid value for profiling overhead_target_percentage setting: " \
             "#{overhead_target_percentage.inspect}. Falling back to default value."
@@ -433,13 +438,24 @@ module Datadog
       end
 
       private_class_method def self.dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)
-        return false if no_signals_workaround_enabled
-
-        # NOTE: In the future this method will evolve to check for Ruby versions affected and not apply the workaround
-        # when it's not needed but currently all known Ruby versions are affected.
+        return false if no_signals_workaround_enabled || RUBY_VERSION >= "3.4"
 
         settings.profiling.advanced.dir_interruption_workaround_enabled
       end
+
+      private_class_method def self.enable_gvl_profiling?(settings)
+        if RUBY_VERSION < "3.2"
+          if settings.profiling.advanced.preview_gvl_enabled
+            Datadog.logger.warn("GVL profiling is currently not supported in Ruby < 3.2 and will not be enabled.")
+          end
+
+          return false
+        end
+
+        # GVL profiling only makes sense in the context of timeline. We could emit a warning here, but not sure how
+        # useful it is -- if a customer disables timeline, there's nowhere to look for GVL profiling anyway!
+        settings.profiling.advanced.timeline_enabled && settings.profiling.advanced.preview_gvl_enabled
+      end
     end
   end
 end

data/lib/datadog/profiling/http_transport.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../core/transport/ext"
+require_relative "../core/telemetry/logger"
 
 module Datadog
   module Profiling
@@ -60,10 +61,14 @@ module Datadog
               "Failed to report profiling data (#{config_without_api_key}): " \
               "server returned unexpected HTTP #{result} status code"
             )
+            Datadog::Core::Telemetry::Logger.error(
+              "Failed to report profiling data: unexpected HTTP #{result} status code"
+            )
             false
           end
         else
           Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
+          Datadog::Core::Telemetry::Logger.error("Failed to report profiling data")
           false
         end
       end
@@ -134,7 +139,7 @@ module Datadog
       end
 
       def config_without_api_key
-        [exporter_configuration[0..1]].to_h
+        "#{exporter_configuration[0]}: #{exporter_configuration[1]}"
       end
     end
   end

data/lib/datadog/profiling/scheduler.rb

@@ -4,6 +4,7 @@ require_relative "../core/utils/time"
 
 require_relative "../core/worker"
 require_relative "../core/workers/polling"
+require_relative "../core/telemetry/logger"
 
 module Datadog
   module Profiling
@@ -134,6 +135,7 @@ module Datadog
           Datadog.logger.error(
             "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
           )
+          Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
         end
 
         true

data/lib/datadog/profiling/stack_recorder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../core/telemetry/logger"
+
 module Datadog
   module Profiling
     # Stores stack samples in a native libdatadog data structure and expose Ruby-level serialization APIs
@@ -42,6 +44,7 @@ module Datadog
           error_message = result
 
           Datadog.logger.error("Failed to serialize profiling data: #{error_message}")
+          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data")
 
           nil
         end

data/lib/datadog/single_step_instrument.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+#
+# Entrypoint file for single step instrumentation.
+#
+# This file's path is private. Do not reference this file.
+#
+begin
+  require_relative 'auto_instrument'
+rescue StandardError, LoadError => e
+  warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
+end

data/lib/datadog/tracing/contrib/action_cable/instrumentation.rb

@@ -14,21 +14,17 @@ module Datadog
           module ActionCableConnection
             def on_open
               Tracing.trace(Ext::SPAN_ON_OPEN) do |span, trace|
-                begin
-                  span.resource = "#{self.class}#on_open"
-                  span.type = Tracing::Metadata::Ext::AppTypes::TYPE_WEB
+                span.resource = "#{self.class}#on_open"
+                span.type = Tracing::Metadata::Ext::AppTypes::TYPE_WEB
 
-                  span.set_tag(Ext::TAG_ACTION, 'on_open')
-                  span.set_tag(Ext::TAG_CONNECTION, self.class.to_s)
+                span.set_tag(Ext::TAG_ACTION, 'on_open')
+                span.set_tag(Ext::TAG_CONNECTION, self.class.to_s)
 
-                  span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
-                  span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ON_OPEN)
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ON_OPEN)
 
-                  # Set the resource name of the trace
-                  trace.resource = span.resource
-                rescue StandardError => e
-                  Datadog.logger.error("Error preparing span for ActionCable::Connection: #{e}")
-                end
+                # Set the resource name of the trace
+                trace.resource = span.resource
 
                 super
               end

data/lib/datadog/tracing/contrib/action_pack/action_controller/instrumentation.rb

@@ -7,6 +7,7 @@ require_relative '../ext'
 require_relative '../utils'
 require_relative '../../rack/middlewares'
 require_relative '../../analytics'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -43,6 +44,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CONTROLLER)
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def finish_processing(payload)
@@ -81,10 +83,13 @@ module Datadog
               end
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             # Instrumentation for ActionController::Metal
             module Metal
+              # TODO: Refactor this method to avoid using async API that splits the logic
+              # into two different methods (`start_processing` and `finish_processing`)
               def process_action(*args)
                 # mutable payload with a tracing context that is used in two different
                 # signals; it propagates the request span so that it can be finished

data/lib/datadog/tracing/contrib/action_pack/action_dispatch/instrumentation.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../../../metadata/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActionPack
+        module ActionDispatch
+          # Instrumentation for ActionDispatch components
+          module Instrumentation
+            module_function
+
+            def set_http_route_tags(route_spec, script_name)
+              return unless Tracing.enabled?
+
+              return unless route_spec
+
+              request_trace = Tracing.active_trace
+              return unless request_trace
+
+              request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, route_spec.to_s.gsub(/\(.:format\)\z/, ''))
+
+              if script_name && !script_name.empty?
+                request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, script_name)
+              end
+            end
+
+            def dispatcher_route?(route)
+              return true if route.dispatcher?
+
+              # in Rails 4 there is no #rack_app method on the app
+              return true if route.app.respond_to?(:rack_app) && !route.app.rack_app.nil?
+
+              false
+            end
+
+            # Instrumentation for ActionDispatch::Journey components
+            module Journey
+              # Instrumentation for ActionDispatch::Journey::Router for Rails versions older than 7.1
+              module Router
+                def find_routes(req)
+                  result = super
+
+                  # result is an array of [match, parameters, route] tuples
+                  routes = result.map(&:last)
+
+                  routes.each do |route|
+                    if Instrumentation.dispatcher_route?(route)
+                      Instrumentation.set_http_route_tags(route.path.spec, req.env['SCRIPT_NAME'])
+                      break
+                    end
+                  end
+
+                  result
+                end
+              end
+
+              # Since Rails 7.1 `Router#find_routes` makes the route computation lazy
+              # https://github.com/rails/rails/commit/35b280fcc2d5d474f9f2be3aca3ae7aa6bba66eb
+              module LazyRouter
+                def find_routes(req)
+                  super do |match, parameters, route|
+                    if Instrumentation.dispatcher_route?(route)
+                      Instrumentation.set_http_route_tags(route.path.spec, req.env['SCRIPT_NAME'])
+                    end
+
+                    yield [match, parameters, route]
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_pack/action_dispatch/patcher.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../patcher'
+require_relative 'instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActionPack
+        module ActionDispatch
+          # Patcher for ActionController components
+          module Patcher
+            include Contrib::Patcher
+
+            module_function
+
+            def target_version
+              Integration.version
+            end
+
+            def patch
+              if ::ActionPack.gem_version >= Gem::Version.new('7.1')
+                ::ActionDispatch::Journey::Router.prepend(ActionDispatch::Instrumentation::Journey::LazyRouter)
+              else
+                ::ActionDispatch::Journey::Router.prepend(ActionDispatch::Instrumentation::Journey::Router)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_pack/patcher.rb

@@ -2,6 +2,7 @@
 
 require_relative '../patcher'
 require_relative 'action_controller/patcher'
+require_relative 'action_dispatch/patcher'
 
 module Datadog
   module Tracing
@@ -19,6 +20,7 @@ module Datadog
 
           def patch
             ActionController::Patcher.patch
+            ActionDispatch::Patcher.patch
           end
         end
       end

data/lib/datadog/tracing/contrib/active_record/configuration/resolver.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../configuration/resolver'
 require_relative 'makara_resolver'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -72,10 +73,12 @@ module Datadog
               #
               # `db_config` input may contain sensitive information such as passwords,
               # hence provide a succinct summary for the error logging.
+              #
               Datadog.logger.error(
                 'Failed to resolve ActiveRecord database configuration. '\
                 "Cause: #{e.class.name} Source: #{Array(e.backtrace).first}"
               )
+              Core::Telemetry::Logger.report(e, description: 'Failed to resolve ActiveRecord database configuration')
 
               nil
             end
@@ -95,6 +98,7 @@ module Datadog
                 "Failed to resolve key #{matcher.inspect}. " \
                 "Cause: #{e.class.name} Source: #{Array(e.backtrace).first}"
               )
+              Core::Telemetry::Logger.report(e, description: 'Failed to resolve key')
 
               nil
             end

data/lib/datadog/tracing/contrib/active_record/events/instantiation.rb

@@ -4,6 +4,7 @@ require_relative '../../../metadata/ext'
 require_relative '../../analytics'
 require_relative '../ext'
 require_relative '../event'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -48,7 +49,8 @@ module Datadog
               span.set_tag(Ext::TAG_INSTANTIATION_CLASS_NAME, payload.fetch(:class_name))
               span.set_tag(Ext::TAG_INSTANTIATION_RECORD_COUNT, payload.fetch(:record_count))
             rescue StandardError => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
           end
         end

data/lib/datadog/tracing/contrib/active_record/events/sql.rb

@@ -6,6 +6,7 @@ require_relative '../event'
 require_relative '../ext'
 require_relative '../../analytics'
 require_relative '../../utils/database'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -68,7 +69,8 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, config[:host]) if config[:host]
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, config[:port]) if config[:port]
             rescue StandardError => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
           end
         end

data/lib/datadog/tracing/contrib/active_support/cache/events/cache.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../ext'
 require_relative '../event'
+require_relative '../../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -64,7 +65,7 @@ module Datadog
                 key = payload[:key]
                 store = payload[:store]
 
-                mapping = MAPPING[event]
+                mapping = MAPPING.fetch(event)
 
                 span.service = configuration[:cache_service]
                 span.resource = mapping[:resource]
@@ -81,6 +82,9 @@ module Datadog
                 span.set_tag('EVENT', event)
 
                 set_cache_key(span, key, mapping[:multi_key])
+              rescue StandardError => e
+                Datadog.logger.error(e.message)
+                Datadog::Core::Telemetry::Logger.report(e)
               end
 
               def set_cache_key(span, key, multi_key)

data/lib/datadog/tracing/contrib/aws/instrumentation.rb

@@ -29,6 +29,7 @@ module Datadog
           private
 
           # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
           def annotate!(span, context)
             span.service = configuration[:service_name]
             span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -76,7 +77,11 @@ module Datadog
             span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, context.safely(:status_code))
 
             Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+          rescue StandardError => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
           end
+          # rubocop:enable Metrics/MethodLength
           # rubocop:enable Metrics/AbcSize
 
           def configuration

data/lib/datadog/tracing/contrib/elasticsearch/patcher.rb

@@ -93,11 +93,16 @@ module Datadog
                   span.resource = "#{method} #{quantized_url}"
                   Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
                 rescue StandardError => e
+                  # TODO: Refactor the code to streamline the execution without ensure
                   Datadog.logger.error(e.message)
+                  Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   # the call is still executed
                   response = super
-                  span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
+
+                  if response && response.respond_to?(:status)
+                    span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
+                  end
                 end
               end
               response

data/lib/datadog/tracing/contrib/faraday/middleware.rb

@@ -7,6 +7,7 @@ require_relative '../http'
 require_relative '../analytics'
 require_relative 'ext'
 require_relative '../http_annotation_helper'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -37,6 +38,7 @@ module Datadog
 
           attr_reader :app
 
+          # rubocop:disable Metrics/AbcSize
           def annotate!(span, env, options)
             span.resource = resource_name(env)
             span.service = service_name(env[:url].host, options)
@@ -75,7 +77,11 @@ module Datadog
             )
 
             Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+          rescue StandardError => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
           end
+          # rubocop:enable Metrics/AbcSize
 
           def handle_response(span, env, options)
             span.set_error(["Error #{env[:status]}", env[:body]]) if options[:error_status_codes].include? env[:status]
@@ -85,6 +91,9 @@ module Datadog
             span.set_tags(
               Datadog.configuration.tracing.header_tags.response_tags(env[:response_headers])
             )
+          rescue StandardError => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
           end
 
           def propagate!(trace, span, env)

data/lib/datadog/tracing/contrib/grape/endpoint.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../../core'
+require_relative '../../../core/telemetry/logger'
 require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative '../rack/ext'
@@ -41,6 +42,7 @@ module Datadog
 
               # collect endpoint details
               endpoint = payload.fetch(:endpoint)
+              env = payload.fetch(:env)
               api_view = api_view(endpoint.options[:for])
               request_method = endpoint.options.fetch(:method).first
               path = endpoint_expand_path(endpoint)
@@ -61,9 +63,22 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ENDPOINT_RUN)
 
+              if (grape_route = env['grape.routing_args']) && grape_route[:route_info]
+                trace.set_tag(
+                  Tracing::Metadata::Ext::HTTP::TAG_ROUTE,
+                  # here we are removing the format from the path:
+                  # e.g. /path/to/resource(.json) => /path/to/resource
+                  # e.g. /path/to/resource(.:format) => /path/to/resource
+                  grape_route[:route_info].path&.gsub(/\(\.:?\w+\)\z/, '')
+                )
+
+                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, env['SCRIPT_NAME'])
+              end
+
               Thread.current[KEY_RUN] = true
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def endpoint_run(name, start, finish, id, payload)
@@ -107,6 +122,7 @@ module Datadog
               end
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             # Status code resolution is tied to the exception handling
@@ -150,6 +166,7 @@ module Datadog
               Thread.current[KEY_RENDER] = true
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def endpoint_render(name, start, finish, id, payload)
@@ -174,6 +191,7 @@ module Datadog
               end
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def endpoint_run_filters(name, start, finish, id, payload)
@@ -212,6 +230,7 @@ module Datadog
               end
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             private

data/lib/datadog/tracing/contrib/graphql/patcher.rb

@@ -21,13 +21,18 @@ module Datadog
           end
 
           def patch
+            # DEV-3.0: We should remove as many patching options as possible, given the alternatives do not
+            # DEV-3.0: provide any benefit to the recommended `with_unified_tracer` patching method.
+            # DEV-3.0: `with_deprecated_tracer` is likely safe to remove.
+            # DEV-3.0: `with_unified_tracer: false` should be removed if possible.
+            # DEV-3.0: `with_unified_tracer: true` should be the default and hopefully not even necessary as an option.
             if configuration[:with_deprecated_tracer]
-              TracingPatcher.patch!(schemas, trace_options)
+              TracingPatcher.patch!(schemas)
             elsif Integration.trace_supported?
               if configuration[:with_unified_tracer]
-                UnifiedTracePatcher.patch!(schemas, trace_options)
+                UnifiedTracePatcher.patch!(schemas)
               else
-                TracePatcher.patch!(schemas, trace_options)
+                TracePatcher.patch!(schemas)
               end
             else
               Datadog.logger.warn(
@@ -35,18 +40,10 @@ module Datadog
                 'or Datadog::Tracing::Contrib::GraphQL::UnifiedTrace.'\
                 'Falling back to GraphQL::Tracing::DataDogTracing.'
               )
-              TracingPatcher.patch!(schemas, trace_options)
+              TracingPatcher.patch!(schemas)
             end
           end
 
-          def trace_options
-            {
-              service: configuration[:service_name],
-              analytics_enabled: Contrib::Analytics.enabled?(configuration[:analytics_enabled]),
-              analytics_sample_rate: configuration[:analytics_sample_rate]
-            }
-          end
-
           def configuration
             Datadog.configuration.tracing[:graphql]
           end

data/lib/datadog/tracing/contrib/graphql/trace_patcher.rb

@@ -8,12 +8,12 @@ module Datadog
         module TracePatcher
           module_function
 
-          def patch!(schemas, options)
+          def patch!(schemas)
             if schemas.empty?
-              ::GraphQL::Schema.trace_with(::GraphQL::Tracing::DataDogTrace, **options)
+              ::GraphQL::Schema.trace_with(::GraphQL::Tracing::DataDogTrace)
             else
               schemas.each do |schema|
-                schema.trace_with(::GraphQL::Tracing::DataDogTrace, **options)
+                schema.trace_with(::GraphQL::Tracing::DataDogTrace)
               end
             end
           end