datadog 2.22.0 → 2.23.0

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

@@ -13,8 +13,7 @@ module Datadog
               # Gets the equivalent status code for the exception (not all are 5XX)
               # You can add custom errors via `config.action_dispatch.rescue_responses`
               status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(exception.class.name)
-              # Only 5XX exceptions are actually errors (e.g. don't flag 404s)
-              status.to_s.start_with?('5')
+              Datadog.configuration.tracing.http_error_statuses.server.include?(status)
             else
               true
             end

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

@@ -6,17 +6,31 @@ module Datadog
       module ActiveJob
         # Active Job log injection wrapped around job execution
         module LogInjection
-          def self.included(base)
-            base.class_eval do
-              around_perform do |_, block|
-                if Datadog.configuration.tracing.log_injection && logger.respond_to?(:tagged)
-                  logger.tagged(Tracing.log_correlation, &block)
-                else
-                  block.call
+          # Active Job 4 / 5 don't execute `perform_now` at the right point, so we do best effort log correlation tagging
+          module AroundPerformPatch
+            def self.included(base)
+              base.class_eval do
+                around_perform do |_, block|
+                  if Datadog.configuration.tracing.log_injection && logger.respond_to?(:tagged)
+                    logger.tagged(Tracing.log_correlation, &block)
+                  else
+                    block.call
+                  end
                 end
               end
             end
           end
+
+          # Active Job 6+ executes `perform_now` at the right point, so we can provide better log correlation tagging
+          module PerformNowPatch
+            def perform_now
+              if Datadog.configuration.tracing.log_injection && logger.respond_to?(:tagged)
+                logger.tagged(Tracing.log_correlation) { super }
+              else
+                super
+              end
+            end
+          end
         end
       end
     end

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

@@ -26,7 +26,11 @@ module Datadog
 
           def inject_log_correlation
             ::ActiveSupport.on_load(:active_job) do
-              include LogInjection
+              if ::ActiveJob.gem_version < Gem::Version.new('6.0.0')
+                include LogInjection::AroundPerformPatch
+              else
+                include LogInjection::PerformNowPatch
+              end
             end
           end
         end

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

@@ -36,8 +36,10 @@ module Datadog
             span.name = Ext::SPAN_COMMAND
             span.resource = context.safely(:resource)
 
-            # Set error on the span if the Response Status Code is in error range
-            if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(context.safely(:status_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 `aws` is a client library, this check should use `http_error_statuses.client` instead.
+            if Datadog.configuration.tracing.http_error_statuses.server.include?(context.safely(:status_code))
               # At this point we do not have any additional diagnostics
               # besides the HTTP status code which is recorded in the span tags
               # later in this method.

data/lib/datadog/tracing/contrib/ethon/easy_patch.rb

@@ -57,7 +57,10 @@ module Datadog
                   set_span_error_message("Request has failed: #{message}")
                 else
                   @datadog_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response_code)
-                  if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(response_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 `ethon` is a client library, this check should use `http_error_statuses.client` instead.
+                  if Datadog.configuration.tracing.http_error_statuses.server.include?(response_code)
                     set_span_error_message("Request has failed with HTTP error: #{response_code}")
                   end
                 end

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

@@ -41,9 +41,17 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `excon` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -13,10 +13,6 @@ module Datadog
           # Custom settings for the Faraday integration
           # @public_api
           class Settings < Contrib::Configuration::Settings
-            DEFAULT_ERROR_HANDLER = lambda do |env|
-              Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(env[:status])
-            end
-
             option :enabled do |o|
               o.type :bool
               o.env Ext::ENV_ENABLED
@@ -44,9 +40,17 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `faraday` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -39,9 +39,13 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 500...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to server (500..599)
+                  Datadog.configuration.tracing.http_error_statuses.server
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -176,6 +176,26 @@ module Datadog
             "#{type.graphql_name}.resolve_type"
           end
 
+          # Serialize error's `locations` array as an array of Strings, given
+          # Span Events do not support hashes nested inside arrays.
+          #
+          # Here's an example in which `locations`:
+          #   [
+          #    {"line" => 3, "column" => 10},
+          #    {"line" => 7, "column" => 8},
+          #   ]
+          # is serialized as:
+          #   ["3:10", "7:8"]
+          def self.serialize_error_locations(locations)
+            # locations are only provided by the `graphql` library when the error can
+            # be associated to a particular point in the query.
+            return [] if locations.nil?
+
+            locations.map do |location|
+              "#{location["line"]}:#{location["column"]}"
+            end
+          end
+
           private
 
           # Traces the given callable with the given trace key, resource, and kwargs.
@@ -268,28 +288,13 @@ module Datadog
                   @type_key => parsed_error.type,
                   @stacktrace_key => parsed_error.backtrace,
                   @message_key => graphql_error['message'],
-                  @locations_key => serialize_error_locations(graphql_error['locations']),
+                  @locations_key =>
+                    Datadog::Tracing::Contrib::GraphQL::UnifiedTrace.serialize_error_locations(graphql_error['locations']),
                   @path_key => graphql_error['path'],
                 )
               )
             end
           end
