datadog 2.21.0 → 2.38.0

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

@@ -13,6 +13,7 @@ require_relative 'ext'
 require_relative 'header_collection'
 require_relative 'header_tagging'
 require_relative 'request_queue'
+require_relative 'route_inference'
 require_relative 'trace_proxy_middleware'
 
 module Datadog
@@ -134,32 +135,12 @@ module Datadog
             # Otherwise, the getter method would delegate to its root span
             trace.resource = request_span.resource unless trace.resource_override?
 
+            request_span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
             request_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
             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_route_and_endpoint_tags(trace: trace, request_span: request_span, status: status, env: env)
 
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
@@ -218,16 +199,14 @@ 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
 
             # detect if the status code is a 5xx and flag the request span as an error
             # unless it has been already set by the underlying framework
-            request_span.status = 1 if status.to_s.start_with?('5') && request_span.status.zero?
+            if request_span.status.zero? && Datadog.configuration.tracing.http_error_statuses.server.include?(status)
+              request_span.status = Tracing::Metadata::Ext::Errors::STATUS
+            end
           end
           # rubocop:enable Metrics/AbcSize
           # rubocop:enable Metrics/CyclomaticComplexity
@@ -240,6 +219,62 @@ module Datadog
             Datadog.configuration.tracing[:rack]
           end
 
+          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
+          # rubocop:disable Metrics/CyclomaticComplexity
+          # rubocop:disable Metrics/PerceivedComplexity
+          def set_route_and_endpoint_tags(trace:, request_span:, status:, env:)
+            return if status == 404
+
+            if (last_route = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE))
+              last_script_name = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH) || ''
+
+              # This happens when processing requests to a nested rack application,
+              # when parent app is instrumented, and the nested app is not instrumented
+              #
+              # When resource_renaming.always_simplified_endpoint is set to true,
+              # we infer the route from the full request path.
+              if last_script_name == '' && env['SCRIPT_NAME'] != '' &&
+                  !Datadog.configuration.tracing.resource_renaming.always_simplified_endpoint &&
+                  (inferred_route = RouteInference.infer(env['PATH_INFO']))
+                set_endpoint_tag(request_span, last_route + inferred_route)
+              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
+
+            if Datadog.configuration.tracing.resource_renaming.always_simplified_endpoint ||
+                request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE).nil?
+              if (inferred_route = RouteInference.read_or_infer(env))
+                set_endpoint_tag(request_span, inferred_route) if inferred_route
+              end
+            elsif !request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ENDPOINT)
+              set_endpoint_tag(request_span, request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE))
+            end
+          end
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/MethodLength
+          # rubocop:enable Metrics/CyclomaticComplexity
+          # rubocop:enable Metrics/PerceivedComplexity
+
+          def set_endpoint_tag(request_span, value)
+            # In the first iteration, http.endpoint must be reported in 2 cases:
+            #   1. resource renaming is enabled
+            #   2. AppSec is enabled and resource renaming is disabled (by default, not explicitly)
+            if Datadog.configuration.tracing.resource_renaming.enabled ||
+                Datadog.configuration.respond_to?(:appsec) &&
+                    Datadog.configuration.appsec&.enabled &&
+                    Datadog.configuration.tracing.resource_renaming.options[:enabled].default_precedence?
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ENDPOINT, value)
+            end
+          end
+
           # rubocop:disable Metrics/AbcSize
           # rubocop:disable Metrics/MethodLength
           def parse_url(env, original_env)

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

@@ -41,7 +41,7 @@ module Datadog
             # context of middleware patching outside a Rails server process (eg. a
             # process that doesn't serve HTTP requests but has Rails environment
             # loaded such as a Resque master process)
-            Datadog.logger.debug("Error patching middleware stack: #{e}")
+            Datadog.logger.debug("Error patching middleware stack: #{e.class}: #{e.message}")
           end
 
           def retain_middleware_name(middleware)
@@ -56,7 +56,7 @@ module Datadog
               end
             end
 
-            following = (middleware.instance_variable_get('@app') if middleware.instance_variable_defined?('@app'))
+            following = (middleware.instance_variable_get(:@app) if middleware.instance_variable_defined?(:@app))
 
             retain_middleware_name(following)
           end

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

@@ -39,7 +39,7 @@ module Datadog
           rescue => e
             # in case of an Exception we don't create a
             # `request.queuing` span
-            Datadog.logger.debug("[rack] unable to parse request queue headers: #{e}")
+            Datadog.logger.debug("[rack] unable to parse request queue headers: #{e.class}: #{e.message}")
             nil
           end
         end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../../../ruby_version'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rack
