datadog 2.7.1 → 2.17.0

data/lib/datadog/tracing/span_event.rb

@@ -19,23 +19,143 @@ module Datadog
       #   @return [Integer]
       attr_reader :time_unix_nano
 
+      # TODO: Accept {Time} as the time_unix_nano parameter, possibly in addition to the current nano integer.
       def initialize(
         name,
         attributes: nil,
         time_unix_nano: nil
       )
         @name = name
-        @attributes = attributes || {}
+
+        @attributes = attributes.dup || {}
+        validate_attributes!(@attributes)
+        @attributes.transform_keys!(&:to_s)
+
         # OpenTelemetry SDK stores span event timestamps in nanoseconds (not seconds).
         # We will do the same here to avoid unnecessary conversions and inconsistencies.
-        @time_unix_nano = time_unix_nano || (Time.now.to_r * 1_000_000_000).to_i
+        @time_unix_nano = time_unix_nano || (Core::Utils::Time.now.to_r * 1_000_000_000).to_i
       end
 
+      # Converts the span event into a hash to be used by with the span tag serialization
+      # (`span.set_tag('events) = [event.to_hash]`). This serialization format has the drawback
+      # of being limiting span events to the size limit of a span tag.
+      # All Datadog agents support this format.
       def to_hash
-        h = { name: @name, time_unix_nano: @time_unix_nano }
-        h[:attributes] = attributes unless @attributes.empty?
+        h = { 'name' => @name, 'time_unix_nano' => @time_unix_nano }
+        h['attributes'] = @attributes unless @attributes.empty?
+        h
+      end
+
+      # Converts the span event into a hash to be used by the MessagePack serialization as a
+      # top-level span field (span.span_events = [event.to_native_format]).
+      # This serialization format removes the serialization limitations of the `span.set_tag('events)` approach,
+      # but is only supported by newer version of the Datadog agent.
+      def to_native_format
+        h = { 'name' => @name, 'time_unix_nano' => @time_unix_nano }
+
+        attr = {}
+        @attributes.each do |key, value|
+          attr[key] = if value.is_a?(Array)
+                        { type: ARRAY_TYPE, array_value: value.map { |v| serialize_native_attribute(v) } }
+                      else
+                        serialize_native_attribute(value)
+                      end
+        end
+
+        h['attributes'] = attr unless @attributes.empty?
+
         h
       end
+
+      private
+
+      MIN_INT64_SIGNED = -2**63
+      MAX_INT64_SIGNED = 2 << 63 - 1
+
+      # Checks the attributes hash to ensure it only contains serializable values.
+      # Invalid values are removed from the hash.
+      def validate_attributes!(attributes)
+        attributes.select! do |key, value|
+          case value
+          when Array
+            next true if value.empty?
+
+            first = value.first
+            case first
+            when String, Integer, Float
+              first_type = first.class
+              if value.all? { |v| v.is_a?(first_type) }
+                value.all? { |v| validate_scalar_attribute!(key, v) }
+              else
+                Datadog.logger.warn("Attribute #{key} array must be homogenous: #{value}.")
+                false
+              end
+            when TrueClass, FalseClass
+              if value.all? { |v| v.is_a?(TrueClass) || v.is_a?(FalseClass) }
+                value.all? { |v| validate_scalar_attribute!(key, v) }
+              else
+                Datadog.logger.warn("Attribute #{key} array must be homogenous: #{value}.")
+                false
+              end
+            else
+              Datadog.logger.warn("Attribute #{key} must be a string, number, or boolean: #{value}.")
+              false
+            end
+          when String, Numeric, TrueClass, FalseClass
+            validate_scalar_attribute!(key, value)
+          else
+            Datadog.logger.warn("Attribute #{key} must be a string, number, boolean, or array: #{value}.")
+            false
+          end
+        end
+      end
+
+      def validate_scalar_attribute!(key, value)
+        case value
+        when String, TrueClass, FalseClass
+          true
+        when Integer
+          # Cannot be larger than signed 64-bit integer
+          if value < MIN_INT64_SIGNED || value > MAX_INT64_SIGNED
+            Datadog.logger.warn("Attribute #{key} must be within the range of a signed 64-bit integer: #{value}.")
+            false
+          else
+            true
+          end
+        when Float
+          # Has to be finite
+          return true if value.finite?
+
+          Datadog.logger.warn("Attribute #{key} must be a finite number: #{value}.")
+          false
+        else
+          Datadog.logger.warn("Attribute #{key} must be a string, number, or boolean: #{value}.")
+          false
+        end
+      end
+
+      STRING_TYPE = 0
+      BOOLEAN_TYPE = 1
+      INTEGER_TYPE = 2
+      DOUBLE_TYPE = 3
+      ARRAY_TYPE = 4
+
+      # Serializes individual scalar attributes into the native format.
+      def serialize_native_attribute(value)
+        case value
+        when String
+          { type: STRING_TYPE, string_value: value }
+        when TrueClass, FalseClass
+          { type: BOOLEAN_TYPE, bool_value: value }
+        when Integer
+          { type: INTEGER_TYPE, int_value: value }
+        when Float
+          { type: DOUBLE_TYPE, double_value: value }
+        else
+          # This is technically unreachable due to the validation in #initialize.
+          raise ArgumentError, "Attribute must be a string, number, or boolean: #{value}."
+        end
+      end
     end
   end
 end

