datadog 2.21.0 → 2.38.0

data/lib/datadog/tracing/tracer.rb

@@ -129,7 +129,6 @@ module Datadog
       # @yield Optional block where new newly created {Datadog::Tracing::SpanOperation} captures the execution.
       # @yieldparam [Datadog::Tracing::SpanOperation] span_op the newly created and active [Datadog::Tracing::SpanOperation]
       # @yieldparam [Datadog::Tracing::TraceOperation] trace_op the active [Datadog::Tracing::TraceOperation]
-      # rubocop:disable Metrics/MethodLength
       def trace(
         name,
         continue_from: nil,
@@ -154,7 +153,7 @@ module Datadog
             active_trace
           end
         rescue => e
-          logger.debug { "Failed to trace: #{e}" }
+          logger.debug { "Failed to trace: #{e.class}: #{e.message}" }
 
           # Tracing failed: fallback and run code without tracing.
           return skip_trace(name, &block)
@@ -241,10 +240,21 @@ module Datadog
         trace.to_correlation
       end
 
-      # Setup a new trace to continue from where another
+      # Setup a new trace execution context to continue from where another
       # trace left off.
+      # This is useful to continue distributed or async traces.
       #
-      # Used to continue distributed or async traces.
+      # The first span created in the restored context is a direct child of the
+      # active span from when the {Datadog::Tracing::TraceDigest} was created.
+      #
+      # When no block is given, the trace context is restored in the current thread.
+      # It remains active until the first span created in this restored context is finished.
+      # After that, if a new span is created, it start a new, unrelated trace.
+      #
+      # When a block is given, the trace context is restored inside the block execution.
+      # It remains active until the block ends, even when the first span created inside
+      # the block finishes. This means that multiple spans can be direct children of the
+      # active span from when the {Datadog::Tracing::TraceDigest} was created.
       #
       # @param [Datadog::Tracing::TraceDigest] digest continue from the {Datadog::Tracing::TraceDigest}.
       # @param [Thread] key Thread to retrieve trace from. Defaults to current thread. For internal use only.
@@ -260,13 +270,32 @@ module Datadog
         # Start a new trace from the digest
         context = call_context(key)
         original_trace = active_trace(key)
-        trace = start_trace(continue_from: digest)
+        # When we want the trace to be bound to a block, we cannot let
+        # it auto finish when the local root span finishes. This would
+        # create mutiple traces inside the block. Instead, we'll
+        # expliclity finish the trace after the block finishes.
+        auto_finish = !block
+
+        trace = start_trace(continue_from: digest, auto_finish: auto_finish)
 
         # If block hasn't been given; we need to manually deactivate
         # this trace. Subscribe to the trace finished event to do this.
         subscribe_trace_deactivation!(context, trace, original_trace) unless block
 
-        context.activate!(trace, &block)
+        if block
+          # When a block is given, the trace will be active until the block finishes.
+          context.activate!(trace) do
+            yield
+          ensure # We have to flush even when an error occurs
+            # On block completion, force the trace to finish and flush its finished spans.
+            # Unfinished spans are lost as the {TraceOperation} has ended.
+            trace.finish!
+            flush_trace(trace)
+          end
+        else
+          # Otherwise, the trace will be bound to the current thread after this point
+          context.activate!(trace)
+        end
       end
 
       # Sample a span, tagging the trace as appropriate.
@@ -274,7 +303,20 @@ module Datadog
         @sampler.sample!(trace_op) if trace_op.sampling_priority.nil?
       rescue => e
         SAMPLE_TRACE_LOG_ONLY_ONCE.run do
-          logger.warn { "Failed to sample trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+          logger.warn { "Failed to sample trace: #{e.class}: #{e.message} at #{Array(e.backtrace).first}" }
+        end
+      end
+
+      def reconsider_trace_sampling_on_resource(trace_op)
+        return unless trace_op.reconsider_resource_sample?
+        return unless @sampler.respond_to?(:reconsider_sample_resource!)
+
+        @sampler.reconsider_sample_resource!(trace_op)
+      rescue => e
+        RECONSIDER_RESOURCE_SAMPLE_TRACE_LOG_ONLY_ONCE.run do
+          logger.warn do
+            "Failed to reconsider trace sampling: #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
+          end
         end
       end
 
@@ -329,10 +371,8 @@ module Datadog
         @provider.context(key)
       end
 
-      def build_trace(digest = nil)
-        # Resolve hostname if configured
-        hostname = Core::Environment::Socket.hostname if Datadog.configuration.tracing.report_hostname
-        hostname = (hostname && !hostname.empty?) ? hostname : nil
+      def build_trace(digest, auto_finish)
+        hostname = Core::Environment::Socket.resolved_hostname(Datadog.configuration)
 
         if digest
           sampling_priority = if propagate_sampling_priority?(upstream_tags: digest.trace_distributed_tags)
@@ -347,13 +387,15 @@ module Datadog
             origin: digest.trace_origin,
             parent_span_id: digest.span_id,
             sampling_priority: sampling_priority,
+            span_links: digest.span_links,
             # Distributed tags are just regular trace tags with special meaning to Datadog
             tags: digest.trace_distributed_tags,
             trace_state: digest.trace_state,
             trace_state_unknown_fields: digest.trace_state_unknown_fields,
             remote_parent: digest.span_remote,
             tracer: self,
-            baggage: digest.baggage
+            baggage: digest.baggage,
+            auto_finish: auto_finish
           )
         else
           TraceOperation.new(
@@ -362,13 +404,12 @@ module Datadog
             profiling_enabled: profiling_enabled,
             apm_tracing_enabled: apm_tracing_enabled,
             remote_parent: false,
-            tracer: self
+            tracer: self,
+            auto_finish: auto_finish
           )
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
-      # rubocop:disable Metrics/MethodLength
       def bind_trace_events!(trace_op)
         events = trace_op.send(:events)
 
@@ -377,6 +418,15 @@ module Datadog
           event_span_op.service ||= @default_service
         end
 
+        events.span_before_finish.subscribe do |event_span_op, _event_trace_op|
+          if event_span_op.service && event_span_op.service != @default_service
+            event_span_op.set_tag(Tracing::Metadata::Ext::TAG_BASE_SERVICE, @default_service)
+            event_span_op.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Tracing::Metadata::Ext::SVC_SRC_MANUAL) unless event_span_op.get_tag(Tracing::Metadata::Ext::TAG_SVC_SRC)
+          else
+            event_span_op.send(:meta).delete(Tracing::Metadata::Ext::TAG_SVC_SRC)
+          end
+        end
+
         events.trace_propagated.subscribe do |event_trace_op|
           sample_trace(event_trace_op)
         end