+        # This module provides logic for inferring HTTP route pattern
+        # from an HTTP path.
+        module RouteInference
+          MAX_NUMBER_OF_SEGMENTS = 8
+
+          INT_PARAM_REGEX = /\A[0-9]+\z/.freeze
+          INT_ID_PARAM_REGEX = /\A(?=.*\d)[\d._-]{3,}\z/.freeze
+          HEX_PARAM_REGEX = /\A(?=.*\d)[A-Fa-f0-9]{6,}\z/.freeze
+          HEX_ID_PARAM_REGEX = /\A(?=.*\d)[A-Fa-f0-9._-]{6,}\z/.freeze
+          STRING_PARAM_REGEX = /\A.{20,}|.*[%&'()*+,:=@].*\z/.freeze
+
+          DATADOG_INFERRED_ROUTE_ENV_KEY = 'datadog.inferred_route'
+
+          module_function
+
+          def read_or_infer(request_env)
+            request_env[DATADOG_INFERRED_ROUTE_ENV_KEY] ||=
+              infer(request_env['SCRIPT_NAME'].to_s + request_env['PATH_INFO'].to_s)
+          end
+
+          def infer(path)
+            count = 0
+            result = []
+
+            split(path, '/') do |segment|
+              next if segment.empty?
+              break if count >= MAX_NUMBER_OF_SEGMENTS
+              count += 1
+
+              result << case segment
+              when INT_PARAM_REGEX then '{param:int}'
+              when INT_ID_PARAM_REGEX then '{param:int_id}'
+              when HEX_PARAM_REGEX then '{param:hex}'
+              when HEX_ID_PARAM_REGEX then '{param:hex_id}'
+              when STRING_PARAM_REGEX then '{param:str}'
+              else segment
+              end
+            end
+
+            result.empty? ? '/' : "/#{result.join('/')}"
+          rescue
+            nil
+          end
+
+          if RubyVersion.is?('>= 2.6')
+            def split(path, pattern = nil, &block)
+              path.split(pattern, &block)
+            end
+          else
+            def split(path, pattern = nil, &block)
+              path.split(pattern).each(&block)
+              path
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,11 @@ module Datadog
         module TraceProxyMiddleware
           module_function
 
-          def call(env, configuration)
+          def call(env, configuration, &block)
+            if configuration[:inferred_proxy_enabled] &&
+                (proxy_type = env[Ext::HEADER_X_DD_PROXY]) && !proxy_type.empty?
+              return call_with_inferred_proxy(env, proxy_type, &block)
+            end
             return yield unless configuration[:request_queuing]
 
             # parse the request queue time
@@ -28,12 +32,14 @@ module Datadog
 
             request_span = Tracing.trace(Ext::SPAN_HTTP_PROXY_REQUEST, **options)
 
+            request_span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT_HTTP_PROXY)
             request_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT_HTTP_PROXY)
             request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HTTP_PROXY_REQUEST)
             request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PROXY)
 
             queue_span = Tracing.trace(Ext::SPAN_HTTP_PROXY_QUEUE, **options)
 
+            queue_span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT_HTTP_PROXY)
             queue_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT_HTTP_PROXY)
             queue_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HTTP_PROXY_QUEUE)
             queue_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PROXY)
@@ -51,6 +57,118 @@ module Datadog
             queue_span&.finish
             request_span&.finish
           end