data/lib/datadog/tracing/span_operation.rb

@@ -11,6 +11,8 @@ require_relative 'event'
 require_relative 'metadata'
 require_relative 'metadata/ext'
 require_relative 'span'
+require_relative 'span_event'
+require_relative 'span_link'
 require_relative 'utils'
 
 module Datadog
@@ -26,6 +28,7 @@ module Datadog
       # Span attributes
       # NOTE: In the future, we should drop the me
       attr_reader \
+        :logger,
         :end_time,
         :id,
         :name,
@@ -35,10 +38,12 @@ module Datadog
         :start_time,
         :trace_id,
         :type
+
       attr_accessor :links, :status, :span_events
 
       def initialize(
         name,
+        logger: Datadog.logger,
         events: nil,
         on_error: nil,
         parent_id: 0,
@@ -52,6 +57,8 @@ module Datadog
         span_events: nil,
         id: nil
       )
+        @logger = logger
+
         # Ensure dynamically created strings are UTF-8 encoded.
         #
         # All strings created in Ruby land are UTF-8. The only sources of non-UTF-8 string are:
@@ -88,11 +95,17 @@ module Datadog
         set_tags(tags) if tags
 
         # Some other SpanOperation-specific behavior
-        @events = events || Events.new
+        @events = events || Events.new(logger: logger)
         @span = nil
 
-        # Subscribe :on_error event
-        @events.on_error.wrap_default(&on_error) if on_error.is_a?(Proc)
+        if on_error.nil?
+          # Nothing, default error handler is already set up.
+        elsif on_error.is_a?(Proc)
+          # Subscribe :on_error event
+          @events.on_error.wrap_default(&on_error)
+        else
+          logger.warn("on_error argument to SpanOperation ignored because is not a Proc: #{on_error}")
+        end
 
         # Start the span with start time, if given.
         start(start_time) if start_time
@@ -128,6 +141,10 @@ module Datadog
         @resource = resource.nil? ? nil : Core::Utils.utf8_encode(resource) # Allow this to be explicitly set to nil
       end
 
+      def get_collector_or_initialize
+        @collector ||= yield
+      end
+
       def measure
         raise ArgumentError, 'Must provide block to measure!' unless block_given?
         # TODO: Should we just invoke the block and skip tracing instead?
@@ -141,7 +158,7 @@ module Datadog
           begin
             start
           rescue StandardError => e
-            Datadog.logger.debug { "Failed to start span: #{e}" }
+            logger.debug { "Failed to start span: #{e}" }
           ensure
             # We should yield to the provided block when possible, as this
             # block is application code that we don't want to hinder.
@@ -159,7 +176,7 @@ module Datadog
           # Stop the span first, so timing is a more accurate.
           # If the span failed to start, timing may be inaccurate,
           # but this is not really a serious concern.
-          stop
+          stop(exception: e)
 
           # Trigger the on_error event
           events.on_error.publish(self, e)
@@ -197,7 +214,10 @@ module Datadog
       end
 
       # Mark the span stopped at the current time
-      def stop(stop_time = nil)
+      #
+      # steep:ignore:start
+      # Steep issue fixed in https://github.com/soutaro/steep/pull/1467
+      def stop(stop_time = nil, exception: nil)
         # A span should not be stopped twice. Note that this is not thread-safe,
         # stop is called from multiple threads, a given span might be stopped
         # several times. Again, one should not do this, so this test is more a
@@ -215,10 +235,11 @@ module Datadog
         @duration_end = stop_time.nil? ? duration_marker : nil
 
         # Trigger after_stop event
-        events.after_stop.publish(self)
+        events.after_stop.publish(self, exception)
 
         self
       end
+      # steep:ignore:end
 
       # Return whether the duration is started or not
       def started?
@@ -230,6 +251,10 @@ module Datadog
         !@end_time.nil?
       end
 
