ddtrace 1.4.2 → 1.23.3

data/lib/datadog/tracing/flush.rb

@@ -1,73 +1,95 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
     module Flush
-      # Consumes only completed traces (where all spans have finished)
-      class Finished
-        # Consumes and returns completed traces (where all spans have finished)
-        # from the provided \trace_op, if any.
+      # Consumes and returns a {TraceSegment} to be flushed, from
+      # the provided {TraceSegment}.
+      #
+      # Only finished spans are consumed. Any spans consumed are
+      # removed from +trace_op+ as a side effect. Unfinished spans are
+      # unaffected.
+      #
+      # @abstract
+      class Base
+        # Consumes and returns a {TraceSegment} to be flushed, from
+        # the provided {TraceSegment}.
         #
-        # Any traces consumed are removed from +trace_op+ as a side effect.
+        # Only finished spans are consumed. Any spans consumed are
+        # removed from +trace_op+ as a side effect. Unfinished spans are
+        # unaffected.
         #
+        # @param [TraceOperation] trace_op
         # @return [TraceSegment] trace to be flushed, or +nil+ if the trace is not finished
         def consume!(trace_op)
-          return unless full_flush?(trace_op)
+          return unless flush?(trace_op)
 
           get_trace(trace_op)
         end
 
-        def full_flush?(trace_op)
-          trace_op && trace_op.sampled? && trace_op.finished?
+        # Should we consume spans from the +trace_op+?
+        # @abstract
+        def flush?(trace_op)
+          raise NotImplementedError
         end
 
         protected
 
+        # Consumes all finished spans from trace.
+        # @return [TraceSegment]
         def get_trace(trace_op)
-          trace_op.flush!
+          trace_op.flush! do |spans|
+            spans.select! { |span| single_sampled?(span) } unless trace_op.sampled?
+
+            spans
+          end
+        end
+
+        # Single Span Sampling has chosen to keep this span
+        # regardless of the trace-level sampling decision
+        def single_sampled?(span)
+          span.get_metric(Sampling::Span::Ext::TAG_MECHANISM) == Sampling::Ext::Mechanism::SPAN_SAMPLING_RATE
+        end
+      end
+
+      # Consumes and returns completed traces (where all spans have finished),
+      # if any, from the provided +trace_op+.
+      #
+      # Spans consumed are removed from +trace_op+ as a side effect.
+      class Finished < Base
+        # Are all spans finished?
+        def flush?(trace_op)
+          trace_op && trace_op.finished?
         end
       end
 
-      # Performs partial trace flushing to avoid large traces residing in memory for too long
-      class Partial
+      # Consumes and returns completed or partially completed
+      # traces from the provided +trace_op+, if any.
+      #
+      # Partial trace flushing avoids large traces residing in memory for too long.
+      #
+      # Partially completed traces, where not all spans have finished,
+      # will only be returned if there are at least
+      # +@min_spans_for_partial+ finished spans.
+      #
+      # Spans consumed are removed from +trace_op+ as a side effect.
+      class Partial < Base
         # Start flushing partial trace after this many active spans in one trace
         DEFAULT_MIN_SPANS_FOR_PARTIAL_FLUSH = 500
 
         attr_reader :min_spans_for_partial
 
         def initialize(options = {})
+          super()
           @min_spans_for_partial = options.fetch(:min_spans_before_partial_flush, DEFAULT_MIN_SPANS_FOR_PARTIAL_FLUSH)
         end
 
-        # Consumes and returns completed or partially completed
-        # traces from the provided +trace_op+, if any.
-        #
-        # Partially completed traces, where not all spans have finished,
-        # will only be returned if there are at least
-        # +@min_spans_for_partial+ finished spans.
-        #
-        # Any spans consumed are removed from +trace_op+ as a side effect.
-        #
-        # @return [TraceSegment] partial or complete trace to be flushed, or +nil+ if no spans are finished
-        def consume!(trace_op)
-          return unless partial_flush?(trace_op)
-
-          get_trace(trace_op)
-        end
-
-        def partial_flush?(trace_op)
-          return false unless trace_op.sampled?
+        def flush?(trace_op)
           return true if trace_op.finished?
           return false if trace_op.finished_span_count < @min_spans_for_partial
 
           true
         end