+
+          # Creates a virtual parent span representing the upstream proxy
+          # that wraps the actual request processing.
+          #
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def call_with_inferred_proxy(env, proxy_type)
+            span_name = Ext::PROXY_SPAN_NAMES[proxy_type]
+            return yield unless span_name
+
+            request_time_ms = env[Ext::HEADER_X_DD_PROXY_REQUEST_TIME_MS].to_f
+            return yield unless request_time_ms.positive?
+
+            path = env[Ext::HEADER_X_DD_PROXY_PATH]
+            stage = env[Ext::HEADER_X_DD_PROXY_STAGE]
+            domain = env[Ext::HEADER_X_DD_PROXY_DOMAIN_NAME]
+            http_method = env[Ext::HEADER_X_DD_PROXY_HTTPMETHOD]
+            resource_path = env[Ext::HEADER_X_DD_PROXY_RESOURCE_PATH]
+
+            # NOTE: resource_path is the parameterized route (e.g. /users/{id}) vs literal path
+            resource = "#{http_method} #{resource_path || path}" if http_method
+
+            inferred_span = Tracing.trace(
+              span_name,
+              service: domain,
+              type: Tracing::Metadata::Ext::AppTypes::TYPE_WEB,
+              start_time: Time.at(request_time_ms / 1_000),
+            )
+            inferred_span.resource = resource if resource
+            inferred_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, proxy_type)
+            inferred_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
+            inferred_span.set_tag('stage', stage) if stage
+            inferred_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method) if http_method
+            inferred_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, "https://#{domain}#{path}") if domain && path
+            inferred_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, resource_path) if resource_path
+            inferred_span.set_metric(Ext::TAG_INFERRED_SPAN, 1)
+
+            set_optional_tags(inferred_span, env: env, proxy_type: proxy_type)
+
+            yield
+          # NOTE: The underlying {Rack::TraceMiddleware} rescues {Exception}
+          #       to tag the request span with error details.
+          #       We must propagate errors to the inferred proxy parent span.
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            inferred_span&.set_error(e)
+            raise
+          ensure
+            if inferred_span
+              propagate_request_span_tags(inferred_span, env: env)
+
+              if (trace = Tracing.active_trace) && resource
+                trace.resource = resource
+              end
+
+              inferred_span.finish
+            end
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+          # Sets cloud provider metadata and constructs the resource ARN.
+          #
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def set_optional_tags(span, env:, proxy_type:)
+            api_id = env[Ext::HEADER_X_DD_PROXY_API_ID]
+            region = env[Ext::HEADER_X_DD_PROXY_REGION]
+
+            # API Gateway v1 sends region as a single-quoted string
+            region = region.delete("'") if region
+
+            span.set_tag('apiid', api_id) if api_id
+            span.set_tag('region', region) if region
+
+            if (account_id = env[Ext::HEADER_X_DD_PROXY_ACCOUNT_ID])
+              span.set_tag('account_id', account_id)
+            end
+
+            if (user = env[Ext::HEADER_X_DD_PROXY_USER])
+              span.set_tag('aws_user', user)
+            end
+
+            if api_id && region
+              # NOTE: Update this when adding non-AWS proxy types.
+              restapi_prefix = (proxy_type == Ext::PROXY_AWS_APIGATEWAY) ? 'restapis' : 'apis'
+              span.set_tag('dd_resource_key', "arn:aws:apigateway:#{region}::/#{restapi_prefix}/#{api_id}")
+            end
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+          # Propagates response-level and security tags from the request span to
+          # the inferred parent.
+          def propagate_request_span_tags(span, env:)
+            rack_span = env[Ext::RACK_ENV_REQUEST_SPAN]
+            return unless rack_span
+
+            if (status_code = rack_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE))
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, status_code)
+              span.status = rack_span.status
+            end
+
+            if (user_agent = rack_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT))
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent)
+            end
+
+            # NOTE: Tracing shouldn't know about AppSec tags.
+            if (appsec_enabled = rack_span.get_metric('_dd.appsec.enabled'))
+              span.set_metric('_dd.appsec.enabled', appsec_enabled)
+            end
+
+            # NOTE: Tracing shouldn't know about AppSec tags.
+            if (appsec_json = rack_span.get_tag('_dd.appsec.json'))
+              span.set_tag('_dd.appsec.json', appsec_json)
+            end
+          end
         end
       end
     end

data/lib/datadog/tracing/contrib/rails/configuration/settings.rb

@@ -51,8 +51,11 @@ module Datadog
               end
             end
 
-            option :distributed_tracing, default: true, type: :bool
-
+            option :distributed_tracing do |o|
+              o.type :bool
+              o.env Ext::ENV_DISTRIBUTED_TRACING
+              o.default true
+            end
             option :request_queuing do |o|
               o.type :bool
               o.default false

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

@@ -9,6 +9,7 @@ module Datadog
         module Ext
           APP = 'rails'
           ENV_ENABLED = 'DD_TRACE_RAILS_ENABLED'
+          ENV_DISTRIBUTED_TRACING = 'DD_TRACE_RAILS_DISTRIBUTED_TRACING'
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAILS_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAILS_ANALYTICS_SAMPLE_RATE'

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

@@ -18,7 +18,7 @@ module Datadog
             app_config.log_tags << proc { Tracing.log_correlation if Datadog.configuration.tracing.log_injection }
           rescue => e
             Datadog.logger.warn(
-              "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class.name} #{e.message}"
+              "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class}: #{e.message}"
             )
             false
           end

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

@@ -26,8 +26,8 @@ module Datadog
           rescue Exception => e
             span = Tracing.active_span
             if !span.nil? && ActionPack::Utils.exception_is_error?(e)
