datadog 2.20.0 → 2.26.0

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,49 @@
+# 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]
+              add_middleware(producer)
+
+              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
+
+          def add_middleware(producer)
+            included_middlewares = producer.middleware.instance_variable_get(:@steps)
+            producer.middleware.append(Middleware) unless included_middlewares.include?(Middleware)
+          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,41 @@
+# 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
+
+          # Steep: https://github.com/soutaro/steep/issues/477
+          # @type ivar @propagation: WaterDrop::Distributed::Propagation
+          @propagation.inject!(digest, data)
+        end
+
+        def self.extract(data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          # Steep: https://github.com/soutaro/steep/issues/477
+          # @type ivar @propagation: WaterDrop::Distributed::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/diagnostics/environment_logger.rb

@@ -62,7 +62,7 @@ module Datadog
             # return `nil` with IO transport
             return unless transport.respond_to?(:client)
 
-            adapter = transport.client.api.adapter
+            adapter = transport.client.instance.adapter
             adapter.url
           end
 

data/lib/datadog/tracing/distributed/baggage.rb

@@ -175,8 +175,9 @@ module Datadog
 
           tags = {}
 
-          baggage_tag_keys.each do |key, _| # rubocop:disable Style/HashEachMethods
-            value = baggage[key]
+          baggage_tag_keys.each do |key, _|
+            # Steep: https://github.com/soutaro/steep/issues/2031
+            value = baggage[key] # steep:ignore ArgumentTypeMismatch
             next if value.nil? || value.empty?
 
             tags["baggage.#{key}"] = value

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

@@ -82,12 +82,20 @@ module Datadog
           TAG_MSG = 'error.message'
           TAG_STACK = 'error.stack'
           TAG_TYPE = 'error.type'
+
+          # From https://opentelemetry.io/docs/specs/semconv/registry/attributes/exception/#exception-stacktrace
+          ATTRIBUTE_MESSAGE = 'exception.message'
+          ATTRIBUTE_STACKTRACE = 'exception.stacktrace'
+          ATTRIBUTE_TYPE = 'exception.type'
+
+          # From https://opentelemetry.io/docs/specs/semconv/exceptions/exceptions-spans/#exception-event
+          EVENT_NAME = 'exception'
         end
 
         # @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/remote.rb

@@ -7,8 +7,6 @@ module Datadog
   module Tracing
     # Remote configuration declaration
     module Remote
-      class ReadError < StandardError; end
-
       class << self
         PRODUCT = 'APM_TRACING'
 
@@ -71,13 +69,7 @@ module Datadog
         private
 
         def parse_content(content)
-          data = content.data.read
-
-          content.data.rewind
-
-          raise ReadError, 'EOF reached' if data.nil?
-
-          JSON.parse(data)
+          JSON.parse(content.data)
         end
       end
     end

data/lib/datadog/tracing/sampling/priority_sampler.rb

@@ -60,7 +60,9 @@ module Datadog
         ensure
           if trace.sampling_priority && trace.sampling_priority > 0
             # Don't modify decision if priority was set upstream.
-            if !distributed_sampling_priority && !trace.has_tag?(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+            # Steep: https://github.com/soutaro/steep/issues/1971
+            if !distributed_sampling_priority && # steep:ignore FallbackAny
+                !trace.has_tag?(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
               # If no sampling priority being assigned at this point, a custom
               # sampler implementation is configured: this means the user has
               # full control over the sampling decision.

data/lib/datadog/tracing/span.rb

@@ -80,7 +80,7 @@ module Datadog
 
         @meta = meta || {}
         @metrics = metrics || {}
-        @metastruct = metastruct || {}
+        @metastruct = metastruct || Metastruct.new
         @status = status || 0
 
         # start_time and end_time track wall clock. In Ruby, wall clock

data/lib/datadog/tracing/span_event.rb

@@ -69,8 +69,8 @@ module Datadog
 
       private
 
-      MIN_INT64_SIGNED = -2**63
-      MAX_INT64_SIGNED = 2 << 63 - 1
+      MIN_INT64_SIGNED = -2 << 62
+      MAX_INT64_SIGNED = (2 << 62) - 1
 
       # Checks the attributes hash to ensure it only contains serializable values.
       # Invalid values are removed from the hash.

data/lib/datadog/tracing/span_operation.rb

@@ -164,7 +164,9 @@ module Datadog
             # block is application code that we don't want to hinder.
             # * We don't yield during a fatal error, as the application is likely trying to
             #   end its execution (either due to a system error or graceful shutdown).
-            return_value = yield(self) unless e && !e.is_a?(StandardError)
+            # @type var e: Exception?
+            # Steep: https://github.com/soutaro/steep/issues/919
+            return_value = yield(self) unless e && !e.is_a?(StandardError) # steep:ignore FallbackAny
           end
         # rubocop:disable Lint/RescueException
         # Here we really want to catch *any* exception, not only StandardError,
@@ -214,9 +216,6 @@ module Datadog
       end
 
       # Mark the span stopped at the current time
-      #
-      # steep:ignore:start
-      # Steep issue fixed in https://github.com/soutaro/steep/pull/1467
       def stop(stop_time = nil, exception: nil)
         # A span should not be stopped twice. Note that this is not thread-safe,
         # stop is called from multiple threads, a given span might be stopped
@@ -239,7 +238,6 @@ module Datadog
 
         self
       end
-      # steep:ignore:end
 
       # Return whether the duration is started or not
       def started?
@@ -287,8 +285,14 @@ module Datadog
       end
 
       def duration
+        # Steep: https://github.com/soutaro/steep/issues/477
+        # @type ivar @duration_end: Time
+        # @type ivar @duration_start: Time
         return @duration_end - @duration_start if @duration_start && @duration_end
 
+        # Steep: https://github.com/soutaro/steep/issues/477
+        # @type ivar @end_time: Time
+        # @type ivar @start_time: Time
         @end_time - @start_time if @start_time && @end_time
       end
 
@@ -316,7 +320,9 @@ module Datadog
           'exception.stacktrace' => exc.backtrace,
         }
 
-        @span_events << SpanEvent.new('exception', attributes: event_attributes.merge!(attributes)) # steep:ignore
+        # Steep: Caused by wrong declaration, should be the same parameters as `merge`
+        # https://github.com/ruby/rbs/blob/3d0fb3a7fdde60af7120e875fe3bd7237b5b6a88/core/hash.rbs#L1468
+        @span_events << SpanEvent.new('exception', attributes: event_attributes.merge!(attributes)) # steep:ignore ArgumentTypeMismatch
       end
 
       # Return a string representation of the span.
@@ -387,7 +393,8 @@ module Datadog
       class Events
         include Tracing::Events
 
-        DEFAULT_ON_ERROR = proc { |span_op, error| span_op&.set_error(error) }
+        # Steep: https://github.com/soutaro/steep/issues/335
+        DEFAULT_ON_ERROR = proc { |span_op, error| span_op&.set_error(error) } # steep:ignore IncompatibleAssignment
 
         attr_reader \
           :logger,
@@ -395,7 +402,7 @@ module Datadog
           :after_stop,
           :before_start
 
-        def initialize(logger: Datadog.logger, on_error: nil)
+        def initialize(logger: Datadog.logger)
           @logger = logger
           @after_finish = AfterFinish.new
           @after_stop = AfterStop.new
@@ -464,7 +471,7 @@ module Datadog
               @handler.call(*args)
             rescue => e
               logger.debug do
-                "Error in on_error handler '#{@default}': #{e.class}: #{e} at #{Array(e.backtrace).first}"
+                "Error in on_error handler '#{@handler}': #{e.class}: #{e} at #{Array(e.backtrace).first}"
               end
             end
 
@@ -548,6 +555,10 @@ module Datadog
       # Used for serialization
       # @return [Integer] in nanoseconds since Epoch
       def start_time_nano
+        return 0 if @start_time.nil?
+
+        # Steep: https://github.com/soutaro/steep/issues/477
+        # @type ivar @start_time: Time
         @start_time.to_i * 1000000000 + @start_time.nsec
       end
 

data/lib/datadog/tracing/trace_operation.rb

@@ -55,6 +55,12 @@ module Datadog
         :sampled,
         :service
 
+      # Creates a new TraceOperation.
+      #
+      # @param auto_finish [Boolean] when true, automatically finishes the trace when the local root span finishes.
+      #   When false, the trace remains unfinished until {#finish!} is called.
+      #   This is useful when this {TraceOperation} represents the continuation of a remote {TraceDigest},
+      #   in which case local root spans in this {TraceOperation} are children of the {TraceDigest}'s last active span.
       def initialize(
         logger: Datadog.logger,
         agent_sample_rate: nil,
@@ -80,7 +86,8 @@ module Datadog
         trace_state_unknown_fields: nil,
         remote_parent: false,
         tracer: nil, # DEV-3.0: deprecated, remove in 3.0
-        baggage: nil
+        baggage: nil,
+        auto_finish: true
       )
         @logger = logger
 
@@ -119,6 +126,7 @@ module Datadog
         @events = events || Events.new
         @finished = false
         @spans = []
+        @auto_finish = !!auto_finish
       end
 
       def full?
@@ -318,6 +326,29 @@ module Datadog
         build_trace(spans, !finished)
       end
 
+      # When automatic context management is disabled (@auto_finish is false),
+      # this method finishes the trace, marking it as completed.
+      #
+      # The trace will **not** automatically finish when its local root span
+      # when @auto_finish is false, thus calling this method is mandatory
+      # in such scenario.
+      #
+      # Unfinished spans are discarded.
+      #
+      # This method is idempotent and safe to call after the trace is finished.
+      # It is also a no-op when @auto_finish is true, to prevent misuse.
+      #
+      # @!visibility private
+      def finish!
+        return if @auto_finish || finished?
+
+        @finished = true
+        @active_span = nil
+        @active_span_count = 0
+
+        events.trace_finished.publish(self)
+      end
+
       # Returns a set of trace headers used for continuing traces.
       # Used for propagation across execution contexts.
       # Data should reflect the active state of the trace.
@@ -460,7 +491,7 @@ module Datadog
 
         @active_span = span_op
 
-        set_root_span!(span_op) unless root_span
+        set_local_root_span!(span_op)
       end
 
       def deactivate_span!(span_op)
@@ -483,6 +514,12 @@ module Datadog
         logger.debug { "Error starting span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
       end
 
+      # For traces with automatic context management (auto_finish),
+      # when the local root span finishes, the trace also finishes.
+      # The trace cannot receive new spans after finished.
+      #
+      # Without auto_finish, the trace can still receive spans
+      # until explicitly finished.
       def finish_span(span, span_op, parent)
         # Save finished span & root span
         @spans << span unless span.nil?
@@ -490,8 +527,9 @@ module Datadog
         # Deactivate the span, re-activate parent.
         deactivate_span!(span_op)
 
-        # Set finished, to signal root span has completed.
-        @finished = true if span_op == root_span
+        # Finish if the local root span is finished and automatic
+        # context management is enabled.
+        @finished = true if span_op == root_span && @auto_finish
 
         # Update active span count
         @active_span_count -= 1
@@ -505,8 +543,8 @@ module Datadog
         logger.debug { "Error finishing span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
       end
 
-      # Track the root span
-      def set_root_span!(span)
+      # Track the root {SpanOperation} object from the current execution context.
+      def set_local_root_span!(span)
         return if span.nil? || root_span
 
         @root_span = span