datadog 2.12.0 → 2.22.0

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

@@ -11,11 +11,45 @@ module Datadog
         # which is required to use features such as API Catalog.
         # DEV-3.0: This tracer should be the default one in the next major version.
         module UnifiedTrace
+          include ::GraphQL::Tracing::PlatformTrace
+
           def initialize(*args, **kwargs)
             @has_prepare_span = respond_to?(:prepare_span)
+
+            # Cache configuration values to avoid repeated lookups
+            config = Datadog.configuration.tracing[:graphql]
+            @service_name = config[:service_name]
+            @analytics_enabled = config[:analytics_enabled]
+            @analytics_sample_rate = config[:analytics_sample_rate]
+            @error_extensions_config = config[:error_extensions]
+
+            load_error_event_attributes(config[:error_tracking])
+
             super
           end
 
+          def load_error_event_attributes(error_tracking)
+            if error_tracking
+              @event_name = Tracing::Metadata::Ext::Errors::EVENT_NAME
+              @message_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_MESSAGE
+              @type_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_TYPE
+              @stacktrace_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_STACKTRACE
+              @locations_key = 'graphql.error.locations'
+              @path_key = 'graphql.error.path'
+              @extensions_key = 'graphql.error.extensions.'
+            else
+              @event_name = Ext::EVENT_QUERY_ERROR
+              @message_key = 'message'
+              @type_key = 'type'
+              @stacktrace_key = 'stacktrace'
+              @locations_key = 'locations'
+              @path_key = 'path'
+              @extensions_key = 'extensions.'
+            end
+          end
+
+          private :load_error_event_attributes
+
           def lex(*args, query_string:, **kwargs)
             trace(proc { super }, 'lex', query_string, query_string: query_string)
           end
@@ -42,7 +76,7 @@ module Datadog
 
           def execute_multiplex(*args, multiplex:, **kwargs)
             trace(proc { super }, 'execute_multiplex', multiplex_resource(multiplex), multiplex: multiplex) do |span|
-              span.set_tag('graphql.source', "Multiplex[#{multiplex.queries.map(&:query_string).join(', ')}]")
+              span.set_tag('graphql.source', "Multiplex[#{multiplex.queries.map(&:query_string).join(", ")}]")
             end
           end
 