+      def root?
+        parent_id == 0
+      end
+
       # for backwards compatibility
       def start_time=(time)
         time.tap { start(time) }
@@ -263,7 +288,8 @@ module Datadog
 
       def duration
         return @duration_end - @duration_start if @duration_start && @duration_end
-        return @end_time - @start_time if @start_time && @end_time
+
+        @end_time - @start_time if @start_time && @end_time
       end
 
       def set_error(e)
@@ -283,6 +309,7 @@ module Datadog
           id: @id,
           meta: meta,
           metrics: metrics,
+          metastruct: metastruct,
           name: @name,
           parent_id: @parent_id,
           resource: @resource,
@@ -322,12 +349,15 @@ module Datadog
               q.text "#{key} => #{value}"
             end
           end
-          q.group(2, 'Metrics: [', ']') do
+          q.group(2, 'Metrics: [', "]\n") do
             q.breakable
             q.seplist metrics.each do |key, value|
               q.text "#{key} => #{value}"
             end
           end
+          q.group(2, 'Metastruct: [', ']') do
+            metastruct.pretty_print(q)
+          end
         end
       end
 
@@ -338,11 +368,13 @@ module Datadog
         DEFAULT_ON_ERROR = proc { |span_op, error| span_op.set_error(error) unless span_op.nil? }
 
         attr_reader \
+          :logger,
           :after_finish,
           :after_stop,
           :before_start
 
-        def initialize(on_error: nil)
+        def initialize(logger: Datadog.logger, on_error: nil)
+          @logger = logger
           @after_finish = AfterFinish.new
           @after_stop = AfterStop.new
           @before_start = BeforeStart.new
@@ -351,7 +383,7 @@ module Datadog
         # This event is lazily initialized as error paths
         # are normally less common that non-error paths.
         def on_error
-          @on_error ||= OnError.new(DEFAULT_ON_ERROR)
+          @on_error ||= OnError.new(DEFAULT_ON_ERROR, logger: logger)
         end
 
         # Triggered when the span is finished, regardless of error.
@@ -377,10 +409,13 @@ module Datadog
 
         # Triggered when the span raises an error during measurement.
         class OnError
-          def initialize(default)
+          def initialize(default, logger: Datadog.logger)
             @handler = default
+            @logger = logger
           end
 
+          attr_reader :logger
+
           # Call custom error handler but fallback to default behavior on failure.
 
           # DEV: Revisit this before full 1.0 release.
@@ -394,9 +429,9 @@ module Datadog
               begin
                 yield(op, error)
               rescue StandardError => e
-                Datadog.logger.debug do
+                logger.debug do
                   "Custom on_error handler #{@handler} failed, using fallback behavior. \
-                  Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                  Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
                 end
 
                 original.call(op, error) if original
@@ -408,8 +443,8 @@ module Datadog
             begin
               @handler.call(*args)
             rescue StandardError => e
-              Datadog.logger.debug do
-                "Error in on_error handler '#{@default}': #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+              logger.debug do
+                "Error in on_error handler '#{@default}': #{e.class}: #{e} at #{Array(e.backtrace).first}"
               end
             end
 
@@ -450,6 +485,7 @@ module Datadog
           id: @id,
           meta: Core::Utils::SafeDup.frozen_or_dup(meta),
           metrics: Core::Utils::SafeDup.frozen_or_dup(metrics),
+          metastruct: Core::Utils::SafeDup.frozen_or_dup(metastruct),
           parent_id: @parent_id,
           resource: @resource,
           service: @service,

data/lib/datadog/tracing/sync_writer.rb

@@ -17,18 +17,22 @@ module Datadog
     # @public_api
     class SyncWriter
       attr_reader \
+        :logger,
         :events,
-        :transport
+        :transport,
+        :agent_settings
 
       # @param [Datadog::Tracing::Transport::Traces::Transport] transport a custom transport instance.
       #   If provided, overrides `transport_options` and `agent_settings`.
       # @param [Hash<Symbol,Object>] transport_options options for the default transport instance.
       # @param [Datadog::Tracing::Configuration::AgentSettingsResolver::AgentSettings] agent_settings agent options for
       #   the default transport instance.
-      def initialize(transport: nil, transport_options: {}, agent_settings: nil)
+      def initialize(transport: nil, transport_options: {}, agent_settings: nil, logger: Datadog.logger)
+        @logger = logger
+        @agent_settings = agent_settings
+
         @transport = transport || begin
