datadog 2.22.0 → 2.23.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
@@ -138,28 +139,7 @@ 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_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 +198,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 +218,60 @@ 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.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/route_inference.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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)
+            segments = path.delete_prefix('/').split('/', MAX_NUMBER_OF_SEGMENTS + 1).first(MAX_NUMBER_OF_SEGMENTS)
+
+            segments.map! do |segment| #: Array[String?]
+              next if segment.empty?
+
+              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
+
+            segments.compact! #: Array[String]
+
+            "/#{segments.join("/")}"
+          rescue
+            nil
+          end
+        end
+      end
+    end
+  end
+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/rest_client/request_patch.rb

@@ -99,7 +99,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/instrumentation.rb

@@ -61,7 +61,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

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

@@ -70,7 +70,9 @@ module Datadog
                   sinatra_response = ::Sinatra::Response.new([], status) # Build object to use status code helpers
 
                   span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, sinatra_response.status)
-                  span.set_error(env['sinatra.error']) if sinatra_response.server_error?
+                  if Datadog.configuration.tracing.http_error_statuses.server.include?(sinatra_response.status)
+                    span.set_error(env['sinatra.error'])
+                  end
                 end
 
                 if (headers = response[1])

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

@@ -5,10 +5,17 @@ module Datadog
     module Contrib
       # Useful checking whether the defined range covers status code
       class StatusRangeMatcher
+        attr_reader :ranges
+
         def initialize(ranges)
           @ranges = Array(ranges)
         end
 
