datadog 2.3.0 → 2.5.0

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
@@ -248,8 +267,11 @@ module Datadog
               route_path = endpoint.options[:path]
               namespace = endpoint.routes.first && endpoint.routes.first.namespace || ''
 
-              parts = (namespace.split('/') + route_path).reject { |p| p.blank? || p.eql?('/') }
-              parts.join('/').prepend('/')
+              path = (namespace.split('/') + route_path)
+                .reject { |p| p.blank? || p.eql?('/') }
+                .join('/')
+              path.prepend('/') if path[0] != '/'
+              path
             end
 
             def service_name

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

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

@@ -8,13 +8,13 @@ module Datadog
         module TracingPatcher
           module_function
 
-          def patch!(schemas, options)
+          def patch!(schemas)
             if schemas.empty?
-              ::GraphQL::Schema.tracer(::GraphQL::Tracing::DataDogTracing.new(**options))
+              ::GraphQL::Schema.tracer(::GraphQL::Tracing::DataDogTracing.new)
             else
               schemas.each do |schema|
                 if schema.respond_to? :use
-                  schema.use(::GraphQL::Tracing::DataDogTracing, **options)
+                  schema.use(::GraphQL::Tracing::DataDogTracing)
                 else
                   Datadog.logger.warn("Unable to patch #{schema}: Please migrate to class-based schema.")
                 end

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

@@ -11,14 +11,7 @@ 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
-          # @param analytics_enabled [Boolean] Deprecated
-          # @param analytics_sample_rate [Float] Deprecated
-          # @param service [String|nil] The service name to be set on the spans
-          def initialize(*args, analytics_enabled: false, analytics_sample_rate: 1.0, service: nil, **kwargs)
-            @analytics_enabled = analytics_enabled
-            @analytics_sample_rate = analytics_sample_rate
-
-            @service_name = service
+          def initialize(*args, **kwargs)
             @has_prepare_span = respond_to?(:prepare_span)
             super
           end
@@ -139,7 +132,18 @@ module Datadog
           private
 
           def trace(callable, trace_key, resource, **kwargs)
-            Tracing.trace("graphql.#{trace_key}", resource: resource, service: @service_name, type: 'graphql') do |span|
+            config = Datadog.configuration.tracing[:graphql]
+
+            Tracing.trace(
+              "graphql.#{trace_key}",
+              type: 'graphql',
+              resource: resource,
+              service: config[:service_name]
+            ) do |span|
+              if Contrib::Analytics.enabled?(config[:analytics_enabled])
+                Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
+              end
+
               yield(span) if block_given?
 
               prepare_span(trace_key, kwargs, span) if @has_prepare_span

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

@@ -12,12 +12,15 @@ module Datadog
         module UnifiedTracePatcher
           module_function
 
-          def patch!(schemas, options)
+          # TODO: `GraphQL::Schema.trace_with` and `YOUR_SCHEMA.trace_with` don't mix.
+          # TODO: They create duplicate spans when combined.
+          # TODO: We should measure how frequently users use `YOUR_SCHEMA.trace_with`, and hopefully we can remove it.
+          def patch!(schemas)
             if schemas.empty?
-              ::GraphQL::Schema.trace_with(UnifiedTrace, **options)
+              ::GraphQL::Schema.trace_with(UnifiedTrace)
             else
               schemas.each do |schema|
-                schema.trace_with(UnifiedTrace, **options)
+                schema.trace_with(UnifiedTrace)
               end
             end
           end

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

@@ -29,6 +29,15 @@ module Datadog
           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]

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

@@ -6,6 +6,7 @@ require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative '../http_annotation_helper'
 require_relative '../utils/quantization/http'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -30,23 +31,23 @@ module Datadog
               return super(req, body, &block) if Contrib::HTTP.should_skip_tracing?(req)
 
               Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
-                begin
-                  span.service = service_name(host, request_options, client_config)
-                  span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
-                  span.resource = req.method
-
-                  if Tracing.enabled? && !Contrib::HTTP.should_skip_distributed_tracing?(client_config)
-                    Contrib::HTTP.inject(trace, req)
-                  end
-
-                  # Add additional request specific tags to the span.
-                  annotate_span_with_request!(span, req, request_options)
-                rescue StandardError => e
-                  Datadog.logger.error("error preparing span for http request: #{e}")
-                ensure
-                  response = super(req, body, &block)
+                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)
+                  Contrib::HTTP.inject(trace, req)
                 end
 
+                # Add additional request specific tags to the span.
+                annotate_span_with_request!(span, req, request_options)
+
+                response = super(req, body, &block)
+
                 # Add additional response specific tags to the span.
                 annotate_span_with_response!(span, response, request_options)
 
@@ -91,6 +92,9 @@ module Datadog
               )
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+            rescue StandardError => 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)
@@ -103,6 +107,9 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response)
               )
+            rescue StandardError => 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)

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

