datadog 2.12.0 → 2.22.0

data/lib/datadog/tracing/span_operation.rb

@@ -28,6 +28,7 @@ module Datadog
       # Span attributes
       # NOTE: In the future, we should drop the me
       attr_reader \
+        :logger,
         :end_time,
         :id,
         :name,
@@ -37,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,
@@ -54,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:
@@ -90,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
@@ -130,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?
@@ -142,8 +157,8 @@ module Datadog
           # running, to minimize impact on normal application function.
           begin
             start
-          rescue StandardError => e
-            Datadog.logger.debug { "Failed to start span: #{e}" }
+          rescue => 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.
@@ -161,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)
@@ -202,7 +217,7 @@ module Datadog
       #
       # steep:ignore:start
       # Steep issue fixed in https://github.com/soutaro/steep/pull/1467
-      def stop(stop_time = nil)
+      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
@@ -220,7 +235,7 @@ 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
@@ -236,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) }
@@ -269,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)
@@ -277,6 +297,28 @@ module Datadog
         set_error_tags(e)
       end
 
+      # Record an exception during the execution of this span. Multiple exceptions
+      # can be recorded on a span.
+      #
+      # @param [Exception] exception The exception to record
+      # @param [optional Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}]
+      #   attributes One or more key:value pairs, where the keys must be
+      #   strings and the values may be (array of) string, boolean or numeric
+      #   type.
+      #
+      # @return [void]
+      def record_exception(exception, attributes: {})
+        exc = Core::Error.build_from(exception)
+
+        event_attributes = {
+          'exception.type' => exc.type,
+          'exception.message' => exc.message,
+          'exception.stacktrace' => exc.backtrace,
+        }
+
+        @span_events << SpanEvent.new('exception', attributes: event_attributes.merge!(attributes)) # steep:ignore
+      end
+
       # Return a string representation of the span.
       def to_s
         "SpanOperation(name:#{@name},sid:#{@id},tid:#{@trace_id},pid:#{@parent_id})"
@@ -289,6 +331,7 @@ module Datadog
           id: @id,
           meta: meta,
           metrics: metrics,
+          metastruct: metastruct,
           name: @name,
           parent_id: @parent_id,
           resource: @resource,
@@ -328,12 +371,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
 
@@ -341,14 +387,16 @@ module Datadog
       class Events
         include Tracing::Events
 
-        DEFAULT_ON_ERROR = proc { |span_op, error| span_op.set_error(error) unless span_op.nil? }
+        DEFAULT_ON_ERROR = proc { |span_op, error| span_op&.set_error(error) }
 
         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
@@ -357,7 +405,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.
@@ -383,10 +431,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.
@@ -397,25 +448,23 @@ module Datadog
             original = @handler
 
             @handler = proc do |op, error|
-              begin
-                yield(op, error)
-              rescue StandardError => e
-                Datadog.logger.debug do
-                  "Custom on_error handler #{@handler} failed, using fallback behavior. \
-                  Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
-                end
-
-                original.call(op, error) if original
+              yield(op, error)
+            rescue => e
+              logger.debug do
+                "Custom on_error handler #{@handler} failed, using fallback behavior. \
+                  Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
               end
+
+              original&.call(op, error)
             end
           end
 
           def publish(*args)
             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}"
+            rescue => e
+              logger.debug do
+                "Error in on_error handler '#{@default}': #{e.class}: #{e} at #{Array(e.backtrace).first}"
               end
             end
 
@@ -456,6 +505,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

@@ -19,19 +19,20 @@ module Datadog
       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
+      # @param [Datadog::Tracing::Configuration::AgentSettings] agent_settings agent options for
       #   the default transport instance.
       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

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
 
@@ -156,28 +162,27 @@ module Datadog
         # DEV: Because we want to sometimes freeze the values provided to `TraceDigest`, it's best
         # DEV: to let `#initialize` decide how to handle each field, instead of duplicating that logic here.
         TraceDigest.new(
-          **{
-            span_id: span_id,
-            span_name: span_name,
-            span_resource: span_resource,
-            span_service: span_service,
-            span_type: span_type,
-            trace_distributed_tags: trace_distributed_tags,
-            trace_hostname: trace_hostname,
-            trace_id: trace_id,
-            trace_name: trace_name,
-            trace_origin: trace_origin,
-            trace_process_id: trace_process_id,
-            trace_resource: trace_resource,
-            trace_runtime_id: trace_runtime_id,
-            trace_sampling_priority: trace_sampling_priority,
-            trace_service: trace_service,
-            trace_distributed_id: trace_distributed_id,
-            trace_flags: trace_flags,
-            trace_state: trace_state,
-            trace_state_unknown_fields: trace_state_unknown_fields,
-            span_remote: span_remote,
-          }.merge!(field_value_pairs)
+          span_id: span_id,
+          span_name: span_name,
+          span_resource: span_resource,
+          span_service: span_service,
+          span_type: span_type,
+          trace_distributed_tags: trace_distributed_tags,
+          trace_hostname: trace_hostname,
+          trace_id: trace_id,
+          trace_name: trace_name,
+          trace_origin: trace_origin,
+          trace_process_id: trace_process_id,
+          trace_resource: trace_resource,
+          trace_runtime_id: trace_runtime_id,
+          trace_sampling_priority: trace_sampling_priority,
+          trace_service: trace_service,
+          trace_distributed_id: trace_distributed_id,
+          trace_flags: trace_flags,
+          trace_state: trace_state,
+          trace_state_unknown_fields: trace_state_unknown_fields,
+          span_remote: span_remote,
+          baggage: baggage, **field_value_pairs
         )
       end
     end