-
-          # Serialize error's `locations` array as an array of Strings, given
-          # Span Events do not support hashes nested inside arrays.
-          #
-          # Here's an example in which `locations`:
-          #   [
-          #    {"line" => 3, "column" => 10},
-          #    {"line" => 7, "column" => 8},
-          #   ]
-          # is serialized as:
-          #   ["3:10", "7:8"]
-          def serialize_error_locations(locations)
-            locations.map do |location|
-              "#{location["line"]}:#{location["column"]}"
-            end
-          end
         end
       end
     end

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

@@ -46,9 +46,17 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `http` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -45,9 +45,17 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `httpclient` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -45,9 +45,17 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `httprb` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

data/lib/datadog/tracing/contrib/kafka/instrumentation/consumer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Instrumentation
+          # Instrumentation for Kafka::Consumer
+          module Consumer
+            def self.prepended(base)
+              base.prepend(InstanceMethods)
+            end
+
+            # Instance methods for consumer instrumentation
+            module InstanceMethods
+              def each_message(**kwargs, &block)
+                return super unless Datadog::DataStreams.enabled?
+
+                wrapped_block = proc do |message|
+                  Datadog.logger.debug { "Kafka each_message: DSM enabled for topic #{message.topic}" }
+
+                  begin
+                    headers = message.headers || {}
+                    Datadog::DataStreams.set_consume_checkpoint(
+                      type: 'kafka',
+                      source: message.topic,
+                      auto_instrumentation: true
+                    ) { |key| headers[key] }
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                  end
+
+                  yield(message) if block
+                end
+
+                super(**kwargs, &wrapped_block)
+              end
+
+              def each_batch(**kwargs, &block)
+                return super unless Datadog::DataStreams.enabled?
+
+                wrapped_block = proc do |batch|
+                  Datadog.logger.debug { "Kafka each_batch: DSM enabled for topic #{batch.topic}" }
+
+                  begin
+                    Datadog::DataStreams.set_consume_checkpoint(
+                      type: 'kafka',
+                      source: batch.topic,
+                      auto_instrumentation: true
+                    )
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                  end
+
+                  yield(batch) if block
+                end
+
+                super(**kwargs, &wrapped_block)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/instrumentation/producer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Instrumentation
+          # Instrumentation for Kafka::Producer
+          module Producer
+            def self.prepended(base)
+              base.prepend(InstanceMethods)
+            end
+
+            module InstanceMethods
+              def deliver_messages(**kwargs)
+                if Datadog::DataStreams.enabled?
+                  begin
+                    pending_messages = instance_variable_get(:@pending_message_queue)
+
+                    if pending_messages && !pending_messages.empty?
+                      pending_messages.each do |message|
+                        message.headers ||= {}
+                        Datadog::DataStreams.set_produce_checkpoint(
+                          type: 'kafka',
+                          destination: message.topic,
+                          auto_instrumentation: true
+                        ) do |key, value|
+                          message.headers[key] = value
+                        end
+                      end
+                    end
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                  end
+                end
+
+                super
+              end
+
+              def send_messages(messages, **kwargs)
+                if Datadog::DataStreams.enabled?
+                  begin
+                    messages.each do |message|
+                      message[:headers] ||= {}
+                      Datadog::DataStreams.set_produce_checkpoint(
+                        type: 'kafka',
+                        destination: message[:topic],
+                        auto_instrumentation: true
+                      ) do |key, value|
+                        message[:headers][key] = value
+                      end
+                    end
+                  rescue => e
+                    Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                  end
+                end
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -21,6 +21,20 @@ module Datadog
           def patch
             # Subscribe to Kafka events
             Events.subscribe!
