datadog 2.12.0 → 2.22.0

data/lib/datadog/tracing/tracer.rb

@@ -49,6 +49,8 @@ module Datadog
       # @param tags [Hash] default tags added to all spans
       # @param writer [Datadog::Tracing::Writer] consumes traces returned by the provided +trace_flush+
       def initialize(
+        # rubocop:disable Style/KeywordParametersOrder
+        # https://github.com/rubocop/rubocop/issues/13933
         trace_flush: Flush::Finished.new,
         context_provider: DefaultContextProvider.new,
         default_service: Core::Environment::Ext::FALLBACK_SERVICE_NAME,
@@ -60,7 +62,10 @@ module Datadog
         ),
         span_sampler: Sampling::Span::Sampler.new,
         tags: {},
-        writer: Writer.new(logger: logger)
+        # writer is not defaulted because creating it requires agent_settings,
+        # which we do not have here and otherwise do not need.
+        writer:
+        # rubocop:enable Style/KeywordParametersOrder
       )
         @trace_flush = trace_flush
         @default_service = default_service
@@ -144,11 +149,11 @@ 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
+            start_trace(continue_from: continue_from)
+          else
+            active_trace
+          end
+        rescue => e
           logger.debug { "Failed to trace: #{e}" }
 
           # Tracing failed: fallback and run code without tracing.
@@ -189,7 +194,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.
@@ -220,7 +224,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.
@@ -267,12 +271,10 @@ module Datadog
 
       # 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}" }
-          end
+        @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}" }
         end
       end
 
@@ -292,7 +294,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
@@ -310,7 +312,7 @@ module Datadog
       def shutdown!
         return unless @enabled
 
-        @writer.stop if @writer
+        @writer&.stop
       end
 
       private
@@ -330,33 +332,43 @@ module Datadog
       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
+        hostname = (hostname && !hostname.empty?) ? hostname : nil
 
         if digest
+          sampling_priority = if propagate_sampling_priority?(upstream_tags: digest.trace_distributed_tags)
+            digest.trace_sampling_priority
+          end
           TraceOperation.new(
+            logger: logger,
             hostname: hostname,
             profiling_enabled: profiling_enabled,
+            apm_tracing_enabled: apm_tracing_enabled,
             id: digest.trace_id,
             origin: digest.trace_origin,
             parent_span_id: digest.span_id,
-            sampling_priority: digest.trace_sampling_priority,
+            sampling_priority: sampling_priority,
             # 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
+            tracer: self,
+            baggage: digest.baggage
           )
         else
           TraceOperation.new(
+            logger: logger,
             hostname: hostname,
             profiling_enabled: profiling_enabled,
+            apm_tracing_enabled: apm_tracing_enabled,
             remote_parent: false,
             tracer: self
           )
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
+      # rubocop:disable Metrics/MethodLength
       def bind_trace_events!(trace_op)
         events = trace_op.send(:events)
 
@@ -365,11 +377,17 @@ module Datadog
           event_span_op.service ||= @default_service
         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
       end
+      # rubocop:enable Metrics/MethodLength
 
       # Creates a new TraceOperation, with events bounds to this Tracer instance.
       # @return [TraceOperation]
@@ -384,6 +402,7 @@ module Datadog
       end
 
       # rubocop:disable Lint/UnderscorePrefixedVariableName
+      # rubocop:disable Metrics/MethodLength
       def start_span(
         name,
         continue_from: nil,
@@ -399,12 +418,13 @@ module Datadog
       )
         trace = _trace || start_trace(continue_from: continue_from)
 