@@ -4,6 +4,7 @@ require_relative '../../metadata/ext'
 require_relative '../http'
 require_relative '../analytics'
 require_relative '../http_annotation_helper'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -29,6 +30,10 @@ module Datadog
                   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)
                     Contrib::HTTP.inject(trace, req.header)
                   end
@@ -36,7 +41,8 @@ module Datadog
                   # Add additional request specific tags to the span.
                   annotate_span_with_request!(span, req, request_options)
                 rescue StandardError => e
-                  logger.error("error preparing span for httpclient request: #{e}, Source: #{e.backtrace}")
+                  Datadog.logger.error("error preparing span for httpclient request: #{e}, Source: #{e.backtrace}")
+                  Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   res = super
                 end
@@ -100,6 +106,9 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response.header)
               )
+            rescue StandardError => 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)
@@ -114,10 +123,6 @@ module Datadog
               Contrib::Analytics.enabled?(request_options[:analytics_enabled])
             end
 
-            def logger
-              Datadog.logger
-            end
-
             def should_skip_distributed_tracing?(client_config)
               return !client_config[:distributed_tracing] if client_config && client_config.key?(:distributed_tracing)
 

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

@@ -13,27 +13,14 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
-          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
-
           module_function
 
-          def patched?
-            PATCH_ONLY_ONCE.ran?
-          end
-
           def target_version
             Integration.version
           end
 
-          # patch applies our patch
           def patch
-            PATCH_ONLY_ONCE.run do
-              begin
-                ::HTTPClient.include(Instrumentation)
-              rescue StandardError => e
-                Datadog.logger.error("Unable to apply httpclient integration: #{e}")
-              end
-            end
+            ::HTTPClient.include(Instrumentation)
           end
         end
       end

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

@@ -4,6 +4,7 @@ require_relative '../../metadata/ext'
 require_relative '../http'
 require_relative '../analytics'
 require_relative '../http_annotation_helper'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -29,12 +30,17 @@ module Datadog
                   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
+
                   Contrib::HTTP.inject(trace, req) if Tracing.enabled? && !should_skip_distributed_tracing?(client_config)
 
                   # Add additional request specific tags to the span.
                   annotate_span_with_request!(span, req, request_options)
                 rescue StandardError => e
                   logger.error("error preparing span for http.rb request: #{e}, Source: #{e.backtrace}")
+                  Datadog::Core::Telemetry::Logger.report(e)
                 ensure
                   res = super(req, options)
                 end
@@ -108,6 +114,9 @@ module Datadog
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response.headers)
               )
+            rescue StandardError => e
+              logger.error("error preparing span from http.rb response: #{e}, Source: #{e.backtrace}")
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def annotate_span_with_error!(span, error)

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

@@ -13,27 +13,14 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
-          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
-
           module_function
 
-          def patched?
-            PATCH_ONLY_ONCE.ran?
-          end
-
           def target_version
             Integration.version
           end
 
-          # patch applies our patch
           def patch
-            PATCH_ONLY_ONCE.run do
-              begin
-                ::HTTP::Client.include(Instrumentation)
-              rescue StandardError => e
-                Datadog.logger.error("Unable to apply httprb integration: #{e}")
-              end
-            end
+            ::HTTP::Client.include(Instrumentation)
           end
         end
       end

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

@@ -24,8 +24,7 @@ module Datadog
             if defined?(::ActiveSupport::TaggedLogging::Formatter) &&
                 ::Lograge::LogSubscribers::ActionController
                     .logger&.formatter.is_a?(::ActiveSupport::TaggedLogging::Formatter)
-
-              Datadog.logger.error(
+              Datadog.logger.warn(
                 'Lograge and ActiveSupport::TaggedLogging (the default Rails log formatter) are not compatible: ' \
                   'Lograge does not account for Rails log tags, creating polluted logs and breaking log formatting. ' \
                   'Traces and Logs correlation may not work. ' \

data/lib/datadog/tracing/contrib/mongodb/subscribers.rb

@@ -70,6 +70,8 @@ module Datadog
 
             # set the resource with the quantized query
             span.resource = serialized_query
+          rescue StandardError => e
+            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e}")
           end
           # rubocop:enable Metrics/AbcSize
 

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

@@ -6,6 +6,7 @@ require_relative 'ext'
 require_relative '../ext'
 require_relative '../integration'
 require_relative '../patcher'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -81,6 +82,8 @@ 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)
+                  # TODO: Refactor the code to streamline the execution without ensure
                 ensure
                   begin
                     response = super
@@ -90,12 +93,16 @@ module Datadog
                     raise
                   end
                   # Set post-response tags
-                  span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
-                  if response.headers['content-length']
-                    span.set_tag(
-                      OpenSearch::Ext::TAG_RESPONSE_CONTENT_LENGTH,
-                      response.headers['content-length'].to_i
-                    )
+                  if response
+                    if response.respond_to?(:status)
+                      span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.status)
+                    end
+                    if response.respond_to?(:headers) && (response.headers || {})['content-length']
+                      span.set_tag(
+                        OpenSearch::Ext::TAG_RESPONSE_CONTENT_LENGTH,
+                        response.headers['content-length'].to_i
+                      )
+                    end
                   end
                 end
               end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../core/utils/only_once'
