ddtrace 1.0.0 → 1.9.0

data/lib/datadog/tracing/sampling/span/sampler.rb

@@ -0,0 +1,75 @@
+module Datadog
+  module Tracing
+    module Sampling
+      module Span
+        # Applies Single Span Sampling rules to spans.
+        # When matching the configured rules, a span is ensured to
+        # be processed Datadog App. In other words, a single sampled span
+        # will never be dropped by the tracer or Datadog agent.
+        #
+        # All spans in a trace are subject to the single sampling rules, if
+        # any rules are configured.
+        #
+        # Single Span Sampling is distinct from trace-level sampling:
+        # Single Span Sampling can ensure a span is kept, even if its
+        # enclosing trace is rejected by trace-level sampling.
+        #
+        # This class only applies operations to spans that are part
+        # of traces that was rejected by trace sampling.
+        # A trace is rejected if either of the following conditions is true:
+        # * The priority sampling for a trace is set to either {USER_REJECT} or {AUTO_REJECT}.
+        # * The trace was rejected by internal sampling, thus never flushed.
+        #
+        # Single-sampled spans are tagged and the tracer ensures they will
+        # reach the Datadog App, regardless of their enclosing trace sampling decision.
+        #
+        # Single Span Sampling does not inspect spans that are part of a trace
+        # that has been accepted by trace-level sampling rules: all spans from such
+        # trace are guaranteed to reach the Datadog App.
+        class Sampler
+          attr_reader :rules
+
+          # Receives sampling rules to apply to individual spans.
+          #
+          # @param [Array<Datadog::Tracing::Sampling::Span::Rule>] rules list of rules to apply to spans
+          def initialize(rules = [])
+            @rules = rules
+          end
+
+          # Applies Single Span Sampling rules to the span if the trace has been rejected.
+          #
+          # The trace can be outright rejected, and never reach the transport,
+          # or be set as rejected by priority sampling. In both cases, the trace
+          # is considered rejected for Single Span Sampling purposes.
+          #
+          # If multiple rules match, only the first one is applied.
+          #
+          # @param [Datadog::Tracing::TraceOperation] trace_op trace for the provided span
+          # @param [Datadog::Tracing::SpanOperation] span_op Span to apply sampling rules
+          # @return [void]
+          def sample!(trace_op, span_op)
+            return if trace_op.sampled? && trace_op.priority_sampled?
+
+            # Applies the first matching rule
+            @rules.each do |rule|
+              decision = rule.sample!(span_op)
+
+              next if decision == :not_matched # Iterate until we find a matching decision
+
+              if decision == :kept
+                trace_op.set_tag(
+                  Metadata::Ext::Distributed::TAG_DECISION_MAKER,
+                  Sampling::Ext::Decision::SPAN_SAMPLING_RATE
+                )
+              end
+
+              break # Found either a `kept` or `rejected` decision
+            end
+
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/span.rb

@@ -2,11 +2,11 @@
 
 # typed: true
 
-require 'datadog/core/utils'
-require 'datadog/core/utils/safe_dup'
+require_relative '../core/utils/safe_dup'
+require_relative 'utils'
 
-require 'datadog/tracing/metadata/ext'
-require 'datadog/tracing/metadata'
+require_relative 'metadata/ext'
+require_relative 'metadata'
 
 module Datadog
   module Tracing
@@ -19,19 +19,6 @@ module Datadog
     class Span
       include Metadata
 
-      # The max value for a {Datadog::Tracing::Span} identifier.
-      # Span and trace identifiers should be strictly positive and strictly inferior to this limit.
-      #
-      # Limited to +2<<62-1+ positive integers, as Ruby is able to represent such numbers "inline",
-      # inside a +VALUE+ scalar, thus not requiring memory allocation.
-      #
-      # The range of IDs also has to consider portability across different languages and platforms.
-      RUBY_MAX_ID = (1 << 62) - 1
-
-      # While we only generate 63-bit integers due to limitations in other languages, we support
-      # parsing 64-bit integers for distributed tracing since an upstream system may generate one
-      EXTERNAL_MAX_ID = 1 << 64
-
       attr_accessor \
         :end_time,
         :id,
@@ -63,6 +50,7 @@ module Datadog
       # * +type+: the type of the span (such as +http+, +db+ and so on)
       # * +parent_id+: the identifier of the parent span
       # * +trace_id+: the identifier of the root span for this trace