-        events = SpanOperation::Events.new
+        events = SpanOperation::Events.new(logger: logger)
 
         if block
           # Ignore start time if a block has been given
           trace.measure(
             name,
+            logger: logger,
             events: events,
             on_error: on_error,
             resource: resource,
@@ -418,6 +438,7 @@ module Datadog
           # Return the new span
           span = trace.build_span(
             name,
+            logger: logger,
             events: events,
             on_error: on_error,
             resource: resource,
@@ -434,16 +455,17 @@ module Datadog
         end
       end
       # rubocop:enable Lint/UnderscorePrefixedVariableName
+      # rubocop:enable Metrics/MethodLength
 
       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)
@@ -487,12 +509,10 @@ module Datadog
       private_constant :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.name} #{e} at #{Array(e.backtrace).first}" }
         end
       end
 
@@ -501,14 +521,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.name} #{e} at #{Array(e.backtrace).first}" }
         end
       end
 
@@ -530,20 +547,50 @@ module Datadog
 
       # TODO: Make these dummy objects singletons to preserve memory.
       def skip_trace(name)
-        span = SpanOperation.new(name)
+        span = SpanOperation.new(name, logger: logger)
 
         if block_given?
-          trace = TraceOperation.new
+          trace = TraceOperation.new(logger: logger)
           yield(span, trace)
         else
           span
         end
       end
 
+      # Decide whether upstream sampling priority should be propagated, by taking into account
+      # the upstream tags and the configuration.
+      # We should always propagate if APM is enabled.
+      #
+      # e.g.: upstream tags containing dd.p.ts: 02, and appsec is enabled, return true.
+      def propagate_sampling_priority?(upstream_tags:)
+        return true if apm_tracing_enabled
+
+        if upstream_tags&.key?(Tracing::Metadata::Ext::Distributed::TAG_TRACE_SOURCE)
+          appsec_bit = upstream_tags[Tracing::Metadata::Ext::Distributed::TAG_TRACE_SOURCE].to_i(16) &
+            Datadog::AppSec::Ext::PRODUCT_BIT
+          return appsec_enabled if appsec_bit != 0
+        end
+
+        false
+      end
+
       def profiling_enabled
         @profiling_enabled ||=
           !!(defined?(Datadog::Profiling) && Datadog::Profiling.respond_to?(:enabled?) && Datadog::Profiling.enabled?)
       end
+
+      def appsec_enabled
+        @appsec_enabled ||= Datadog.configuration.appsec.enabled
+      end
+
+      # Due to APM Tracing (the product) and Tracing (the transport) being intertwined, we cannot completely disabled APM
+      # without also disabling the tracer. When setting `@apm_tracing_enabled` to `false`, it does not disable the tracer,
+      # but rather only sends heartbeat traces (1 per minutes), so that the service is considered alive in the backend.
+      # Other products (like ASM) can then set the sampling priority of their traces to `MANUAL_KEEP`,
+      # effectively allowing standalone products to work without APM.
+      def apm_tracing_enabled
+        @apm_tracing_enabled ||= Datadog.configuration.apm.tracing.enabled
+      end
     end
   end
 end

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