+require_relative '../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -49,8 +50,8 @@ module Datadog
           # Processes patching errors. This default implementation logs the error and reports relevant metrics.
           # @param e [Exception]
           def on_patch_error(e)
-            # Log the error
             Datadog.logger.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{Array(e.backtrace).first}")
+            Datadog::Core::Telemetry::Logger.report(e, description: "Failed to apply #{patch_name} patch")
 
             @patch_error_result = {
               type: e.class.name,

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

@@ -13,22 +13,10 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
-          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
-
           module_function
 
-          def patched?
-            PATCH_ONLY_ONCE.ran?
-          end
-
           def patch
-            PATCH_ONLY_ONCE.run do
-              begin
-                ::Presto::Client::Client.include(Instrumentation::Client)
-              rescue StandardError => e
-                Datadog.logger.error("Unable to apply Presto integration: #{e}")
-              end
-            end
+            ::Presto::Client::Client.include(Instrumentation::Client)
           end
         end
       end

data/lib/datadog/tracing/contrib/rack/middlewares.rb

@@ -138,6 +138,29 @@ module Datadog
             request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
             request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
 
+            if status != 404 && (last_route = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE))
+              last_script_name = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH) || ''
+
+              # If the last_script_name is empty but the env['SCRIPT_NAME'] is NOT empty
+              # then the current rack request was not routed and must be accounted for
+              # which only happens in pure nested rack requests i.e /rack/rack/hello/world
+              #
+              # To account for the unaccounted nested rack requests of /rack/hello/world,
+              # we use 'PATH_INFO knowing that rack cannot have named parameters
+              if last_script_name == '' && env['SCRIPT_NAME'] && env['SCRIPT_NAME'] != ''
+                last_script_name = last_route
+                last_route = env['PATH_INFO']
+              end
+
+              # Clear the route and route path tags from the request trace to avoid possibility of misplacement
+              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE)
+              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
+
+              # Ensure tags are placed in rack.request span as desired
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, last_script_name + last_route)
+              request_span.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
+            end
+
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
               Contrib::Analytics.set_sample_rate(request_span, configuration[:analytics_sample_rate])
@@ -195,6 +218,10 @@ module Datadog
               request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent)
             end
 
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE).nil? && status != 404
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, env['PATH_INFO'])
+            end
+
             HeaderTagging.tag_request_headers(request_span, request_header_collection, configuration)
             HeaderTagging.tag_response_headers(request_span, headers, configuration) if headers
 

data/lib/datadog/tracing/contrib/rails/runner.rb

@@ -58,7 +58,7 @@ module Datadog
           # Capture the executed source code when provided from STDIN.
           def eval(*args)
             span = Datadog::Tracing.active_span
-            if span.name == Ext::SPAN_RUNNER_STDIN
+            if span&.name == Ext::SPAN_RUNNER_STDIN
               source = args[0]
               span.set_tag(
                 Ext::TAG_RUNNER_SOURCE,

data/lib/datadog/tracing/contrib/redis/tags.rb

@@ -4,6 +4,7 @@ require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative 'ext'
 require_relative '../ext'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -45,6 +46,9 @@ module Datadog
               span.set_tag Ext::TAG_RAW_COMMAND, raw_command
 
               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
 
             private

data/lib/datadog/tracing/contrib/rest_client/request_patch.rb

@@ -25,6 +25,9 @@ module Datadog
               return super(&block) unless Tracing.enabled?
 
               datadog_trace_request(uri) do |_span, trace|
+                if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
+                  trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                end
                 Contrib::HTTP.inject(trace, processed_headers) if datadog_configuration[:distributed_tracing]
 
                 super(&block)

data/lib/datadog/tracing/contrib/sinatra/tracer.rb

@@ -69,6 +69,10 @@ module Datadog
 
                 trace.resource = span.resource
 
+                _, path = env['sinatra.route'].split(' ', 2)
+                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, path)
+                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, env['SCRIPT_NAME'])
+
                 sinatra_request_span = Sinatra::Env.datadog_span(env)
 
                 sinatra_request_span.resource = span.resource

data/lib/datadog/tracing/contrib/stripe/request.rb

@@ -47,8 +47,9 @@ module Datadog
 
             # Measure service stats
             Contrib::Analytics.set_measured(span)
-
-            span.set_tag(Ext::TAG_REQUEST_ID, event.request_id)
+            # `5.38.0` Add request_id to RequestEndEvent
+            # https://github.com/stripe/stripe-ruby/blob/master/CHANGELOG.md#5380---2021-08-10
+            span.set_tag(Ext::TAG_REQUEST_ID, event.request_id) if event.respond_to?(:request_id)
             span.set_tag(Ext::TAG_REQUEST_HTTP_STATUS, event.http_status.to_s)
             span.set_tag(Ext::TAG_REQUEST_METHOD, event.method)
             span.set_tag(Ext::TAG_REQUEST_PATH, event.path)