-          transport_options[:agent_settings] = agent_settings if agent_settings
-          Transport::HTTP.default(**transport_options)
+          Transport::HTTP.default(agent_settings: agent_settings, logger: logger, **transport_options)
         end
 
         @events = Writer::Events.new
@@ -40,7 +44,7 @@ module Datadog
       def write(trace)
         flush_trace(trace)
       rescue => e
-        Datadog.logger.debug(e)
+        logger.debug(e)
       end
 
       # Does nothing.

data/lib/datadog/tracing/trace_digest.rb

@@ -80,6 +80,9 @@ module Datadog
       #   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]
+      # @!attribute [r] baggage
+      #   The W3C "baggage" extracted from a distributed context. This field is a hash of key/value pairs.
+      #   @return [Hash<String,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 \
@@ -102,7 +105,8 @@ module Datadog
         :trace_flags,
         :trace_state,
         :trace_state_unknown_fields,
-        :span_remote
+        :span_remote,
+        :baggage
 
       def initialize(
         span_id: nil,
@@ -124,7 +128,8 @@ module Datadog
         trace_flags: nil,
         trace_state: nil,
         trace_state_unknown_fields: nil,
-        span_remote: true
+        span_remote: true,
+        baggage: nil
       )
         @span_id = span_id
         @span_name = span_name && span_name.dup.freeze
@@ -146,6 +151,7 @@ module Datadog
         @trace_state = trace_state && trace_state.dup.freeze
         @trace_state_unknown_fields = trace_state_unknown_fields && trace_state_unknown_fields.dup.freeze
         @span_remote = span_remote
+        @baggage = baggage && baggage.dup.freeze
         freeze
       end
 
@@ -177,6 +183,7 @@ module Datadog
             trace_state: trace_state,
             trace_state_unknown_fields: trace_state_unknown_fields,
             span_remote: span_remote,
+            baggage: baggage
           }.merge!(field_value_pairs)
         )
       end

data/lib/datadog/tracing/trace_operation.rb

@@ -2,7 +2,6 @@
 
 require_relative '../core/environment/identity'
 require_relative '../core/utils'
-require_relative 'tracer'
 require_relative 'event'
 require_relative 'metadata/tagging'
 require_relative 'sampling/ext'
@@ -37,9 +36,11 @@ module Datadog
         :rule_sample_rate,
         :sample_rate,
         :sampling_priority,
-        :remote_parent
+        :remote_parent,
+        :baggage
 
       attr_reader \
+        :logger,
         :active_span_count,
         :active_span,
         :id,
@@ -55,6 +56,7 @@ module Datadog
         :service
 
       def initialize(
+        logger: Datadog.logger,
         agent_sample_rate: nil,
         events: nil,
         hostname: nil,
@@ -71,19 +73,22 @@ module Datadog
         sampling_priority: nil,
         service: nil,
         profiling_enabled: nil,
+        apm_tracing_enabled: nil,
         tags: nil,
         metrics: nil,
         trace_state: nil,
         trace_state_unknown_fields: nil,
         remote_parent: false,
-        tracer: nil
-
+        tracer: nil,
+        baggage: nil
       )
+        @logger = logger
+
         # Attributes
         @id = id || Tracing::Utils::TraceId.next_id
         @max_length = max_length || DEFAULT_MAX_LENGTH
         @parent_span_id = parent_span_id
-        @sampled = sampled.nil? ? true : sampled
+        @sampled = sampled.nil? || sampled
         @remote_parent = remote_parent
 
         # Tags
@@ -98,9 +103,11 @@ module Datadog
         @sampling_priority = sampling_priority
         @service = service
         @profiling_enabled = profiling_enabled
+        @apm_tracing_enabled = apm_tracing_enabled
         @trace_state = trace_state
         @trace_state_unknown_fields = trace_state_unknown_fields
         @tracer = tracer
+        @baggage = baggage
 
         # Generic tags
         set_tags(tags) if tags
@@ -173,6 +180,12 @@ module Datadog
         super || (root_span && root_span.get_metric(key))
       end
 
+      def set_distributed_source(product_bit)
+        source = get_tag(Metadata::Ext::Distributed::TAG_TRACE_SOURCE)&.to_i(16) || 0
+        source |= product_bit
+        set_tag(Metadata::Ext::Distributed::TAG_TRACE_SOURCE, format('%02X', source))
+      end
+
       def tags
         all_tags = {}
         all_tags.merge!(root_span&.tags || {}) if root_span