@@ -22,14 +22,14 @@ module Datadog
 
           def defaults
             Core::Transport::HTTP::API::Map[
-              V4 => Spec.new do |s|
+              V4 => Traces::API::Spec.new do |s|
                 s.traces = Traces::API::Endpoint.new(
                   '/v0.4/traces',
                   Core::Encoding::MsgpackEncoder,
                   service_rates: true
                 )
               end,
-              V3 => Spec.new do |s|
+              V3 => Traces::API::Spec.new do |s|
                 s.traces = Traces::API::Endpoint.new(
                   '/v0.3/traces',
                   Core::Encoding::MsgpackEncoder
@@ -37,14 +37,6 @@ module Datadog
               end,
             ].with_fallbacks(V4 => V3)
           end
-
-          class Instance < Core::Transport::HTTP::API::Instance
-            include Traces::API::Instance
-          end
-
-          class Spec < Core::Transport::HTTP::API::Spec
-            include Traces::API::Spec
-          end
         end
       end
     end

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

@@ -12,10 +12,11 @@ module Datadog
         class Client
           include Datadog::Tracing::Transport::HTTP::Statistics
 
-          attr_reader :api
+          attr_reader :api, :logger
 
-          def initialize(api)
+          def initialize(api, logger: Datadog.logger)
             @api = api
+            @logger = logger
           end
 
           def send_request(request, &block)
@@ -29,17 +30,17 @@ module Datadog
             update_stats_from_response!(response)
 
             response
-          rescue StandardError => e
+          rescue => e
             message =
               "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
                 "Location: #{Array(e.backtrace).first}"
 
             # Log error
             if stats.consecutive_errors > 0
-              Datadog.logger.debug(message)
+              logger.debug(message)
             else
               # Not to report telemetry logs
-              Datadog.logger.error(message)
+              logger.error(message)
             end
 
             # Update statistics

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

@@ -6,6 +6,8 @@ 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'
 
 module Datadog
   module Tracing
@@ -35,16 +37,12 @@ module Datadog
           end
 
           module API
-            # Extensions for HTTP API Spec
-            module Spec
-              attr_reader :traces
-
-              def traces=(endpoint)
-                @traces = endpoint
-              end
+            # HTTP API Spec
+            class Spec < Core::Transport::HTTP::API::Spec
+              attr_accessor :traces
 
               def send_traces(env, &block)
-                raise NoTraceEndpointDefinedError, self if traces.nil?
+                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('traces', self) if traces.nil?
 
                 traces.call(env, &block)
               end
@@ -52,47 +50,21 @@ module Datadog
               def encoder
                 traces.encoder
               end
-
-              # Raised when traces sent but no traces endpoint is defined
-              class NoTraceEndpointDefinedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super
-
-                  @spec = spec
-                end
-
-                def message
-                  'No trace endpoint is defined for API specification!'
-                end
-              end
             end
 
-            # Extensions for HTTP API Instance
-            module Instance
+            # HTTP API Instance
+            class Instance < Core::Transport::HTTP::API::Instance
               def send_traces(env)
-                raise TracesNotSupportedError, spec unless spec.is_a?(Traces::API::Spec)
+                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
-
-              # Raised when traces sent to API that does not support traces
-              class TracesNotSupportedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super
-
-                  @spec = spec
-                end
-
-                def message
-                  'Traces not supported for this API!'
-                end
-              end
             end
 
             # Endpoint for submitting trace data
@@ -123,10 +95,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)

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

@@ -1,14 +1,9 @@
 # frozen_string_literal: true
 
-require 'uri'
-
 require_relative '../../core/environment/container'
 require_relative '../../core/environment/ext'
 require_relative '../../core/transport/ext'
-require_relative '../../core/transport/http/adapters/net'
-require_relative '../../core/transport/http/adapters/test'
-require_relative '../../core/transport/http/adapters/unix_socket'
-require_relative '../../core/transport/http/builder'
+require_relative '../../core/transport/http'
 require_relative 'http/api'
 require_relative '../../../datadog/version'
 
@@ -17,89 +12,32 @@ module Datadog
     module Transport
       # Namespace for HTTP transport components
       module HTTP
-        # NOTE: Due to... legacy reasons... This class likes having a default `AgentSettings` instance to fall back to.
-        # Because we generate this instance with an empty instance of `Settings`, the resulting `AgentSettings` below
-        # represents only settings specified via environment variables + the usual defaults.
-        #
-        # DO NOT USE THIS IN NEW CODE, as it ignores any settings specified by users via `Datadog.configure`.
-        DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS = Datadog::Core::Configuration::AgentSettingsResolver.call(
-          Datadog::Core::Configuration::Settings.new,
-          logger: nil,
-        )
-
         module_function
 
-        # Builds a new Transport::HTTP::Client
-        def new(klass, &block)
-          Core::Transport::HTTP::Builder.new(
-            api_instance_class: API::Instance, &block
-          ).to_transport(klass)
-        end
-
         # Builds a new Transport::HTTP::Client with default settings
         # Pass a block to override any settings.
         def default(
-          agent_settings: DO_NOT_USE_ENVIRONMENT_AGENT_SETTINGS,
-          **options
+          agent_settings:,
+          logger: Datadog.logger,
+          api_version: nil,
+          headers: nil
         )