-
-        protected
-
-        def get_trace(trace_op)
-          trace_op.flush!
-        end
       end
     end
   end

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 require_relative '../analytics'
 require_relative 'ext'

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

@@ -1,4 +1,4 @@
-# typed: false
+# frozen_string_literal: true
 
 require_relative '../../core/error'
 

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# typed: true
-
 module Datadog
   module Tracing
     module Metadata
@@ -25,6 +23,10 @@ module Datadog
         # Set this tag to `1.0` if the span is a Service Entry span.
         TAG_TOP_LEVEL = '_dd.top_level'
 
+        # Set to `1.0` if profiling is enabled together with tracing, and `0.0` otherwise
+        # See Datadog-internal "RFC: Identifying which spans have profiling enabled " for details
+        TAG_PROFILING_ENABLED = '_dd.profiling.enabled'
+
         # Defines constants for trace analytics
         # @public_api
         module Analytics
@@ -45,14 +47,27 @@ module Datadog
         # @public_api
         # Tags related to distributed tracing
         module Distributed
+          # What mechanism was used to make this trace's sampling decision.
+          # @see Datadog::Tracing::Sampling::Ext::Mechanism
+          TAG_DECISION_MAKER = '_dd.p.dm'
+
           TAG_ORIGIN = '_dd.origin'
           TAG_SAMPLING_PRIORITY = '_sampling_priority_v1'
+
+          # Trace tags with this prefix will propagate from a trace through distributed tracing.
+          # Distributed headers tags with this prefix will be injected into the active trace.
+          TAGS_PREFIX = '_dd.p.'
+
+          # The distributed tag to carry hex encoded high order 64 bits of 127 bits trace id during
+          # the context restricted with 64 bits. Such as, Datadog propagation and messagepack encoding
+          TID = 'tid'
+          TAG_TID = TAGS_PREFIX + TID
         end
 
         # @public_api
         module Errors
           STATUS = 1
-          TAG_MSG = 'error.msg'
+          TAG_MSG = 'error.message'
           TAG_STACK = 'error.stack'
           TAG_TYPE = 'error.type'
         end
@@ -63,11 +78,14 @@ module Datadog
           TAG_BASE_URL = 'http.base_url'
           TAG_METHOD = 'http.method'
           TAG_STATUS_CODE = 'http.status_code'
+          TAG_USER_AGENT = 'http.useragent'
           TAG_URL = 'http.url'
           TYPE_INBOUND = AppTypes::TYPE_WEB.freeze
           TYPE_OUTBOUND = 'http'
           TYPE_PROXY = 'proxy'
           TYPE_TEMPLATE = 'template'
+          TAG_CLIENT_IP = 'http.client_ip'
+          HEADER_USER_AGENT = 'User-Agent'
 
           # General header functionality
           module Headers
@@ -76,7 +94,10 @@ module Datadog
             INVALID_TAG_CHARACTERS = %r{[^a-z0-9_\-:./]}.freeze
 
             # Normalizes an HTTP header string into a valid tag string.
-            def to_tag(name)
+            #
+            # By default, tags cannot create nested span tag levels:
+            # `allow_nested` allows you to override this behavior.
+            def to_tag(name, allow_nested: false)
               # Tag normalization based on: https://docs.datadoghq.com/getting_started/tagging/#defining-tags.
               #
               # Only the following characters are accepted.
@@ -95,7 +116,7 @@ module Datadog
               # Additional HTTP header normalization.
               #
               # Periods are replaced with an underscore.
-              tag.tr!('.', '_')
+              tag.tr!('.', '_') unless allow_nested
               tag
             end
           end
@@ -153,23 +174,17 @@ module Datadog
           TAG_QUERY = 'sql.query'
         end
 