+      # * +service_entry+: whether it is a service entry span.
       # TODO: Remove span_type
       def initialize(
         name,
@@ -78,16 +66,17 @@ module Datadog
         start_time: nil,
         status: 0,
         type: span_type,
-        trace_id: nil
+        trace_id: nil,
+        service_entry: nil
       )
         @name = Core::Utils::SafeDup.frozen_or_dup(name)
         @service = Core::Utils::SafeDup.frozen_or_dup(service)
         @resource = Core::Utils::SafeDup.frozen_or_dup(resource)
         @type = Core::Utils::SafeDup.frozen_or_dup(type)
 
-        @id = id || Core::Utils.next_id
+        @id = id || Tracing::Utils.next_id
         @parent_id = parent_id || 0
-        @trace_id = trace_id || Core::Utils.next_id
+        @trace_id = trace_id || Tracing::Utils.next_id
 
         @meta = meta || {}
         @metrics = metrics || {}
@@ -103,6 +92,11 @@ module Datadog
         # duration_start and duration_end track monotonic clock, and may remain nil in cases where it
         # is known that we have to use wall clock to measure duration.
         @duration = duration
+
+        @service_entry = service_entry
+
+        # Mark with the service entry span metric, if applicable
+        set_metric(Metadata::Ext::TAG_TOP_LEVEL, 1.0) if service_entry
       end
 
       # Return whether the duration is started or not
@@ -207,6 +201,16 @@ module Datadog
       def duration_nano
         (duration * 1e9).to_i
       end
+
+      # https://docs.datadoghq.com/tracing/visualization/#service-entry-span
+      # A span is a service entry span when it is the entrypoint method for a request to a service.
+      # You can visualize this within Datadog APM when the color of the immediate parent on a flame graph is a different
+      # color. Services are also listed on the right when viewing a flame graph.
+      #
+      # @return [Boolean] `true` if the span is a serivce entry span
+      def service_entry?
+        @service_entry == true
+      end
     end
   end
 end

data/lib/datadog/tracing/span_operation.rb

@@ -1,17 +1,17 @@
 # typed: true
 
-require 'forwardable'
 require 'time'
 
-require 'datadog/core'
-require 'datadog/core/environment/identity'
-require 'datadog/core/utils'
-require 'datadog/core/utils/time'
+require_relative '../core'
+require_relative '../core/environment/identity'
+require_relative '../core/utils'
+require_relative '../core/utils/time'
 
-require 'datadog/tracing/metadata/ext'
-require 'datadog/tracing/event'
-require 'datadog/tracing/span'
-require 'datadog/tracing/metadata'
+require_relative 'event'
+require_relative 'metadata'
+require_relative 'metadata/ext'
+require_relative 'span'
+require_relative 'utils'
 
 module Datadog
   module Tracing
@@ -19,7 +19,6 @@ module Datadog
     # It gives a Span a context which can be used to
     # build a Span. When completed, it yields the Span.
     #
-    # rubocop:disable Metrics/ClassLength
     # @public_api
     class SpanOperation
       include Metadata
@@ -63,9 +62,9 @@ module Datadog
         self.type = type
         self.resource = resource
 
-        @id = Core::Utils.next_id
+        @id = Tracing::Utils.next_id
         @parent_id = parent_id || 0
-        @trace_id = trace_id || Core::Utils.next_id
+        @trace_id = trace_id || Tracing::Utils.next_id
 
         @status = 0
 
@@ -399,7 +398,7 @@ module Datadog
               rescue StandardError => e
                 Datadog.logger.debug do
                   "Custom on_error handler #{@handler} failed, using fallback behavior. \
-                  Error: #{e.message} Location: #{Array(e.backtrace).first}"
+                  Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
                 end
 
                 original.call(op, error) if original
@@ -412,7 +411,7 @@ module Datadog
               @handler.call(*args)
             rescue StandardError => e
               Datadog.logger.debug do
-                "Error in on_error handler '#{@default}': #{e.message} at #{Array(e.backtrace).first}"
+                "Error in on_error handler '#{@default}': #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
               end
             end
 
@@ -469,7 +468,8 @@ module Datadog
           start_time: @start_time,
           status: @status,
           type: @type,
-          trace_id: @trace_id
+          trace_id: @trace_id,
+          service_entry: parent.nil? || (service && parent.service != service)
         )
       end
 
@@ -516,6 +516,5 @@ module Datadog
       alias :span_type :type
       alias :span_type= :type=
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/datadog/tracing/sync_writer.rb

@@ -1,12 +1,12 @@
 # typed: true
 
-require 'datadog/core'
+require_relative '../core'
 