@@ -386,14 +436,22 @@ module Datadog
           sample_span(event_trace_op, event_span)
           flush_trace(event_trace_op)
         end
+
+        # Conditionally subscribe to the less common sampling rules below, to avoid
+        # measurable unnecessary performance overhead when they are not present.
+
+        if @sampler.respond_to?(:resource_sampling?) && @sampler.resource_sampling?
+          events.trace_resource_change.subscribe do |event_trace_op|
+            reconsider_trace_sampling_on_resource(event_trace_op)
+          end
+        end
       end
-      # rubocop:enable Metrics/MethodLength
 
       # Creates a new TraceOperation, with events bounds to this Tracer instance.
       # @return [TraceOperation]
-      def start_trace(continue_from: nil)
+      def start_trace(continue_from: nil, auto_finish: true)
         # Build a new trace using digest if provided.
-        trace = build_trace(continue_from)
+        trace = build_trace(continue_from, auto_finish)
 
         # Bind trace events: sample trace, set default service, flush spans.
         bind_trace_events!(trace)
@@ -402,7 +460,6 @@ module Datadog
       end
 
       # rubocop:disable Lint/UnderscorePrefixedVariableName
-      # rubocop:disable Metrics/MethodLength
       def start_span(
         name,
         continue_from: nil,
@@ -454,9 +511,8 @@ module Datadog
           span
         end
       end
-      # rubocop:enable Lint/UnderscorePrefixedVariableName
-      # rubocop:enable Metrics/MethodLength
 
+      # rubocop:enable Lint/UnderscorePrefixedVariableName
       def resolve_tags(tags, service)
         merged_tags = if @tags.any? && tags
           # Combine default tags with provided tags,
@@ -508,11 +564,14 @@ module Datadog
       SAMPLE_TRACE_LOG_ONLY_ONCE = Core::Utils::OnlyOnce.new
       private_constant :SAMPLE_TRACE_LOG_ONLY_ONCE
 
+      RECONSIDER_RESOURCE_SAMPLE_TRACE_LOG_ONLY_ONCE = Core::Utils::OnlyOnce.new
+      private_constant :RECONSIDER_RESOURCE_SAMPLE_TRACE_LOG_ONLY_ONCE
+
       def sample_span(trace_op, span)
         @span_sampler.sample!(trace_op, span)
       rescue => e
         SAMPLE_SPAN_LOG_ONLY_ONCE.run do
-          logger.warn { "Failed to sample span: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+          logger.warn { "Failed to sample span: #{e.class}: #{e.message} at #{Array(e.backtrace).first}" }
         end
       end
 
@@ -525,7 +584,7 @@ module Datadog
         write(trace) if trace && !trace.empty?
       rescue => e
         FLUSH_TRACE_LOG_ONLY_ONCE.run do
-          logger.warn { "Failed to flush trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+          logger.warn { "Failed to flush trace: #{e.class}: #{e.message} at #{Array(e.backtrace).first}" }
         end
       end
 

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

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

@@ -2,12 +2,10 @@
 
 require 'json'
 
-require_relative '../traces'
-require_relative 'client'
 require_relative '../../../core/transport/http/response'
 require_relative '../../../core/transport/http/api/endpoint'
-require_relative '../../../core/transport/http/api/spec'
 require_relative '../../../core/transport/http/api/instance'
+require_relative '../traces'
 
 module Datadog
   module Tracing
@@ -27,58 +25,15 @@ module Datadog
             end
           end
 
-          # Extensions for HTTP client
-          module Client
-            def send_traces_payload(request)
-              send_request(request) do |api, env|
-                api.send_traces(env)
-              end
-            end
-          end
-
           module API
-            # HTTP API Spec
-            class Spec < Core::Transport::HTTP::API::Spec
-              attr_accessor :traces
-
-              def send_traces(env, &block)
-                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('traces', self) if traces.nil?
-
-                traces.call(env, &block)
-              end
-
-              def encoder
-                traces.encoder
-              end
-            end
-
-            # HTTP API Instance
-            class Instance < Core::Transport::HTTP::API::Instance
-              def send_traces(env)
-                unless spec.is_a?(Traces::API::Spec)
-                  raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new(
-                    'traces', self
-                  )
-                end
-
-                spec.send_traces(env) do |request_env|
-                  call(request_env)
-                end
-              end
-            end
-
             # Endpoint for submitting trace data
             class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
               HEADER_CONTENT_TYPE = 'Content-Type'
               HEADER_TRACE_COUNT = 'X-Datadog-Trace-Count'
               SERVICE_RATE_KEY = 'rate_by_service'
 
-              attr_reader \
-                :encoder
-
               def initialize(path, encoder, options = {})
-                super(:post, path)
-                @encoder = encoder
+                super(:post, path, encoder: encoder)
                 @service_rates = options.fetch(:service_rates, false)
               end
 
@@ -111,9 +66,6 @@ module Datadog
               end
             end
           end
-
-          # Add traces behavior to transport components
-          HTTP::Client.include(Traces::Client)
         end
       end
     end

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

@@ -1,17 +1,28 @@
 # frozen_string_literal: true
 
+require_relative '../../core/encoding'
 require_relative '../../core/environment/container'
 require_relative '../../core/environment/ext'
 require_relative '../../core/transport/ext'
 require_relative '../../core/transport/http'
-require_relative 'http/api'
-require_relative '../../../datadog/version'
+require_relative 'http/traces'
 
 module Datadog
   module Tracing
     module Transport
       # Namespace for HTTP transport components
       module HTTP
+        V4 = Traces::API::Endpoint.new(
+          '/v0.4/traces',
+          Core::Encoding::MsgpackEncoder,
+          service_rates: true
+        )
+
+        V3 = Traces::API::Endpoint.new(
+          '/v0.3/traces',
+          Core::Encoding::MsgpackEncoder,
+        )
+
         module_function
 
         # Builds a new Transport::HTTP::Client with default settings
@@ -19,20 +30,15 @@ module Datadog
         def default(
           agent_settings:,
           logger: Datadog.logger,
-          api_version: nil,
           headers: nil
         )
           Core::Transport::HTTP.build(
-            api_instance_class: Traces::API::Instance,
             agent_settings: agent_settings,
             logger: logger,
-            api_version: api_version,
             headers: headers
           ) do |transport|
-            apis = API.defaults
-
-            transport.api API::V4, apis[API::V4], fallback: API::V3, default: true
-            transport.api API::V3, apis[API::V3]
+            transport.api 'v0.4', V4, fallback: 'v0.3', default: true
+            transport.api 'v0.3', V3
 
             # Call block to apply any customization, if provided
             yield(transport) if block_given?

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

@@ -19,8 +19,11 @@ module Datadog
             @out = out
             @encoder = encoder
 
+            # Note: The :encode option was previously supported but is no longer used.
+            # Data is now expected to be pre-encoded in the Parcel before reaching this client,
+            # matching the behavior of other transports (e.g., HTTP transport).
+            # If provided, the :encode option will be silently ignored for backwards compatibility.
             @request_block = options.fetch(:request, method(:send_default_request))
-            @encode_block = options.fetch(:encode, method(:encode_data))
             @write_block = options.fetch(:write, method(:write_data))
             @response_block = options.fetch(:response, method(:build_response))
           end
@@ -38,11 +41,10 @@ module Datadog
             # Update statistics
             update_stats_from_response!(response)
 
-            # Return response
             response
           rescue => e
             message =
-              "Internal error during IO transport request. Cause: #{e.class.name} #{e.message} " \
+              "Internal error during IO transport request. Cause: #{e.class}: #{e.message} " \
                 "Location: #{Array(e.backtrace).first}"
 
             # Log error
@@ -59,10 +61,6 @@ module Datadog
             InternalErrorResponse.new(e)
           end
 
-          def encode_data(encoder, request)
-            request.parcel.encode_with(encoder)
-          end
-
           def write_data(out, data)
             out.puts(data)
           end
@@ -74,8 +72,7 @@ module Datadog
           private
 
           def send_default_request(out, request)
-            # Encode data
-            data = @encode_block.call(encoder, request)
+            data = request.parcel.data
 
             # Write to IO
             result = @write_block.call(out, data)

data/lib/datadog/tracing/transport/io/traces.rb

@@ -21,29 +21,6 @@ module Datadog
             end
           end
 
-          # Extensions for HTTP client
-          module Client
-            def send_traces(traces)
-              # Build a request
-              req = Transport::Traces::Request.new(Parcel.new(traces))
-
-              [send_request(req) do |out, request|
-                # Encode trace data
-                data = encode_data(encoder, request)
-
-                # Write to IO
-                result = if block_given?
-                  yield(out, data)
-                else
-                  write_data(out, data)
-                end
-
-                # Generate response
-                Traces::Response.new(result)
-              end]
-            end
-          end
-
           # Encoder for IO-specific trace encoding
           # API compliant when used with {JSONEncoder}.
           module Encoder
@@ -54,13 +31,13 @@ module Datadog
             ].freeze
 
             # Encodes a list of traces
-            def encode_traces(encoder, traces)
+            def encode_traces(traces)
               trace_hashes = traces.map do |trace|
                 encode_trace(trace)
               end
 
-              # Wrap traces & encode them
-              encoder.encode(traces: trace_hashes)
+              # Wrap traces
+              {traces: trace_hashes}
             end
 
             private
@@ -78,17 +55,34 @@ module Datadog
             end
           end
 
-          # Transfer object for list of traces
-          class Parcel
-            include Datadog::Core::Transport::Parcel
+          # Extensions for HTTP client
+          module Client
             include Encoder
 
-            def count
-              data.length
-            end
+            def send_traces(traces)
+              # Build a request
+              encoded_traces = encode_traces(traces)
+              encoder = Core::Encoding::JSONEncoder
+              parcel = Core::Transport::Parcel.new(
+                encoder.encode(encoded_traces),
+                content_type: encoder.content_type,
+              )
+              req = Transport::Traces::Request.new(parcel)
+
+              [send_request(req) do |out, request|
+                # Get already-encoded data from parcel
+                data = request.parcel.data
+
+                # Write to IO
+                result = if block_given?
+                  yield(out, data)
+                else
+                  write_data(out, data)
+                end
 
-            def encode_with(encoder)
-              encode_traces(encoder, data)
+                # Generate response
+                Traces::Response.new(result)
+              end]
             end
           end
 

data/lib/datadog/tracing/transport/trace_formatter.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../../core/environment/identity'
+require_relative '../../core/environment/process'
 require_relative '../../core/environment/socket'
 require_relative '../../core/environment/git'
 require_relative '../../core/git/ext'
@@ -48,6 +49,7 @@ module Datadog
 
           tag_agent_sample_rate!
           tag_hostname!
+          tag_knuth_sampling_rate!
           tag_lang!
           tag_origin!
           tag_process_id!
@@ -62,6 +64,7 @@ module Datadog
           tag_apm_tracing_disabled!
 
           if first_span
+            tag_process_tags!
             tag_git_repository_url!
             tag_git_commit_sha!
           end
@@ -108,6 +111,16 @@ module Datadog
           )
         end
 
+        def tag_knuth_sampling_rate!
+          rate = trace.rule_sample_rate || trace.agent_sample_rate
+          return unless rate
+
+          root_span.set_tag(
+            Tracing::Metadata::Ext::Distributed::TAG_KNUTH_SAMPLING_RATE,
+            format('%.6f', (rate * 1e6).round / 1e6).sub(/\.?0+\z/, '')
+          )
+        end
+
         def tag_lang!
           return if trace.lang.nil?
 
@@ -215,6 +228,15 @@ module Datadog
           first_span.set_tag(Core::Git::Ext::TAG_COMMIT_SHA, git_commit_sha)
         end
 
+        def tag_process_tags!
+          return unless Datadog.configuration.experimental_propagate_process_tags_enabled
+
+          first_span.set_tag(
+            Core::Environment::Ext::TAG_PROCESS_TAGS,
+            Core::Environment::Process.serialized
+          )
+        end
+
         private
 
         def partial?