@@ -50,10 +84,13 @@ module Datadog
             trace(
               proc { super },
               'execute',
-              query.selected_operation_name,
+              operation_resource(query.selected_operation),
               lambda { |span|
+                # Ensure this span can be aggregated by in the Datadog App, and generates RED metrics.
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
+
                 span.set_tag('graphql.source', query.query_string)
-                span.set_tag('graphql.operation.type', query.selected_operation.operation_type)
+                span.set_tag('graphql.operation.type', query.selected_operation&.operation_type)
                 if query.selected_operation_name
                   span.set_tag(
                     'graphql.operation.name',
@@ -71,10 +108,10 @@ module Datadog
 
           def execute_query_lazy(*args, query:, multiplex:, **kwargs)
             resource = if query
-                         query.selected_operation_name || fallback_transaction_name(query.context)
-                       else
-                         multiplex_resource(multiplex)
-                       end
+              query.selected_operation_name || fallback_transaction_name(query.context)
+            else
+              multiplex_resource(multiplex)
+            end
             trace(proc { super }, 'execute_lazy', resource, query: query, multiplex: multiplex)
           end
 
@@ -127,8 +164,6 @@ module Datadog
             resolve_type_span(proc { super }, 'resolve_type_lazy', **kwargs)
           end
 
-          include ::GraphQL::Tracing::PlatformTrace
-
           def platform_field_key(field, *args, **kwargs)
             field.path
           end
@@ -153,16 +188,14 @@ module Datadog
           # @param kwargs [Hash] the arguments to pass to `prepare_span`
           # @yield [Span] the block to run before the trace, same as the `before` parameter
           def trace(callable, trace_key, resource, before = nil, after = nil, **kwargs, &before_block)
-            config = Datadog.configuration.tracing[:graphql]
-
             Tracing.trace(
               "graphql.#{trace_key}",
               type: 'graphql',
               resource: resource,
-              service: config[:service_name]
+              service: @service_name
             ) do |span|
-              if Contrib::Analytics.enabled?(config[:analytics_enabled])
-                Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
+              if Contrib::Analytics.enabled?(@analytics_enabled)
+                Contrib::Analytics.set_sample_rate(span, @analytics_sample_rate)
               end
 
               # A sanity check for us.
@@ -176,7 +209,7 @@ module Datadog
 
               ret = callable.call
 
-              after.call(span) if after
+              after&.call(span)
 
               ret
             end
@@ -194,46 +227,49 @@ module Datadog
             end
           end
 
+          def operation_resource(operation)
+            if operation&.name
+              "#{operation.operation_type} #{operation.name}"
+            else
+              'anonymous'
+            end
+          end
+
           # Create a Span Event for each error that occurs at query level.
-          #
-          # These are represented in the Datadog App as special GraphQL errors,
-          # given their event name `dd.graphql.query.error`.
           def add_query_error_events(span, errors)
-            capture_extensions = Datadog.configuration.tracing[:graphql][:error_extensions]
             errors.each do |error|
-              extensions = if !capture_extensions.empty? && (extensions = error.extensions)
-                             # Capture extensions, ensuring all values are primitives
-                             extensions.each_with_object({}) do |(key, value), hash|
-                               next unless capture_extensions.include?(key.to_s)
-
-                               value = case value
-                                       when TrueClass, FalseClass, Integer, Float
-                                         value
-                                       else
-                                         # Stringify anything that is not a boolean or a number
-                                         value.to_s
-                                       end
-
-                               hash["extensions.#{key}"] = value
-                             end
-                           else
-                             {}
-                           end
+              attributes = if !@error_extensions_config.empty? && (extensions = error.extensions)
+                # Capture extensions, ensuring all values are primitives
+                extensions.each_with_object({}) do |(key, value), hash|
+                  next unless @error_extensions_config.include?(key.to_s)
+
+                  value = case value
+                  when TrueClass, FalseClass, Integer, Float
+                    value
+                  else
+                    value.to_s
+                  end
+
+                  hash[@extensions_key + key.to_s] = value
+                end
+              else
+                {}
+              end
 
               # {::GraphQL::Error#to_h} returns the error formatted in compliance with the GraphQL spec.
               # This is an unwritten contract in the `graphql` library.
               # See for an example: https://github.com/rmosolgo/graphql-ruby/blob/0afa241775e5a113863766cce126214dee093464/lib/graphql/execution_error.rb#L32
               graphql_error = error.to_h
-              error = Core::Error.build_from(error)
-
-              span.span_events << Datadog::Tracing::SpanEvent.new(
-                Ext::EVENT_QUERY_ERROR,
-                attributes: extensions.merge!(
-                  message: graphql_error['message'],
-                  type: error.type,
-                  stacktrace: error.backtrace,
-                  locations: serialize_error_locations(graphql_error['locations']),
-                  path: graphql_error['path'],
+              parsed_error = Core::Error.build_from(error)
+
+              span.span_events << SpanEvent.new(
+                @event_name,
+                attributes: attributes.merge!(
+                  @type_key => parsed_error.type,
+                  @stacktrace_key => parsed_error.backtrace,
+                  @message_key => graphql_error['message'],
+                  @locations_key => serialize_error_locations(graphql_error['locations']),
+                  @path_key => graphql_error['path'],
                 )
               )
             end
@@ -251,7 +287,7 @@ module Datadog
           #   ["3:10", "7:8"]
           def serialize_error_locations(locations)
             locations.map do |location|
-              "#{location['line']}:#{location['column']}"
+              "#{location["line"]}:#{location["column"]}"
             end
           end
         end

data/lib/datadog/tracing/contrib/grpc/datadog_interceptor/client.rb

@@ -33,7 +33,7 @@ module Datadog
 
                 begin
                   result = yield
-                rescue StandardError => e
+                rescue => e
                   code = e.is_a?(::GRPC::BadStatus) ? e.code : ::GRPC::Core::StatusCodes::UNKNOWN
                   span.set_tag(Contrib::Ext::RPC::GRPC::TAG_STATUS_CODE, code)
 
@@ -81,9 +81,15 @@ module Datadog
               # Set analytics sample rate
               Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
-              GRPC.inject(trace, metadata) if distributed_tracing?
+              if Tracing::Distributed::PropagationPolicy.enabled?(
+                pin_config: Datadog.configuration_for(self),
+                global_config: datadog_configuration,
+                trace: trace
+              )
+                GRPC.inject(trace, metadata)
+              end
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
-            rescue StandardError => e
+            rescue => e
               Datadog.logger.debug("GRPC client trace failed: #{e}")
             end
 
@@ -97,12 +103,12 @@ module Datadog
               return unless call
 
               peer_address = if call.respond_to?(:peer)
-                               call.peer
-                             else
-                               # call is a "view" class with restricted method visibility.
-                               # We reach into it to find our data source anyway.
-                               call.instance_variable_get(:@wrapped).peer
-                             end
+                call.peer
+              else
+                # call is a "view" class with restricted method visibility.
+                # We reach into it to find our data source anyway.
+                call.instance_variable_get(:@wrapped).peer
+              end
 
               Core::Utils.extract_host_port(peer_address)
             rescue => e

data/lib/datadog/tracing/contrib/grpc/datadog_interceptor/server.rb

@@ -37,7 +37,7 @@ module Datadog
 
                 begin
                   yield
-                rescue StandardError => e
+                rescue => e
                   code = e.is_a?(::GRPC::BadStatus) ? e.code : ::GRPC::Core::StatusCodes::UNKNOWN
                   span.set_tag(Contrib::Ext::RPC::GRPC::TAG_STATUS_CODE, code)
 
@@ -52,7 +52,7 @@ module Datadog
 
             def set_distributed_context!(metadata)
               Tracing.continue_trace!(GRPC.extract(metadata))
-            rescue StandardError => e
+            rescue => e
               Datadog.logger.debug(
                 "unable to propagate GRPC metadata to context: #{e}"
               )
@@ -85,7 +85,7 @@ module Datadog
 
               # Measure service stats
               Contrib::Analytics.set_measured(span)
-            rescue StandardError => e
+            rescue => e
               Datadog.logger.debug("GRPC server trace failed: #{e}")
             end
           end

data/lib/datadog/tracing/contrib/grpc/distributed/fetcher.rb

@@ -15,7 +15,7 @@ module Datadog
             def [](key)
               # Metadata values are normally integrals but can also be
               # arrays when multiple values are associated with the same key.
-              value = super(key)
+              value = super
               value.is_a?(::Array) ? value[0] : value
             end
           end

data/lib/datadog/tracing/contrib/grpc/distributed/propagation.rb

@@ -3,6 +3,7 @@
 require_relative 'fetcher'
 require_relative '../../../distributed/b3_multi'
 require_relative '../../../distributed/b3_single'
+require_relative '../../../distributed/propagation_policy'
 require_relative '../../../distributed/datadog'
 require_relative '../../../distributed/none'
 require_relative '../../../distributed/propagation'
@@ -31,6 +32,8 @@ module Datadog
                     Tracing::Distributed::Datadog.new(fetcher: Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
                     Tracing::Distributed::TraceContext.new(fetcher: Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE =>
+                    Tracing::Distributed::Baggage.new(fetcher: Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
                 },
                 propagation_style_inject: propagation_style_inject,

data/lib/datadog/tracing/contrib/grpc/integration.rb

@@ -18,7 +18,7 @@ module Datadog
           register_as :grpc, auto_patch: true
 
           def self.version
-            Gem.loaded_specs['grpc'] && Gem.loaded_specs['grpc'].version
+            Gem.loaded_specs['grpc']&.version
           end
 
           def self.loaded?

data/lib/datadog/tracing/contrib/hanami/ext.rb

@@ -9,9 +9,9 @@ module Datadog
         module Ext
           ENV_ENABLED = 'DD_TRACE_HANAMI_ENABLED'
 
-          SPAN_ACTION =  'hanami.action'
+          SPAN_ACTION = 'hanami.action'
           SPAN_ROUTING = 'hanami.routing'
-          SPAN_RENDER =  'hanami.render'
+          SPAN_RENDER = 'hanami.render'
 
           TAG_COMPONENT = 'hanami'
           TAG_OPERATION_ACTION = 'action'

data/lib/datadog/tracing/contrib/hanami/integration.rb

@@ -18,7 +18,7 @@ module Datadog
           register_as :hanami
 
           def self.version
-            Gem.loaded_specs['hanami'] && Gem.loaded_specs['hanami'].version
+            Gem.loaded_specs['hanami']&.version
           end
 
           def self.loaded?

data/lib/datadog/tracing/contrib/hanami/renderer_policy_tracing.rb

@@ -15,7 +15,7 @@ module Datadog
             #
             # For example in config/routes.rb:
             # get '/hello', to: ->(env) { [200, {}, ['Hello from Hanami!']] }
-            action_klass = (action && action.class) ||
+            action_klass = action&.class ||
               ::Hanami::Routing::Default::NullAction
 
             Tracing.trace(

data/lib/datadog/tracing/contrib/hanami/router_tracing.rb

@@ -17,19 +17,17 @@ module Datadog
               service: configuration[:service_name],
               type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND
             ) do |span_op, trace_op|
-              begin
-                span_op.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
-                span_op.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ROUTING)
+              span_op.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span_op.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ROUTING)
 
-                span_op.resource = nil
+              span_op.resource = nil
 
-                super
-              ensure
-                span_op.resource ||= if trace_op.resource_override?
-                                       trace_op.resource
-                                     else
-                                       env['REQUEST_METHOD']
-                                     end
+              super
+            ensure
+              span_op.resource ||= if trace_op.resource_override?
+                trace_op.resource
+              else
+                env['REQUEST_METHOD']
               end
             end
           end

data/lib/datadog/tracing/contrib/http/circuit_breaker.rb

@@ -27,21 +27,6 @@ module Datadog
             !!(request[Datadog::Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION] ||
               request[Datadog::Core::Transport::Ext::HTTP::HEADER_DD_INTERNAL_UNTRACED_REQUEST])
           end
-
-          def should_skip_distributed_tracing?(client_config)
-            if Datadog.configuration.appsec.standalone.enabled
-              # Skip distributed tracing so that we don't bill distributed traces in case of absence of
-              # upstream ASM event (_dd.p.appsec:1) and no local security event (which sets _dd.p.appsec:1 locally).
-              # If there is an ASM event, we still have to check if distributed tracing is enabled or not
-              return true unless Tracing.active_trace
-
-              return true if Tracing.active_trace.get_tag(Datadog::AppSec::Ext::TAG_DISTRIBUTED_APPSEC_EVENT) != '1'
-            end
-
-            return !client_config[:distributed_tracing] if client_config && client_config.key?(:distributed_tracing)
-
-            !Datadog.configuration.tracing[:http][:distributed_tracing]
-          end
         end
       end
     end

data/lib/datadog/tracing/contrib/http/distributed/fetcher.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 
 require_relative '../../../distributed/fetcher'
 
@@ -17,13 +17,13 @@ module Datadog
             # @return [String, nil] the header value or nil if not found
             def [](name)
               # Try to fetch with the plain key
-              value = super(name)
+              value = super
               return value if value && !value.empty?
 
               # If not found, try the Rack-formatted key
-              rack_header = "HTTP-#{name}"
+              rack_header = +"HTTP-#{name}"
               rack_header.upcase!
-              rack_header.tr!('-'.freeze, '_'.freeze)
+              rack_header.tr!('-', '_')
 
               hdr = super(rack_header)
 

data/lib/datadog/tracing/contrib/http/distributed/propagation.rb

@@ -2,6 +2,7 @@
 
 require_relative 'fetcher'
 require_relative '../../../distributed/propagation'
+require_relative '../../../distributed/propagation_policy'
 require_relative '../../../distributed/b3_multi'
 require_relative '../../../distributed/b3_single'
 require_relative '../../../distributed/datadog'
@@ -30,7 +31,9 @@ module Datadog
                     Tracing::Distributed::Datadog.new(fetcher: Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
                     Tracing::Distributed::TraceContext.new(fetcher: Fetcher),
-                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE =>
+                  Tracing::Distributed::Baggage.new(fetcher: Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new,
                 },
                 propagation_style_inject: propagation_style_inject,
                 propagation_style_extract: propagation_style_extract,

data/lib/datadog/tracing/contrib/http/ext.rb

@@ -18,10 +18,11 @@ module Datadog
           SPAN_REQUEST = 'http.request'
           TAG_COMPONENT = 'net/http'
           TAG_OPERATION_REQUEST = 'request'
-          PEER_SERVICE_SOURCES = Array[
+          PEER_SERVICE_SOURCES = [
             Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
             Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
-            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,
+          ].freeze
         end
       end
     end

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

@@ -28,18 +28,18 @@ module Datadog
               request_options = datadog_configuration(host)
               client_config = Datadog.configuration_for(self)
 
-              return super(req, body, &block) if Contrib::HTTP.should_skip_tracing?(req)
+              return super if Contrib::HTTP.should_skip_tracing?(req)
 
-              Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
+              Tracing.trace(Ext::SPAN_REQUEST) do |span, trace|
                 span.service = service_name(host, request_options, client_config)
                 span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
                 span.resource = req.method
 
-                if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
-                  trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
-                end
-
-                if Tracing.enabled? && !Contrib::HTTP.should_skip_distributed_tracing?(client_config)
+                if Tracing::Distributed::PropagationPolicy.enabled?(
+                  pin_config: client_config,
+                  global_config: Datadog.configuration.tracing[:http],
+                  trace: trace
+                )
                   Contrib::HTTP.inject(trace, req)
                 end
 
@@ -74,7 +74,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
               span.set_tag(
                 Tracing::Metadata::Ext::HTTP::TAG_URL,
-                Contrib::Utils::Quantization::HTTP.url(request.path, { query: { exclude: :all } })
+                Contrib::Utils::Quantization::HTTP.url(request.path, {query: {exclude: :all}})
               )
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, request.method)
 
@@ -92,13 +92,13 @@ module Datadog
               )
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
-            rescue StandardError => e
+            rescue => e
               Datadog.logger.error("error preparing span from http request: #{e}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def annotate_span_with_response!(span, response, request_options)
-              return unless response && response.code
+              return unless response&.code
 
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.code)
 
@@ -107,15 +107,11 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response)
               )
-            rescue StandardError => e
+            rescue => e
               Datadog.logger.error("error preparing span from http response: #{e}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
-            def annotate_span_with_error!(span, error)
-              span.set_error(error)
-            end
-
             def set_analytics_sample_rate(span, request_options)
               return unless analytics_enabled?(request_options)
 

data/lib/datadog/tracing/contrib/httpclient/ext.rb

@@ -19,10 +19,11 @@ module Datadog
           SPAN_REQUEST = 'httpclient.request'
           TAG_COMPONENT = 'httpclient'
           TAG_OPERATION_REQUEST = 'request'
-          PEER_SERVICE_SOURCES = Array[
+          PEER_SERVICE_SOURCES = [
             Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
             Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
-            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,
+          ].freeze
         end
       end
     end

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

@@ -25,22 +25,22 @@ module Datadog
               request_options = datadog_configuration(host)
               client_config = Datadog.configuration_for(self)
 
-              Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
+              Tracing.trace(Ext::SPAN_REQUEST) do |span, trace|
                 begin
                   span.service = service_name(host, request_options, client_config)
                   span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
 
-                  if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
-                    trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
-                  end
-
-                  if Tracing.enabled? && !should_skip_distributed_tracing?(client_config)
+                  if Tracing::Distributed::PropagationPolicy.enabled?(
+                    pin_config: client_config,
+                    global_config: Datadog.configuration.tracing[:httpclient],
+                    trace: trace
+                  )
                     Contrib::HTTP.inject(trace, req.header)
                   end
 
                   # Add additional request specific tags to the span.
                   annotate_span_with_request!(span, req, request_options)
-                rescue StandardError => e
+                rescue => e
                   Datadog.logger.error("error preparing span for httpclient request: #{e}, Source: #{e.backtrace}")
                   Datadog::Core::Telemetry::Logger.report(e)
                 ensure
@@ -95,7 +95,7 @@ module Datadog
             end
 
             def annotate_span_with_response!(span, response, request_options)
-              return unless response && response.status
+              return unless response&.status
 
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
 
@@ -106,15 +106,11 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response.header)
               )
-            rescue StandardError => e
+            rescue => e
               Datadog.logger.error("error preparing span from httpclient response: #{e}, Source: #{e.backtrace}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
-            def annotate_span_with_error!(span, error)
-              span.set_error(error)
-            end
-
             def datadog_configuration(host = :default)
               Datadog.configuration.tracing[:httpclient, host]
             end
@@ -123,12 +119,6 @@ module Datadog
               Contrib::Analytics.enabled?(request_options[:analytics_enabled])
             end
 
-            def should_skip_distributed_tracing?(client_config)
-              return !client_config[:distributed_tracing] if client_config && client_config.key?(:distributed_tracing)
-
-              !Datadog.configuration.tracing[:httpclient][:distributed_tracing]
-            end
-
             def set_analytics_sample_rate(span, request_options)
               return unless analytics_enabled?(request_options)
 

data/lib/datadog/tracing/contrib/httpclient/integration.rb

@@ -19,7 +19,7 @@ module Datadog
           register_as :httpclient
 
           def self.version
-            Gem.loaded_specs['httpclient'] && Gem.loaded_specs['httpclient'].version
+            Gem.loaded_specs['httpclient']&.version
           end
 
           def self.loaded?

data/lib/datadog/tracing/contrib/httprb/ext.rb

@@ -18,10 +18,11 @@ module Datadog
           SPAN_REQUEST = 'httprb.request'
           TAG_COMPONENT = 'httprb'
           TAG_OPERATION_REQUEST = 'request'
-          PEER_SERVICE_SOURCES = Array[
+          PEER_SERVICE_SOURCES = [
             Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
             Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
-            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,
+          ].freeze
         end
       end
     end