@@ -194,6 +207,7 @@ module Datadog
 
       def measure(
         op_name,
+        logger: Datadog.logger,
         events: nil,
         on_error: nil,
         resource: nil,
@@ -207,7 +221,9 @@ module Datadog
         # Don't allow more span measurements if the
         # trace is already completed. Prevents multiple
         # root spans with parent_span_id = 0.
-        return yield(SpanOperation.new(op_name), TraceOperation.new) if finished? || full?
+        return yield( # rubocop:disable Style/MultilineIfModifier
+          SpanOperation.new(op_name, logger: logger),
+          TraceOperation.new(logger: logger)) if finished? || full?
 
         # Create new span
         span_op = build_span(
@@ -228,6 +244,7 @@ module Datadog
 
       def build_span(
         op_name,
+        logger: Datadog.logger,
         events: nil,
         on_error: nil,
         resource: nil,
@@ -249,7 +266,7 @@ module Datadog
           parent_id = parent ? parent.id : @parent_span_id || 0
 
           # Build events
-          events ||= SpanOperation::Events.new
+          events ||= SpanOperation::Events.new(logger: logger)
 
           # Before start: activate the span, publish events.
           events.before_start.subscribe do |span_op|
@@ -264,6 +281,7 @@ module Datadog
           # Build a new span operation
           SpanOperation.new(
             op_name,
+            logger: logger,
             events: events,
             on_error: on_error,
             parent_id: parent_id,
@@ -276,10 +294,10 @@ module Datadog
             id: id
           )
         rescue StandardError => e
-          Datadog.logger.debug { "Failed to build new span: #{e}" }
+          logger.debug { "Failed to build new span: #{e}" }
 
           # Return dummy span
-          SpanOperation.new(op_name)
+          SpanOperation.new(op_name, logger: logger)
         end
       end
 
@@ -315,10 +333,10 @@ module Datadog
 
         TraceDigest.new(
           span_id: span_id,
-          span_name: (@active_span && @active_span.name),
-          span_resource: (@active_span && @active_span.resource),
-          span_service: (@active_span && @active_span.service),
-          span_type: (@active_span && @active_span.type),
+          span_name: @active_span && @active_span.name,
+          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,
@@ -331,7 +349,8 @@ module Datadog
           trace_service: service,
           trace_state: @trace_state,
           trace_state_unknown_fields: @trace_state_unknown_fields,
-          span_remote: (@remote_parent && @active_span.nil?),
+          span_remote: @remote_parent && @active_span.nil?,
+          baggage: @baggage.nil? || @baggage.empty? ? nil : @baggage
         ).freeze
       end
 
@@ -351,22 +370,22 @@ module Datadog
       def fork_clone
         self.class.new(
           agent_sample_rate: @agent_sample_rate,
-          events: (@events && @events.dup),
-          hostname: (@hostname && @hostname.dup),
+          events: @events && @events.dup,
+          hostname: @hostname && @hostname.dup,
           id: @id,
           max_length: @max_length,
-          name: (name && name.dup),
-          origin: (@origin && @origin.dup),
+          name: name && name.dup,
+          origin: @origin && @origin.dup,
           parent_span_id: (@active_span && @active_span.id) || @parent_span_id,
           rate_limiter_rate: @rate_limiter_rate,
-          resource: (resource && resource.dup),
+          resource: resource && resource.dup,
           rule_sample_rate: @rule_sample_rate,
           sample_rate: @sample_rate,
           sampled: @sampled,
           sampling_priority: @sampling_priority,
-          service: (service && service.dup),
-          trace_state: (@trace_state && @trace_state.dup),
-          trace_state_unknown_fields: (@trace_state_unknown_fields && @trace_state_unknown_fields.dup),
+          service: service && service.dup,
+          trace_state: @trace_state && @trace_state.dup,
+          trace_state_unknown_fields: @trace_state_unknown_fields && @trace_state_unknown_fields.dup,
           tags: meta.dup,
           metrics: metrics.dup,
           remote_parent: @remote_parent
@@ -454,7 +473,7 @@ module Datadog
           # Publish :span_before_start event
           events.span_before_start.publish(span_op, self)
         rescue StandardError => e
-          Datadog.logger.debug { "Error starting span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
+          logger.debug { "Error starting span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
         end
       end
 
@@ -478,7 +497,7 @@ module Datadog
           # Publish :trace_finished event
           events.trace_finished.publish(self) if finished?
         rescue StandardError => e
-          Datadog.logger.debug { "Error finishing span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
+          logger.debug { "Error finishing span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
         end
       end
 
@@ -510,6 +529,7 @@ module Datadog
           metrics: metrics,
           root_span_id: !partial ? root_span && root_span.id : nil,
           profiling_enabled: @profiling_enabled,
+          apm_tracing_enabled: @apm_tracing_enabled
         )
       end