-require 'datadog/tracing/pipeline'
-require 'datadog/tracing/runtime/metrics'
-require 'datadog/tracing/writer'
+require_relative 'pipeline'
+require_relative 'runtime/metrics'
+require_relative 'writer'
 
-require 'ddtrace/transport/http'
+require_relative '../../ddtrace/transport/http'
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/trace_digest.rb

@@ -6,12 +6,84 @@ module Datadog
     # Used to propagate context and continue traces across execution boundaries.
     # @public_api
     class TraceDigest
+      # @!attribute [r] span_id
+      #   Datadog id for the currently active span.
+      #   @return [Integer]
+      # @!attribute [r] span_name
+      #   The operation name of the currently active span.
+      #   @return [String]
+      # @!attribute [r] span_resource
+      #   The resource name of the currently active span.
+      #   @return [String]
+      # @!attribute [r] span_service
+      #   The service of the currently active span.
+      #   @return [String]
+      # @!attribute [r] span_type
+      #   The type of the currently active span.
+      #   @return [String]
+      # @!attribute [r] trace_distributed_tags
+      #   Datadog-specific tags that support richer distributed tracing association.
+      #   @return [Hash<String,String>]
+      # @!attribute [r] trace_hostname
+      #   The hostname of the currently active trace. Use to attribute traces to hosts.
+      #   @return [String]
+      # @!attribute [r] trace_id
+      #   Datadog id for the currently active trace.
+      #   @return [Integer]
+      # @!attribute [r] trace_name
+      #   Operation name for the currently active trace.
+      #   @return [Integer]
+      # @!attribute [r] trace_origin
+      #   Datadog-specific attribution of this trace's creation.
+      #   @return [String]
+      # @!attribute [r] trace_process_id
+      #   The OS-specific process id.
+      #   @return [Integer]
+      # @!attribute [r] trace_resource
+      #   The resource name of the currently active trace.
+      #   @return [String]
+      # @!attribute [r] trace_runtime_id
+      #   Unique id to this Ruby process. Used to differentiate traces coming from
+      #   child processes forked from same parent process.
+      #   @return [String]
+      # @!attribute [r] trace_sampling_priority
+      #   Datadog-specific sampling decision for the currently active trace.
+      #   @return [Integer]
+      # @!attribute [r] trace_service
+      #   The service of the currently active trace.
+      #   @return [String]
+      # @!attribute [r] trace_distributed_id
+      #   The trace id extracted from a distributed context, if different from `trace_id`.
+      #
+      #   The current use case is when the distributed context has a trace id integer larger than 64-bit:
+      #   This attribute will preserve the original id, while `trace_id` will only contain the lower 64 bits.
+      #   @return [Integer]
+      #   @see https://www.w3.org/TR/trace-context/#trace-id
+      # @!attribute [r] trace_flags
+      #   The W3C "trace-flags" extracted from a distributed context. This field is an 8-bit unsigned integer.
+      #   @return [Integer]
+      #   @see https://www.w3.org/TR/trace-context/#trace-flags
+      # @!attribute [r] trace_state
+      #   The W3C "tracestate" extracted from a distributed context.
+      #   This field is a string representing vendor-specific distribution data.
+      #   The `dd=` entry is removed from `trace_state` as its value is dynamically calculated
+      #   on every propagation injection.
+      #   @return [String]
+      #   @see https://www.w3.org/TR/trace-context/#tracestate-header
+      # @!attribute [r] trace_state_unknown_fields
+      #   From W3C "tracestate"'s `dd=` entry, when keys are not recognized they are stored here long with their values.
+      #   This allows later propagation to include those unknown fields, as they can represent future versions of the spec
+      #   sending data through this service. This value ends in a trailing `;` to facilitate serialization.
+      #   @return [String]
+      # TODO: The documentation for the last attribute above won't be rendered.
+      # TODO: This might be a YARD bug as adding an attribute, making it now second-last attribute, renders correctly.
       attr_reader \
         :span_id,
         :span_name,
         :span_resource,
         :span_service,
         :span_type,
+        :trace_distributed_tags,
         :trace_hostname,
         :trace_id,
         :trace_name,
@@ -20,7 +92,11 @@ module Datadog
         :trace_resource,
         :trace_runtime_id,
         :trace_sampling_priority,