-              # Only set error if it's supposed to be flagged as such
-              # e.g. we don't want to flag 404s.
+              # By default, only 5XX exceptions are actually errors (e.g. don't flag 404s).
+              # This can be changed by setting `DD_TRACE_HTTP_SERVER_ERROR_STATUSES` environment variable.
               # You can add custom errors via `config.action_dispatch.rescue_responses`
               span.set_error(e)
 

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

@@ -6,7 +6,6 @@ require_relative 'framework'
 require_relative 'log_injection'
 require_relative 'middlewares'
 require_relative 'runner'
-require_relative '../../../core/contrib/rails/utils'
 require_relative '../semantic_logger/patcher'
 
 module Datadog

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

@@ -53,6 +53,7 @@ module Datadog
               name,
               service: Datadog.configuration.tracing[:rails][:service_name],
               tags: {
+                Tracing::Metadata::Ext::TAG_SVC_SRC => Ext::TAG_COMPONENT,
                 Tracing::Metadata::Ext::TAG_COMPONENT => Ext::TAG_COMPONENT,
                 Tracing::Metadata::Ext::TAG_OPERATION => operation,
               }
@@ -86,7 +87,7 @@ module Datadog
                 # Reads one more byte than the limit to allow us to check if the source exceeds the limit.
                 source = File.read(file, MAX_TAG_VALUE_SIZE + 1)
               rescue => e
-                Datadog.logger.debug("Failed to read file '#{file}' for Rails runner: #{e.message}")
+                Datadog.logger.debug { "Failed to read file '#{file}' for Rails runner: #{e.class}: #{e.message}" }
               end
 
               Tracing.trace(
@@ -94,6 +95,7 @@ module Datadog
                 service: Datadog.configuration.tracing[:rails][:service_name],
                 resource: resource,
                 tags: {
+                  Tracing::Metadata::Ext::TAG_SVC_SRC => Ext::TAG_COMPONENT,
                   Tracing::Metadata::Ext::TAG_COMPONENT => Ext::TAG_COMPONENT,
                   Tracing::Metadata::Ext::TAG_OPERATION => operation,
                 }

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

@@ -3,7 +3,7 @@
 require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative 'ext'
-require_relative '../utils/quantization/hash'
+require_relative '../utils/quantization/hash_formatter'
 
 module Datadog
   module Tracing
@@ -53,6 +53,7 @@ module Datadog
 
             def annotate_invoke!(span, args)
               span.resource = name
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               # Set analytics sample rate
               if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
                 Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
@@ -66,21 +67,22 @@ module Datadog
               span.set_tag(Ext::TAG_TASK_ARG_NAMES, arg_names)
               span.set_tag(Ext::TAG_INVOKE_ARGS, quantize_args(args)) unless args.nil?
             rescue => e
-              Datadog.logger.debug("Error while tracing Rake invoke: #{e.class.name} #{e.message}")
+              Datadog.logger.debug { "Error while tracing Rake invoke: #{e.class}: #{e.message}" }
             end
 
             def annotate_execute!(span, args)
               span.resource = name
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_EXECUTE)
               span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
             rescue => e
-              Datadog.logger.debug("Error while tracing Rake execute: #{e.class.name} #{e.message}")
+              Datadog.logger.debug { "Error while tracing Rake execute: #{e.class}: #{e.message}" }
             end
 
             def quantize_args(args)
               quantize_options = configuration[:quantize][:args]
-              Contrib::Utils::Quantization::Hash.format(args, quantize_options)
+              Contrib::Utils::Quantization::HashFormatter.format(args, quantize_options)
             end
 
             def enabled?

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

@@ -34,7 +34,7 @@ module Datadog
             str = Core::Utils.utf8_encode(arg, binary: true, placeholder: PLACEHOLDER)
             Core::Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
           rescue => e
-            Datadog.logger.debug("non formattable Redis arg #{str}: #{e}")
+            Datadog.logger.debug("non formattable Redis arg #{str}: #{e.class}: #{e.message}")
             PLACEHOLDER
           end
 

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

@@ -21,11 +21,6 @@ module Datadog
                 )
               end
 
-              # Tag original global service name if not used
-              if span.service != Datadog.configuration.service
-                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-              end
-
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
 
@@ -47,7 +42,7 @@ module Datadog
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
             rescue => e
-              Datadog.logger.error(e.message)
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 

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

@@ -26,6 +26,7 @@ module Datadog
           class << self
             def call(client, command, service_name, command_args)
               Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Redis::Ext::TAG_COMPONENT)
                 raw_command = get_command(command, true)
                 span.resource = command_args ? raw_command : get_command(command, false)
 