-        # @public_api
-        module DB
-          TAG_INSTANCE = 'db.instance'
-          TAG_USER = 'db.user'
-          TAG_SYSTEM = 'db.system'
-          TAG_STATEMENT = 'db.statement'
-          TAG_ROW_COUNT = 'db.row_count'
-        end
-
         # @public_api
         module SpanKind
+          TAG_PROXY = 'proxy'
           TAG_SERVER = 'server'
           TAG_CLIENT = 'client'
           TAG_PRODUCER = 'producer'
           TAG_CONSUMER = 'consumer'
           TAG_INTERNAL = 'internal'
         end
+
+        # @public_api
       end
     end
   end

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

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../../core/environment/ext'
 
 require_relative 'ext'
@@ -61,8 +59,17 @@ module Datadog
         # A valid example is:
         #
         #   span.set_tags({ "http.method" => "GET", "user.id" => "234" })
-        def set_tags(tags)
-          tags.each { |k, v| set_tag(k, v) }
+        def set_tags(hash)
+          hash.each { |k, v| set_tag(k, v) }
+        end
+
+        # Returns true if the provided `tag` was set to a non-nil value.
+        # False otherwise.
+        #
+        # @param [String] tag the tag or metric to check for presence
+        # @return [Boolean] if the tag is present and not nil
+        def has_tag?(tag) # rubocop:disable Naming/PredicateName
+          !get_tag(tag).nil? # nil is considered not present, thus we can't use `Hash#has_key?`
         end
 
         # This method removes a tag for the given key.
@@ -101,6 +108,12 @@ module Datadog
           metrics.delete(key)
         end
 
+        # Returns a copy of all metadata.
+        # Keys for `@meta` and `@metrics` don't collide, by construction.
+        def tags
+          meta.merge(metrics)
+        end
+
         protected
 
         def meta

data/lib/datadog/tracing/metadata.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 require_relative 'metadata/analytics'
 require_relative 'metadata/tagging'

data/lib/datadog/tracing/pipeline/span_filter.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 require 'set'
 require_relative 'span_processor'

data/lib/datadog/tracing/pipeline/span_processor.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/pipeline.rb

@@ -1,7 +1,3 @@
-# typed: true
-
-require_relative '../core'
-
 require_relative 'pipeline/span_filter'
 require_relative 'pipeline/span_processor'
 

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

@@ -1,109 +1,14 @@
-# typed: false
+# frozen_string_literal: true
 
-require_relative '../../core'
-
-require_relative '../configuration/ext'
-require_relative '../sampling/ext'
-require_relative '../distributed/headers/b3'
-require_relative '../distributed/headers/b3_single'
-require_relative '../distributed/headers/datadog'
-
-require_relative '../trace_digest'
-require_relative '../trace_operation'
+require_relative '../contrib/http/distributed/propagation'
 
 module Datadog
   module Tracing
     module Propagation
       # Propagation::HTTP helps extracting and injecting HTTP headers.
+      # DEV-2.0: This file has been moved to Contrib. Should be deleted in the next release.
       # @public_api