-        :trace_service
+        :trace_service,
+        :trace_distributed_id,
+        :trace_flags,
+        :trace_state,
+        :trace_state_unknown_fields
 
       def initialize(
         span_id: nil,
@@ -28,6 +104,7 @@ module Datadog
         span_resource: nil,
         span_service: nil,
         span_type: nil,
+        trace_distributed_tags: nil,
         trace_hostname: nil,
         trace_id: nil,
         trace_name: nil,
@@ -36,13 +113,18 @@ module Datadog
         trace_resource: nil,
         trace_runtime_id: nil,
         trace_sampling_priority: nil,
-        trace_service: nil
+        trace_service: nil,
+        trace_distributed_id: nil,
+        trace_flags: nil,
+        trace_state: nil,
+        trace_state_unknown_fields: nil
       )
         @span_id = span_id
         @span_name = span_name && span_name.dup.freeze
         @span_resource = span_resource && span_resource.dup.freeze
         @span_service = span_service && span_service.dup.freeze
         @span_type = span_type && span_type.dup.freeze
+        @trace_distributed_tags = trace_distributed_tags && trace_distributed_tags.dup.freeze
         @trace_hostname = trace_hostname && trace_hostname.dup.freeze
         @trace_id = trace_id
         @trace_name = trace_name && trace_name.dup.freeze
@@ -52,6 +134,10 @@ module Datadog
         @trace_runtime_id = trace_runtime_id && trace_runtime_id.dup.freeze
         @trace_sampling_priority = trace_sampling_priority
         @trace_service = trace_service && trace_service.dup.freeze
+        @trace_distributed_id = trace_distributed_id
+        @trace_flags = trace_flags
+        @trace_state = trace_state && trace_state.dup.freeze
+        @trace_state_unknown_fields = trace_state_unknown_fields && trace_state_unknown_fields.dup.freeze
 
         freeze
       end

data/lib/datadog/tracing/trace_operation.rb

@@ -1,15 +1,16 @@
 # typed: false
 
-require 'datadog/core'
-require 'datadog/core/environment/identity'
-require 'datadog/core/utils'
-
-require 'datadog/tracing/sampling/ext'
-require 'datadog/tracing/event'
-require 'datadog/tracing/span_operation'
-require 'datadog/tracing/trace_segment'
-require 'datadog/tracing/trace_digest'
-require 'datadog/tracing/metadata/tagging'
+require_relative '../core'
+require_relative '../core/environment/identity'
+require_relative '../core/utils'
+
+require_relative 'event'
+require_relative 'metadata/tagging'
+require_relative 'sampling/ext'
+require_relative 'span_operation'
+require_relative 'trace_digest'
+require_relative 'trace_segment'
+require_relative 'utils'
 
 module Datadog
   module Tracing
@@ -22,7 +23,6 @@ module Datadog
     # For async support, a {Datadog::Tracing::TraceOperation} should be employed
     # per execution context (e.g. Thread, etc.)
     #
-    # rubocop:disable Metrics/ClassLength
     # @public_api
     class TraceOperation
       include Metadata::Tagging
@@ -71,11 +71,10 @@ module Datadog
         metrics: nil
       )
         # Attributes
-        @events = events || Events.new
-        @id = id || Core::Utils.next_id
+        @id = id || Tracing::Utils.next_id
         @max_length = max_length || DEFAULT_MAX_LENGTH
         @parent_span_id = parent_span_id
-        @sampled = sampled.nil? ? false : sampled
+        @sampled = sampled.nil? ? true : sampled
 
         # Tags
         @agent_sample_rate = agent_sample_rate
@@ -114,18 +113,34 @@ module Datadog
         @finished == true
       end
 
+      # Will this trace be flushed by the tracer transport?
+      # This includes cases where the span is kept solely due to priority sampling.
+      #
+      # This is not the ultimate Datadog App sampling decision. Downstream systems
+      # can decide to reject this trace, especially for cases where priority
+      # sampling is set to AUTO_KEEP.
+      #
+      # @return [Boolean]
       def sampled?
-        @sampled == true || (!@sampling_priority.nil? && @sampling_priority > 0)
+        @sampled == true || priority_sampled?
+      end
+
+      # Has the priority sampling chosen to keep this span?
+      # @return [Boolean]
+      def priority_sampled?
+        !@sampling_priority.nil? && @sampling_priority > 0
       end
 
       def keep!
         self.sampled = true
         self.sampling_priority = Sampling::Ext::Priority::USER_KEEP
+        set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, Tracing::Sampling::Ext::Decision::MANUAL)
       end
 
       def reject!
         self.sampled = false
         self.sampling_priority = Sampling::Ext::Priority::USER_REJECT