@@ -37,6 +38,7 @@ module Datadog
 
             def call_pipelined(client, commands, service_name, command_args)
               Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Redis::Ext::TAG_COMPONENT)
                 raw_command = get_pipeline_commands(commands, true)
                 span.resource = command_args ? raw_command : get_pipeline_commands(commands, false)
 

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

@@ -33,6 +33,17 @@ module Datadog
           def register_as(name, registry: Contrib::REGISTRY, auto_patch: false, **options)
             registry.add(name, new(name, **options), auto_patch)
           end
+
+          # Registers this `as` in the global tracer registry as an alias of `original_name`.
+          # Using `as` or `original_name` become interchangeable.
+          # The configuration object is shared between the two names.
+          # The patcher will only run once if both are activated.
+          def register_alias_for(original_name, as:, registry: Contrib::REGISTRY)
+            original = registry[original_name]
+            raise ArgumentError, "integration '#{original_name}' not registered" unless original
+
+            registry.add(as, original, false)
+          end
         end
 
         # Instance methods for registerable behavior

data/lib/datadog/tracing/contrib/resque/resque_job.rb

@@ -35,6 +35,7 @@ module Datadog
             return yield unless datadog_configuration && Tracing.enabled?
 
             Tracing.trace(Ext::SPAN_JOB, **span_options) do |span|
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               span.resource = args.first.is_a?(Hash) && args.first['job_class'] || name
               span.type = Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
 

data/lib/datadog/tracing/contrib/rest_client/configuration/settings.rb

@@ -30,8 +30,11 @@ module Datadog
               o.default 1.0
             end
 
-            option :distributed_tracing, default: true, type: :bool
-
+            option :distributed_tracing do |o|
+              o.type :bool
+              o.env Ext::ENV_DISTRIBUTED_TRACING
+              o.default true
+            end
             option :service_name do |o|
               o.default do
                 Contrib::SpanAttributeSchema.fetch_service_name(

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

@@ -8,6 +8,7 @@ module Datadog
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
           ENV_ENABLED = 'DD_TRACE_REST_CLIENT_ENABLED'
+          ENV_DISTRIBUTED_TRACING = 'DD_TRACE_REST_CLIENT_DISTRIBUTED_TRACING'
           ENV_SERVICE_NAME = 'DD_TRACE_REST_CLIENT_SERVICE_NAME'
           ENV_PEER_SERVICE = 'DD_TRACE_REST_CLIENT_PEER_SERVICE'
           # @!visibility private

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

@@ -37,6 +37,7 @@ module Datadog
             end
 
             def datadog_tag_request(uri, span)
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               span.resource = method.to_s.upcase
 
               if datadog_configuration[:peer_service]
@@ -46,11 +47,6 @@ module Datadog
                 )
               end
 
-              # Tag original global service name if not used
-              if span.service != Datadog.configuration.service
-                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-              end
-
               span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
@@ -99,7 +95,10 @@ module Datadog
                 end
               end
             rescue ::RestClient::ExceptionWithResponse => e
-              span.set_error(e) if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(e.http_code)
+              # DEV-3.0: This was previously checking against a 500..599 range.
+              # To not introduce breaking change, this was changed to use `http_error_statuses.server`,
+              # but `rest_client` is a client library, this check should use `http_error_statuses.client` instead.
+              span.set_error(e) if Datadog.configuration.tracing.http_error_statuses.server.include?(e.http_code)
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, e.http_code)
 
               raise e

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

@@ -7,6 +7,7 @@ module Datadog
         # Roda integration constants
         module Ext
           APP = 'roda'
+          TAG_COMPONENT = 'roda'
           ENV_ENABLED = 'DD_TRACE_RODA_ENABLED'
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_RODA_ANALYTICS_ENABLED'

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

@@ -25,7 +25,10 @@ module Datadog
               begin
                 request_method = request.request_method.to_s.upcase
 
-                span.service = configuration[:service_name] if configuration[:service_name]
+                if configuration[:service_name]
+                  span.service = configuration[:service_name]
+                  span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
+                end
 
                 span.type = Tracing::Metadata::Ext::HTTP::TYPE_INBOUND
 
@@ -61,7 +64,9 @@ module Datadog
               # Adds status code to the resource name once the resource comes back
               span.resource = "#{request_method} #{status_code}"
               span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, status_code)
-              span.status = 1 if status_code.to_s.start_with?('5')
+              if Datadog.configuration.tracing.http_error_statuses.server.include?(status_code)
+                span.status = Tracing::Metadata::Ext::Errors::STATUS
+              end
               response
             end
           end