+        def +(other)
+          StatusRangeMatcher.new(@ranges + other.ranges)
+        end
+        alias_method :concat, :+
+
         def include?(status)
           @ranges.any? do |e|
             case e

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        module Configuration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            option :service_name
+
+            option :distributed_tracing, default: false, type: :bool
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../../../distributed/fetcher'
+require_relative '../../../distributed/propagation'
+require_relative '../../../distributed/b3_multi'
+require_relative '../../../distributed/b3_single'
+require_relative '../../../distributed/datadog'
+require_relative '../../../distributed/none'
+require_relative '../../../distributed/trace_context'
+require_relative '../../../configuration/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        module Distributed
+          # Extracts and injects propagation through Kafka message headers.
+          class Propagation < Tracing::Distributed::Propagation
+            def initialize(
+              propagation_style_inject:,
+              propagation_style_extract:,
+              propagation_extract_first:
+            )
+              super(
+                propagation_styles: {
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER =>
+                    Tracing::Distributed::B3Multi.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER =>
+                    Tracing::Distributed::B3Single.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG =>
+                    Tracing::Distributed::Datadog.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
+                    Tracing::Distributed::TraceContext.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE =>
+                    Tracing::Distributed::Baggage.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
+                },
+                propagation_style_inject: propagation_style_inject,
+                propagation_style_extract: propagation_style_extract,
+                propagation_extract_first: propagation_extract_first
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_WATERDROP_ENABLED'
+
+          SPAN_PRODUCER = 'karafka.produce'
+
+          TAG_PRODUCER = 'kafka.producer'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Description of WaterDrop integration
+        class Integration
+          include Contrib::Integration
+
+          # WaterDrop added class-level instrumentation in version 2.8.8.rc1
+          MINIMUM_VERSION = Gem::Version.new('2.8.8.rc1')
+
+          register_as :waterdrop, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['waterdrop']&.version
+          end
+
+          def self.loaded?
+            !defined?(::WaterDrop).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Middleware to propagate tracing context in messages produced by WaterDrop
+        module Middleware
+          class << self
+            def call(message)
+              trace_op = Datadog::Tracing.active_trace
+
+              if trace_op && Datadog::Tracing::Distributed::PropagationPolicy.enabled?(
+                global_config: configuration,
+                trace: trace_op
+              )
+                WaterDrop.inject(trace_op.to_digest, message[:headers] ||= {})
+              end
+
+              if Datadog::DataStreams.enabled?
+                Datadog::DataStreams.set_produce_checkpoint(
+                  type: 'kafka',
+                  destination: message[:topic],
+                  auto_instrumentation: true
+                ) do |key, value|
+                  message[:headers] ||= {}
+                  message[:headers][key] = value
+                end
+              end
+
+              message
+            end
+
+            private
+
+            def configuration
+              Datadog.configuration.tracing[:waterdrop]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Patcher enables patching of 'waterdrop' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'producer'
+            require_relative 'middleware'
+
+            ::WaterDrop::Producer.prepend(Producer)
+            ::WaterDrop.instrumentation.subscribe('producer.configured') do |event|
+              producer = event[:producer]
+
+              included_middlewares = producer.middleware.instance_variable_get(:@steps)
+              producer.middleware.append(Middleware) unless included_middlewares.include?(Middleware)
+
+              if Datadog.configuration.data_streams.enabled
+                producer.monitor.subscribe('message.acknowledged') do |ack_event|
+                  if Datadog::DataStreams.enabled?
+                    payload = ack_event.payload
+                    Datadog::DataStreams.track_kafka_produce(payload[:topic], payload[:partition], payload[:offset])
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/waterdrop/producer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module WaterDrop
+        # Producer integration for WaterDrop
+        module Producer
+          %i[
+            produce_many_sync
+            produce_many_async
+            produce_sync
+            produce_async
+          ].each do |method|
+            define_method(method) do |messages|
+              Datadog::Tracing.trace(Ext::SPAN_PRODUCER, resource: "waterdrop.#{__method__}") do
+                extract_span_tags(messages)
+                super(messages)
+              end
+            end
+          end
+
+          private
+
+          def extract_span_tags(messages)
+            messages = [messages] if messages.is_a?(Hash)
+            span = Datadog::Tracing.active_span
+            return unless span
+
+            topics = []
+            partitions = []
+            messages.each do |message|
+              topics << message[:topic]
+              partitions << message[:partition] if message.key?(:partition)
+            end
+
+            span.set_tag(Ext::TAG_PRODUCER, id)
+            span.set_tag(Contrib::Karafka::Ext::TAG_MESSAGE_COUNT, messages.size)
+            span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Contrib::Karafka::Ext::TAG_SYSTEM)
+
+            span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, topics.uniq.sort.join(','))
+            span.set_tag(Contrib::Karafka::Ext::TAG_PARTITION, partitions.uniq.sort.join(',')) if partitions.any?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'component'
+require_relative 'waterdrop/integration'
+require_relative 'waterdrop/distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # `WaterDrop` integration public API
+      module WaterDrop
+        def self.inject(digest, data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.inject!(digest, data)
+        end
+
+        def self.extract(data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.extract(data)
+        end
+
+        Contrib::Component.register('waterdrop') do |config|
+          tracing = config.tracing
+          tracing.propagation_style
+
+          @propagation = WaterDrop::Distributed::Propagation.new(
+            propagation_style_inject: tracing.propagation_style_inject,
+            propagation_style_extract: tracing.propagation_style_extract,
+            propagation_extract_first: tracing.propagation_extract_first
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib.rb

@@ -55,6 +55,7 @@ require_relative 'contrib/httpclient/integration'
 require_relative 'contrib/httprb/integration'
 require_relative 'contrib/integration'
 require_relative 'contrib/kafka/integration'
+require_relative 'contrib/waterdrop'
 require_relative 'contrib/karafka'
 require_relative 'contrib/lograge/integration'
 require_relative 'contrib/mongodb/integration'

data/lib/datadog/tracing/metadata/ext.rb

@@ -94,8 +94,8 @@ module Datadog
 
         # @public_api
         module HTTP
-          ERROR_RANGE = (500...600).freeze
           TAG_BASE_URL = 'http.base_url'
+          TAG_ENDPOINT = 'http.endpoint'
           TAG_METHOD = 'http.method'
           TAG_STATUS_CODE = 'http.status_code'
           TAG_USER_AGENT = 'http.useragent'

data/lib/datadog/tracing/transport/http/client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'statistics'
+require_relative '../../../core/transport/http/client'
 require_relative '../../../core/transport/http/env'
 require_relative '../../../core/transport/http/response'
 
@@ -9,33 +10,24 @@ module Datadog
     module Transport
       module HTTP
         # Routes, encodes, and sends tracer data to the trace agent via HTTP.
-        class Client
+        class Client < Core::Transport::HTTP::Client
           include Datadog::Tracing::Transport::HTTP::Statistics
 
-          attr_reader :api, :logger
+          private
 
-          def initialize(api, logger: Datadog.logger)
-            @api = api
-            @logger = logger
-          end
-
-          def send_request(request, &block)
-            # Build request into env
-            env = build_env(request)
-
-            # Get responses from API
-            response = yield(api, env)
+          def on_response(response)
+            super
 
             # Update statistics
             update_stats_from_response!(response)
+          end
 
-            response
-          rescue => e
-            message =
-              "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
-                "Location: #{Array(e.backtrace).first}"
+          def on_exception(exception)
+            # Note: this method does NOT call super - it has replacement
+            # logic for how to log the exception.
+
+            message = build_exception_message(exception)
 
-            # Log error
             if stats.consecutive_errors > 0
               logger.debug(message)
             else
@@ -44,13 +36,7 @@ module Datadog
             end
 
             # Update statistics
-            update_stats_from_exception!(e)
-
-            Datadog::Core::Transport::InternalErrorResponse.new(e)
-          end
-
-          def build_env(request)
-            Datadog::Core::Transport::HTTP::Env.new(request)
+            update_stats_from_exception!(exception)
           end
         end
       end