+        set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, Tracing::Sampling::Ext::Decision::MANUAL)
       end
 
       def name
@@ -136,6 +151,13 @@ module Datadog
         @resource || (root_span && root_span.resource)
       end
 
+      # Returns true if the resource has been explicitly set
+      #
+      # @return [Boolean]
+      def resource_override?
+        !@resource.nil?
+      end
+
       def service
         @service || (root_span && root_span.service)
       end
@@ -227,6 +249,11 @@ module Datadog
         end
       end
 
+      # Returns a {TraceSegment} with all finished spans that can be flushed
+      # at invocation time. All other **finished** spans are discarded.
+      #
+      # @yield [spans] spans that will be returned as part of the trace segment returned
+      # @return [TraceSegment]
       def flush!
         finished = finished?
 
@@ -234,6 +261,8 @@ module Datadog
         spans = @spans.dup
         @spans = []
 
+        spans = yield(spans) if block_given?
+
         # Use them to build a trace
         build_trace(spans, !finished)
       end
@@ -252,6 +281,7 @@ module Datadog
           span_resource: (@active_span && @active_span.resource),
           span_service: (@active_span && @active_span.service),
           span_type: (@active_span && @active_span.type),
+          trace_distributed_tags: distributed_tags,
           trace_hostname: @hostname,
           trace_id: @id,
           trace_name: name,
@@ -426,7 +456,21 @@ module Datadog
           root_span_id: !partial ? root_span && root_span.id : nil
         )
       end
+
+      # Returns tracer tags that will be propagated if this span's context
+      # is exported through {.to_digest}.
+      # @return [Hash] key value pairs of distributed tags
+      def distributed_tags
+        meta.select { |name, _| name.start_with?(Metadata::Ext::Distributed::TAGS_PREFIX) }
+      end
+
+      def reset
+        @root_span = nil
+        @active_span = nil
+        @active_span_count = 0
+        @finished = false
+        @spans = []
+      end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/datadog/tracing/trace_segment.rb

@@ -1,17 +1,16 @@
 # typed: true
 
-require 'datadog/core/runtime/ext'
-require 'datadog/core/utils/safe_dup'
+require_relative '../core/runtime/ext'
+require_relative '../core/utils/safe_dup'
 
-require 'datadog/tracing/sampling/ext'
-require 'datadog/tracing/metadata/ext'
-require 'datadog/tracing/metadata/tagging'
+require_relative 'sampling/ext'
+require_relative 'metadata/ext'
+require_relative 'metadata/tagging'
 
 module Datadog
   module Tracing
     # Serializable construct representing a trace
     # @public_api
-    # rubocop:disable Metrics/ClassLength
     class TraceSegment
       TAG_NAME = 'name'.freeze
       TAG_RESOURCE = 'resource'.freeze
@@ -31,11 +30,13 @@ module Datadog
         :rule_sample_rate,
         :runtime_id,
         :sample_rate,
+        :sampling_decision_maker,
         :sampling_priority,
         :service
 
       # rubocop:disable Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity
+      # @param spans [Array<Datadog::Span>]
       def initialize(
         spans,
         agent_sample_rate: nil,
@@ -77,6 +78,7 @@ module Datadog
         @rule_sample_rate = rule_sample_rate_tag || rule_sample_rate
         @runtime_id = runtime_id || runtime_id_tag
         @sample_rate = sample_rate || sample_rate_tag
+        @sampling_decision_maker = sampling_decision_maker_tag
         @sampling_priority = sampling_priority || sampling_priority_tag
         @service = Core::Utils::SafeDup.frozen_or_dup(service || service_tag)
       end
@@ -171,7 +173,7 @@ module Datadog
       end
 
       def process_id_tag
-        meta[Core::Runtime::Ext::TAG_PID]
+        meta[Core::Runtime::Ext::TAG_PROCESS_ID]
       end
 
       def rate_limiter_rate_tag
@@ -194,6 +196,10 @@ module Datadog
         metrics[Metadata::Ext::Sampling::TAG_SAMPLE_RATE]
       end
 
+      def sampling_decision_maker_tag
+        meta[Metadata::Ext::Distributed::TAG_DECISION_MAKER]
+      end
+
       def sampling_priority_tag
         meta[Metadata::Ext::Distributed::TAG_SAMPLING_PRIORITY]
       end
@@ -202,6 +208,5 @@ module Datadog
         meta[TAG_SERVICE]
       end
     end
-    # rubocop:enable Metrics/ClassLength
   end
 end