datadog 2.17.0 → 2.37.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,
@@ -149,12 +148,12 @@ module Datadog
           context = call_context
           active_trace = context.active_trace
           trace = if continue_from || active_trace.nil?
-                    start_trace(continue_from: continue_from)
-                  else
-                    active_trace
-                  end
-        rescue StandardError => e
-          logger.debug { "Failed to trace: #{e}" }
+            start_trace(continue_from: continue_from)
+          else
+            active_trace
+          end
+        rescue => e
+          logger.debug { "Failed to trace: #{e.class}: #{e.message}" }
 
           # Tracing failed: fallback and run code without tracing.
           return skip_trace(name, &block)
@@ -194,7 +193,6 @@ module Datadog
           )
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
       # Set the given key / value tag pair at the tracer level. These tags will be
       # appended to each span created by the tracer. Keys and values must be strings.
@@ -225,7 +223,7 @@ module Datadog
       # @return [nil] if no trace is active, and thus no span is active
       def active_span(key = nil)
         trace = active_trace(key)
-        trace.active_span if trace
+        trace&.active_span
       end
 
       # Information about the currently active trace.
@@ -242,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.
+      #
+      # 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.
       #
-      # Used to continue distributed or async traces.
+      # 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.
@@ -261,22 +270,52 @@ 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.
       def sample_trace(trace_op)
-        begin
-          @sampler.sample!(trace_op)
-        rescue StandardError => e
-          SAMPLE_TRACE_LOG_ONLY_ONCE.run do
-            logger.warn { "Failed to sample trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
+        @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}: #{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
@@ -297,7 +336,7 @@ module Datadog
         #       description of and constraints on arguments.
         # rubocop:disable Lint/UselessMethodDefinition
         def publish(trace)
-          super(trace)
+          super
         end
         # rubocop:enable Lint/UselessMethodDefinition
       end
@@ -315,7 +354,7 @@ module Datadog
       def shutdown!
         return unless @enabled
 
-        @writer.stop if @writer
+        @writer&.stop
       end
 
       private
@@ -332,15 +371,13 @@ 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)
-                                digest.trace_sampling_priority
-                              end
+            digest.trace_sampling_priority
+          end
           TraceOperation.new(
             logger: logger,
             hostname: hostname,
@@ -350,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(
@@ -365,7 +404,8 @@ 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
@@ -378,17 +418,40 @@ 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
+
         events.span_finished.subscribe do |event_span, event_trace_op|
+          sample_trace(trace_op) if event_trace_op.sampling_priority.nil?
           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
 
       # 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)
@@ -448,17 +511,17 @@ module Datadog
           span
         end
       end
-      # rubocop:enable Lint/UnderscorePrefixedVariableName
 
+      # rubocop:enable Lint/UnderscorePrefixedVariableName
       def resolve_tags(tags, service)
         merged_tags = if @tags.any? && tags
-                        # Combine default tags with provided tags,
-                        # preferring provided tags.
-                        @tags.merge(tags)
-                      else
-                        # Use provided tags or default tags if none.
-                        tags || @tags.dup
-                      end
+          # Combine default tags with provided tags,
+          # preferring provided tags.
+          @tags.merge(tags)
+        else
+          # Use provided tags or default tags if none.
+          tags || @tags.dup
+        end
         # Remove version tag if service is not the default service
         if merged_tags.key?(Core::Environment::Ext::TAG_VERSION) && service && service != @default_service
           merged_tags.delete(Core::Environment::Ext::TAG_VERSION)
@@ -501,13 +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)
-        begin
-          @span_sampler.sample!(trace_op, span)
-        rescue StandardError => e
-          SAMPLE_SPAN_LOG_ONLY_ONCE.run do
-            logger.warn { "Failed to sample span: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
-          end
+        @span_sampler.sample!(trace_op, span)
+      rescue => e
+        SAMPLE_SPAN_LOG_ONLY_ONCE.run do
+          logger.warn { "Failed to sample span: #{e.class}: #{e.message} at #{Array(e.backtrace).first}" }
         end
       end
 
@@ -516,14 +580,11 @@ module Datadog
 
       # Flush finished spans from the trace buffer, send them to writer.
       def flush_trace(trace_op)
-        sample_trace(trace_op) unless trace_op.sampling_priority
-        begin
-          trace = @trace_flush.consume!(trace_op)
-          write(trace) if trace && !trace.empty?
-        rescue StandardError => e
-          FLUSH_TRACE_LOG_ONLY_ONCE.run do
-            logger.warn { "Failed to flush trace: #{e.class.name} #{e} at #{Array(e.backtrace).first}" }
-          end
+        trace = @trace_flush.consume!(trace_op)
+        write(trace) if trace && !trace.empty?
+      rescue => e
+        FLUSH_TRACE_LOG_ONLY_ONCE.run do
+          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 StandardError => 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
 
@@ -95,10 +50,10 @@ module Datadog
                 env.body = env.request.parcel.data
 
                 # Query for response
-                http_response = super(env, &block)
+                http_response = super
 
                 # Process the response
-                response_options = { trace_count: env.request.parcel.trace_count }.tap do |options|
+                response_options = {trace_count: env.request.parcel.trace_count}.tap do |options|
                   # Parse service rates, if configured to do so.
                   if service_rates? && !http_response.payload.to_s.empty?
                     body = JSON.parse(http_response.payload)
@@ -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
@@ -30,19 +33,18 @@ module Datadog
             # If block is given, allow it to handle writing
             # Otherwise do a standard encode/write/response.
             response = if block_given?
-                         yield(out, request)
-                       else
-                         @request_block.call(out, request)
-                       end
+              yield(out, request)
+            else
+              @request_block.call(out, request)
+            end
 
             # Update statistics
             update_stats_from_response!(response)
 
-            # Return response
             response
-          rescue StandardError => e
+          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
 
-            def encode_with(encoder)
-              encode_traces(encoder, data)
+                # 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
 

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

@@ -47,7 +47,7 @@ module Datadog
         end
 
         def metrics_for_exception(_exception)
-          { api_errors: Core::Metrics::Metric.new(:api_errors, nil, 1) }
+          {api_errors: Core::Metrics::Metric.new(:api_errors, nil, 1)}
         end
 
         # Stat counts