-      module HTTP
-        PROPAGATION_STYLES = {
-          Configuration::Ext::Distributed::PROPAGATION_STYLE_B3 => Distributed::Headers::B3,
-          Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER => Distributed::Headers::B3Single,
-          Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG => Distributed::Headers::Datadog
-        }.freeze
-
-        # inject! popolates the env with span ID, trace ID and sampling priority
-        def self.inject!(digest, env)
-          # Prevent propagation from being attempted if trace headers provided are nil.
-          if digest.nil?
-            Datadog.logger.debug(
-              'Cannot inject trace headers into env to propagate over HTTP: trace headers are nil.'.freeze
-            )
-            return
-          end
-
-          digest = digest.to_digest if digest.is_a?(TraceOperation)
-
-          # Inject all configured propagation styles
-          Datadog.configuration.tracing.distributed_tracing.propagation_inject_style.each do |style|
-            propagator = PROPAGATION_STYLES[style]
-            begin
-              propagator.inject!(digest, env) unless propagator.nil?
-            rescue => e
-              Datadog.logger.error(
-                'Error injecting propagated trace headers into the environment. ' \
-                "Cause: #{e} Location: #{Array(e.backtrace).first}"
-              )
-            end
-          end
-        end
-
-        # extract returns trace headers containing the span ID, trace ID and
-        # sampling priority defined in env.
-        def self.extract(env)
-          trace_digest = nil
-          dd_trace_digest = nil
-
-          Datadog.configuration.tracing.distributed_tracing.propagation_extract_style.each do |style|
-            propagator = PROPAGATION_STYLES[style]
-            next if propagator.nil?
-
-            # Extract trace headers
-            # DEV: `propagator.extract` will return `nil`, where `Propagation::HTTP#extract` will not
-            begin
-              extracted_trace_digest = propagator.extract(env)
-            rescue => e
-              Datadog.logger.error(
-                'Error extracting propagated trace headers from the environment. ' \
-                "Cause: #{e} Location: #{Array(e.backtrace).first}"
-              )
-            end
-
-            # Skip this style if no valid headers were found
-            next if extracted_trace_digest.nil?
-
-            # Keep track of the Datadog extract trace headers, we want to return
-            #   this one if we have one
-            if extracted_trace_digest && style == Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG
-              dd_trace_digest = extracted_trace_digest
-            end
-
-            # No previously extracted trace headers, use the one we just extracted
-            if trace_digest.nil?
-              trace_digest = extracted_trace_digest
-            else
-              unless trace_digest.trace_id == extracted_trace_digest.trace_id \
-                      && trace_digest.span_id == extracted_trace_digest.span_id
-                # Return an empty/new trace headers if we have a mismatch in values extracted
-                msg = "#{trace_digest.trace_id} != #{extracted_trace_digest.trace_id} && " \
-                      "#{trace_digest.span_id} != #{extracted_trace_digest.span_id}"
-                Datadog.logger.debug(
-                  "Cannot extract trace headers from HTTP: extracted trace headers differ, #{msg}"
-                )
-                # DEV: This will return from `self.extract` not this `each` block
-                return TraceDigest.new
-              end
-            end
-          end
-
-          # Return the extracted trace headers if we found one or else a new empty trace headers
-          # Always return the Datadog trace headers if one exists since it has more
-          #   information than the B3 headers e.g. origin, expanded priority
-          #   sampling values, etc
-          dd_trace_digest || trace_digest || nil
-        end
-      end
+      HTTP = Tracing::Contrib::HTTP::Distributed::Propagation.new
     end
   end
 end

data/lib/datadog/tracing/remote.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../core/remote/dispatcher'
+require_relative 'configuration/dynamic'
+
+module Datadog
+  module Tracing
+    # Remote configuration declaration
+    module Remote
+      class ReadError < StandardError; end
+
+      class << self
+        PRODUCT = 'APM_TRACING'
+
+        def products
+          [PRODUCT]
+        end
+
+        def capabilities
+          [] # No capabilities advertised
+        end
+
+        def process_config(config, content)
+          lib_config = config['lib_config']
+
+          env_vars = Datadog::Tracing::Configuration::Dynamic::OPTIONS.map do |name, env_var, option|
+            value = lib_config[name]
+
+            # Guard for RBS/Steep
+            raise "option is a #{option.class}, expected Option" unless option.is_a?(Configuration::Dynamic::Option)
+
+            option.call(value)
+
+            [env_var, value]
+          end
+
+          content.applied
+
+          Datadog.send(:components).telemetry.client_configuration_change!(env_vars)
+        rescue => e
+          content.errored("#{e.class.name} #{e.message}: #{Array(e.backtrace).join("\n")}")
+        end
+
+        def receivers
+          receiver do |repository, _changes|
+            # DEV: Filter our by product. Given it will be very common
+            # DEV: we can filter this out before we receive the data in this method.
+            # DEV: Apply this refactor to AppSec as well if implemented.
+            repository.contents.map do |content|
+              case content.path.product
+              when PRODUCT
+                config = parse_content(content)
+                process_config(config, content)
+              end
+            end
+          end
+        end
+
+        def receiver(products = [PRODUCT], &block)
+          matcher = Core::Remote::Dispatcher::Matcher::Product.new(products)
+          [Core::Remote::Dispatcher::Receiver.new(matcher, &block)]
+        end
+
+        private
+
+        def parse_content(content)
+          data = content.data.read
+
+          content.data.rewind
+
+          raise ReadError, 'EOF reached' if data.nil?
+
+          JSON.parse(data)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/runtime/metrics.rb