+
+            # Apply monkey patches for additional instrumentation (e.g., DSM)
+            patch_producer if defined?(::Kafka::Producer)
+            patch_consumer if defined?(::Kafka::Consumer)
+          end
+
+          def patch_producer
+            require_relative 'instrumentation/producer'
+            ::Kafka::Producer.prepend(Instrumentation::Producer)
+          end
+
+          def patch_consumer
+            require_relative 'instrumentation/consumer'
+            ::Kafka::Consumer.prepend(Instrumentation::Consumer)
           end
         end
       end

data/lib/datadog/tracing/contrib/karafka/framework.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Karafka framework code, used to essentially:
+        # - handle configuration entries which are specific to Datadog tracing
+        # - instrument parts of the framework when needed
+        module Framework
+          def self.setup
+            Datadog.configure do |datadog_config|
+              karafka_config = datadog_config.tracing[:karafka]
+              activate_waterdrop!(datadog_config, karafka_config)
+            end
+          end
+
+          # Apply relevant configuration from Karafka to WaterDrop
+          def self.activate_waterdrop!(datadog_config, karafka_config)
+            datadog_config.tracing.instrument(
+              :waterdrop,
+              service_name: karafka_config[:service_name],
+              distributed_tracing: karafka_config[:distributed_tracing],
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/monitor.rb

@@ -47,6 +47,17 @@ module Datadog
                 span.set_tag(Ext::TAG_CONSUMER, consumer)
                 span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, job.executor.topic.name)
                 span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_SYSTEM)
+
+                # DSM: Track consumer offset stats for batch processing
+                if Datadog.configuration.data_streams.enabled
+                  job.messages.each do |message|
+                    Datadog::DataStreams.track_kafka_consume(
+                      job.executor.topic.name,
+                      job.executor.partition,
+                      message.metadata.offset
+                    )
+                  end
+                end
               end
 
               super

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

@@ -35,6 +35,24 @@ module Datadog
                 Datadog::Tracing.continue_trace!(trace_digest) if trace_digest
               end
 
+              if Datadog::DataStreams.enabled?
+                begin
+                  headers = if message.metadata.respond_to?(:raw_headers)
+                    message.metadata.raw_headers
+                  else
+                    message.metadata.headers
+                  end
+
+                  Datadog::DataStreams.set_consume_checkpoint(
+                    type: 'kafka',
+                    source: message.topic,
+                    auto_instrumentation: true
+                  ) { |key| headers[key] }
+                rescue => e
+                  Datadog.logger.debug("Error setting DSM checkpoint: #{e.class}: #{e}")
+                end
+              end
+
               Tracing.trace(Ext::SPAN_MESSAGE_CONSUME) do |span|
                 span.set_tag(Ext::TAG_OFFSET, message.metadata.offset)
                 span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, message.topic)
@@ -48,6 +66,18 @@ module Datadog
           end
         end
 
+        module AppPatch
+          ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Core::Utils::OnlyOnce.new }
+
+          def initialized!
+            ONLY_ONCE_PER_APP[self].run do
+              # Activate tracing on components related to Karafka (e.g. WaterDrop)
+              Contrib::Karafka::Framework.setup
+            end
+            super
+          end
+        end
+
         # Patcher enables patching of 'karafka' module.
         module Patcher
           include Contrib::Patcher
@@ -60,9 +90,11 @@ module Datadog
 
           def patch
             require_relative 'monitor'
+            require_relative 'framework'
 
             ::Karafka::Instrumentation::Monitor.prepend(Monitor)
             ::Karafka::Messages::Messages.prepend(MessagesPatch)
+            ::Karafka::App.singleton_class.prepend(AppPatch)
           end
         end
       end