-          new(Transport::Traces::Transport) do |transport|
-            transport.adapter(agent_settings)
-            transport.headers default_headers
-
+          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]
 
-            # Apply any settings given by options
-            unless options.empty?
-              transport.default_api = options[:api_version] if options.key?(:api_version)
-              transport.headers options[:headers] if options.key?(:headers)
-            end
-
             # Call block to apply any customization, if provided
             yield(transport) if block_given?
-          end
+          end.to_transport(Transport::Traces::Transport)
         end
-
-        def default_headers
-          {
-            Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_TOP_LEVEL => '1',
-            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG => Datadog::Core::Environment::Ext::LANG,
-            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_VERSION => Datadog::Core::Environment::Ext::LANG_VERSION,
-            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER =>
-              Datadog::Core::Environment::Ext::LANG_INTERPRETER,
-            Datadog::Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER_VENDOR => Core::Environment::Ext::LANG_ENGINE,
-            Datadog::Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION =>
-              Datadog::Core::Environment::Ext::GEM_DATADOG_VERSION
-          }.tap do |headers|
-            # Add container ID, if present.
-            container_id = Datadog::Core::Environment::Container.container_id
-            headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
-            # Pretend that stats computation are already done by the client
-            if Datadog.configuration.appsec.standalone.enabled
-              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_STATS] = 'yes'
-            end
-          end
-        end
-
-        def default_adapter
-          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-        end
-
-        # Add adapters to registry
-        Core::Transport::HTTP::Builder::REGISTRY.set(
-          Datadog::Core::Transport::HTTP::Adapters::Net,
-          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-        )
-        Core::Transport::HTTP::Builder::REGISTRY.set(
-          Datadog::Core::Transport::HTTP::Adapters::Test,
-          Datadog::Core::Transport::Ext::Test::ADAPTER
-        )
-        Core::Transport::HTTP::Builder::REGISTRY.set(
-          Datadog::Core::Transport::HTTP::Adapters::UnixSocket,
-          Datadog::Core::Transport::Ext::UnixSocket::ADAPTER
-        )
       end
     end
   end

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

@@ -30,17 +30,17 @@ 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} " \
                 "Location: #{Array(e.backtrace).first}"

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

@@ -33,10 +33,10 @@ module Datadog
 
                 # Write to IO
                 result = if block_given?
-                           yield(out, data)
-                         else
-                           write_data(out, data)
-                         end
+                  yield(out, data)
+                else
+                  write_data(out, data)
+                end
 
                 # Generate response
                 Traces::Response.new(result)

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

@@ -69,7 +69,7 @@ module Datadog
         def to_msgpack(packer = nil)
           packer ||= MessagePack::Packer.new
 
-          number_of_elements_to_write = 11
+          number_of_elements_to_write = 12
 
           number_of_elements_to_write += 1 if span.events.any? && @native_events_supported
 
@@ -117,6 +117,8 @@ module Datadog
           packer.write(span.meta)
           packer.write('metrics')
           packer.write(span.metrics)
+          packer.write('meta_struct')
+          packer.write(span.metastruct)
           packer.write('span_links')
           packer.write(span.links.map(&:to_hash))
           packer.write('error')

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

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

@@ -59,6 +59,7 @@ module Datadog
           tag_high_order_trace_id!
           tag_sampling_priority!
           tag_profiling_enabled!
+          tag_apm_tracing_disabled!
 
           if first_span
             tag_git_repository_url!
@@ -196,6 +197,12 @@ module Datadog
           )
         end
 
+        def tag_apm_tracing_disabled!
+          return if trace.apm_tracing_enabled
+
+          root_span.set_tag(Tracing::Metadata::Ext::TAG_APM_ENABLED, 0)
+        end
+
         def tag_git_repository_url!
           return if git_repository_url.nil?