@@ -1,6 +1,4 @@
-# typed: true
-
-require_relative '../../core'
+# frozen_string_literal: true
 
 module Datadog
   module Tracing

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 require_relative 'sampler'
 

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

@@ -1,4 +1,4 @@
-# typed: strict
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -21,6 +21,35 @@ module Datadog
           # through the {Datadog::Tracing::Sampling::RuleSampler}.
           USER_KEEP = 2
         end
+
+        # List of what mechanism was used to make the trace-level sampling decision.
+        module Mechanism
+          # Single Span Sampled.
+          SPAN_SAMPLING_RATE = 8
+        end
+
+        # List of how the decision was made for the trace-level sampling.
+        #
+        # These values used to populate the {Datadog::Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER} tag.
+        #
+        # The decision has two parts, separated by a `-`:
+        # `part1-sampling_mechanism`. `part1` is currently not populated, thus
+        # this tag is currently formatted as `"-sampling_mechanism"`.
+        module Decision
+          # Used before the tracer receives any rates from agent and there are no rules configured.
+          DEFAULT = '-0'
+          # The sampling rate received in the agent's http response.
+          AGENT_RATE = '-1'
+          # Sampling rule or sampling rate based on tracer config.
+          TRACE_SAMPLING_RULE = '-3'
+          # User directly sets sampling priority via {Tracing.reject!} or {Tracing.keep!},
+          # or by a custom sampler implementation.
+          MANUAL = '-4'
+          # Formerly AppSec.
+          ASM = '-5'
+          # Single Span Sampled.
+          SPAN_SAMPLING_RATE = '-8'
+        end
       end
     end
   end

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

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module Tracing
@@ -29,20 +29,40 @@ module Datadog
           end
         end.new
 
-        attr_reader :name, :service
+        attr_reader :name, :service, :resource, :tags
 
         # @param name [String,Regexp,Proc] Matcher for case equality (===) with the trace name,
         #             defaults to always match
         # @param service [String,Regexp,Proc] Matcher for case equality (===) with the service name,
         #                defaults to always match
-        def initialize(name: MATCH_ALL, service: MATCH_ALL)
+        # @param resource [String,Regexp,Proc] Matcher for case equality (===) with the resource name,
+        #                defaults to always match
+        def initialize(name: MATCH_ALL, service: MATCH_ALL, resource: MATCH_ALL, tags: {})
           super()
           @name = name
           @service = service
+          @resource = resource
+          @tags = tags
         end
 
         def match?(trace)
-          name === trace.name && service === trace.service
+          name === trace.name && service === trace.service && resource === trace.resource && tags_match?(trace)
+        end
+
+        private
+
+        # Match against the trace tags and metrics.
+        def tags_match?(trace)
+          @tags.all? do |name, matcher|
+            tag = trace.get_tag(name)
+
+            # Format metrics as strings, to allow for partial number matching (/4.*/ matching '400', '404', etc.).
+            # Because metrics are floats, we use the '%g' format specifier to avoid trailing zeros, which
+            # can affect exact string matching (e.g. '400' matching '400.0').
+            tag = format('%g', tag) if tag.is_a?(Numeric)
+
+            matcher === tag
+          end
         end
       end