datadog 2.18.0 → 2.20.0

data/lib/datadog/tracing/span_link.rb

@@ -47,15 +47,15 @@ module Datadog
         @span_id = digest.span_id
         @trace_id = digest.trace_id
         @trace_flags = if digest.trace_sampling_priority.nil?
-                         nil
-                       elsif digest.trace_sampling_priority > 0
-                         1
-                       else
-                         0
-                       end
-        @trace_state = digest.trace_state && digest.trace_state.dup
+          nil
+        elsif digest.trace_sampling_priority > 0
+          1
+        else
+          0
+        end
+        @trace_state = digest.trace_state&.dup
         @dropped_attributes = 0
-        @attributes = (attributes && attributes.dup) || {}
+        @attributes = attributes&.dup || {}
       end
 
       def to_hash
@@ -81,10 +81,10 @@ module Datadog
         # If traceflags set, the high bit (bit 31) should be set to 1 (uint32).
         # This helps us distinguish between when the sample decision is zero or not set
         h[:flags] = if @trace_flags.nil?
-                      0
-                    else
-                      @trace_flags | (1 << 31)
-                    end
+          0
+        else
+          @trace_flags | (1 << 31)
+        end
         h
       end
     end

data/lib/datadog/tracing/span_operation.rb

@@ -157,7 +157,7 @@ module Datadog
           # running, to minimize impact on normal application function.
           begin
             start
-          rescue StandardError => e
+          rescue => e
             logger.debug { "Failed to start span: #{e}" }
           ensure
             # We should yield to the provided block when possible, as this
@@ -297,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})"
@@ -365,7 +387,7 @@ 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,
@@ -426,23 +448,21 @@ module Datadog
             original = @handler
 
             @handler = proc do |op, error|
-              begin
-                yield(op, error)
-              rescue StandardError => e
-                logger.debug do
-                  "Custom on_error handler #{@handler} failed, using fallback behavior. \
+              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) if original
               end
+
+              original&.call(op, error)
             end
           end
 
           def publish(*args)
             begin
               @handler.call(*args)
-            rescue StandardError => e
+            rescue => e
               logger.debug do
                 "Error in on_error handler '#{@default}': #{e.class}: #{e} at #{Array(e.backtrace).first}"
               end

data/lib/datadog/tracing/trace_digest.rb

@@ -162,29 +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,
-            baggage: baggage
-          }.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

data/lib/datadog/tracing/trace_operation.rb

@@ -163,20 +163,20 @@ module Datadog
       end
 
       def name
-        @name || (root_span && root_span.name)
+        @name || root_span&.name
       end
 
       def resource
-        @resource || (root_span && root_span.resource)
+        @resource || root_span&.resource
       end
 
       # When retrieving tags or metrics we need to include root span tags for sampling purposes
       def get_tag(key)
-        super || (root_span && root_span.get_tag(key))
+        super || root_span&.get_tag(key)
       end
 
       def get_metric(key)
-        super || (root_span && root_span.get_metric(key))
+        super || root_span&.get_metric(key)
       end
 
       def set_distributed_source(product_bit)
@@ -201,7 +201,7 @@ module Datadog
       end
 
       def service
-        @service || (root_span && root_span.service)
+        @service || root_span&.service
       end
 
       def measure(
@@ -220,9 +220,11 @@ 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( # rubocop:disable Style/MultilineIfModifier
-          SpanOperation.new(op_name, logger: logger),
-          TraceOperation.new(logger: logger)) if finished? || full?
+        if finished? || full?
+          return yield(
+            SpanOperation.new(op_name, logger: logger),
+            TraceOperation.new(logger: logger))
+        end
 
         # Create new span
         span_op = build_span(
@@ -253,51 +255,49 @@ module Datadog
         type: nil,
         id: nil
       )
-        begin
-          # Resolve span options:
-          # Parent, service name, etc.
-          # Add default options
-          trace_id = @id
-          parent = @active_span
-
-          # Use active span's span ID if available. Otherwise, the parent span ID.
-          # Necessary when this trace continues from another, e.g. distributed trace.
-          parent_id = parent ? parent.id : @parent_span_id || 0
-
-          # Build events
-          events ||= SpanOperation::Events.new(logger: logger)
-
-          # Before start: activate the span, publish events.
-          events.before_start.subscribe do |span_op|
-            start_span(span_op)
-          end
+        # Resolve span options:
+        # Parent, service name, etc.
+        # Add default options
+        trace_id = @id
+        parent = @active_span
 
-          # After finish: deactivate the span, record, publish events.
-          events.after_finish.subscribe do |span, span_op|
-            finish_span(span, span_op, parent)
-          end
+        # Use active span's span ID if available. Otherwise, the parent span ID.
+        # Necessary when this trace continues from another, e.g. distributed trace.
+        parent_id = parent ? parent.id : @parent_span_id || 0
+
+        # Build events
+        events ||= SpanOperation::Events.new(logger: logger)
 
-          # Build a new span operation
-          SpanOperation.new(
-            op_name,
-            logger: logger,
-            events: events,
-            on_error: on_error,
-            parent_id: parent_id,
-            resource: resource || op_name,
-            service: service,
-            start_time: start_time,
-            tags: tags,
-            trace_id: trace_id,
-            type: type,
-            id: id
-          )
-        rescue StandardError => e
-          logger.debug { "Failed to build new span: #{e}" }
-
-          # Return dummy span
-          SpanOperation.new(op_name, logger: logger)
+        # Before start: activate the span, publish events.
+        events.before_start.subscribe do |span_op|
+          start_span(span_op)
         end
+
+        # After finish: deactivate the span, record, publish events.
+        events.after_finish.subscribe do |span, span_op|
+          finish_span(span, span_op, parent)
+        end
+
+        # Build a new span operation
+        SpanOperation.new(
+          op_name,
+          logger: logger,
+          events: events,
+          on_error: on_error,
+          parent_id: parent_id,
+          resource: resource || op_name,
+          service: service,
+          start_time: start_time,
+          tags: tags,
+          trace_id: trace_id,
+          type: type,
+          id: id
+        )
+      rescue => e
+        logger.debug { "Failed to build new span: #{e}" }
+
+        # Return dummy span
+        SpanOperation.new(op_name, logger: logger)
       end
 
       # Returns a {TraceSegment} with all finished spans that can be flushed
@@ -325,7 +325,7 @@ module Datadog
       # We should move the sample call to inject and right before moving to new contexts(threads, forking etc.)
       def to_digest
         # Resolve current span ID
-        span_id = @active_span && @active_span.id
+        span_id = @active_span&.id
         span_id ||= @parent_span_id unless finished?
         # sample the trace_operation with the tracer
         events.trace_propagated.publish(self)
@@ -349,13 +349,13 @@ module Datadog
           trace_state: @trace_state,
           trace_state_unknown_fields: @trace_state_unknown_fields,
           span_remote: @remote_parent && @active_span.nil?,
-          baggage: @baggage.nil? || @baggage.empty? ? nil : @baggage
+          baggage: (@baggage.nil? || @baggage.empty?) ? nil : @baggage
         ).freeze
       end
 
       def to_correlation
         # Resolve current span ID
-        span_id = @active_span && @active_span.id
+        span_id = @active_span&.id
         span_id ||= @parent_span_id unless finished?
 
         Correlation::Identifier.new(
@@ -369,22 +369,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&.dup,
+          hostname: @hostname&.dup,
           id: @id,
           max_length: @max_length,
-          name: name && name.dup,
-          origin: @origin && @origin.dup,
-          parent_span_id: (@active_span && @active_span.id) || @parent_span_id,
+          name: name&.dup,
+          origin: @origin&.dup,
+          parent_span_id: @active_span&.id || @parent_span_id,
           rate_limiter_rate: @rate_limiter_rate,
-          resource: resource && resource.dup,
+          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&.dup,
+          trace_state: @trace_state&.dup,
+          trace_state_unknown_fields: @trace_state_unknown_fields&.dup,
           tags: meta.dup,
           metrics: metrics.dup,
           remote_parent: @remote_parent
@@ -472,41 +472,37 @@ module Datadog
       end
 
       def start_span(span_op)
-        begin
-          activate_span!(span_op)
+        activate_span!(span_op)
 
-          # Update active span count
-          @active_span_count += 1
+        # Update active span count
+        @active_span_count += 1
 
-          # Publish :span_before_start event
-          events.span_before_start.publish(span_op, self)
-        rescue StandardError => e
-          logger.debug { "Error starting span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
-        end
+        # Publish :span_before_start event
+        events.span_before_start.publish(span_op, self)
+      rescue => e
+        logger.debug { "Error starting span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
       end
 
       def finish_span(span, span_op, parent)
-        begin
-          # Save finished span & root span
-          @spans << span unless span.nil?
+        # Save finished span & root span
+        @spans << span unless span.nil?
 
-          # Deactivate the span, re-activate parent.
-          deactivate_span!(span_op)
+        # Deactivate the span, re-activate parent.
+        deactivate_span!(span_op)
 
-          # Set finished, to signal root span has completed.
-          @finished = true if span_op == root_span
+        # Set finished, to signal root span has completed.
+        @finished = true if span_op == root_span
 
-          # Update active span count
-          @active_span_count -= 1
+        # Update active span count
+        @active_span_count -= 1
 
-          # Publish :span_finished event
-          events.span_finished.publish(span, self)
+        # Publish :span_finished event
+        events.span_finished.publish(span, self)
 
-          # Publish :trace_finished event
-          events.trace_finished.publish(self) if finished?
-        rescue StandardError => e
-          logger.debug { "Error finishing span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
-        end
+        # Publish :trace_finished event
+        events.trace_finished.publish(self) if finished?
+      rescue => e
+        logger.debug { "Error finishing span on trace: #{e} Backtrace: #{e.backtrace.first(3)}" }
       end
 
       # Track the root span
@@ -535,7 +531,7 @@ module Datadog
           service: service,
           tags: meta,
           metrics: metrics,
-          root_span_id: !partial ? root_span && root_span.id : nil,
+          root_span_id: (!partial) ? root_span&.id : nil,
           profiling_enabled: @profiling_enabled,
           apm_tracing_enabled: @apm_tracing_enabled
         )

data/lib/datadog/tracing/trace_segment.rb

@@ -68,8 +68,8 @@ module Datadog
 
         # Does not make an effort to move metrics out of tags
         # The caller is expected to have done that
-        @meta = (tags && tags.dup) || {}
-        @metrics = (metrics && metrics.dup) || {}
+        @meta = tags&.dup || {}
+        @metrics = metrics&.dup || {}
 
         # Set well-known tags, defaulting to getting the values from tags
         @agent_sample_rate = agent_sample_rate || agent_sample_rate_tag

data/lib/datadog/tracing/tracer.rb

@@ -149,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.
@@ -194,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.
@@ -225,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.
@@ -272,12 +271,10 @@ module Datadog
 
       # Sample a span, tagging the trace as appropriate.
       def sample_trace(trace_op)
-        begin
-          @sampler.sample!(trace_op) if trace_op.sampling_priority.nil?
-        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
 
@@ -297,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
@@ -315,7 +312,7 @@ module Datadog
       def shutdown!
         return unless @enabled
 
-        @writer.stop if @writer
+        @writer&.stop
       end
 
       private
@@ -335,12 +332,12 @@ 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
+            digest.trace_sampling_priority
+          end
           TraceOperation.new(
             logger: logger,
             hostname: hostname,
@@ -369,7 +366,9 @@ module Datadog
           )
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
+      # rubocop:disable Metrics/MethodLength
       def bind_trace_events!(trace_op)
         events = trace_op.send(:events)
 
@@ -388,6 +387,7 @@ module Datadog
           flush_trace(event_trace_op)
         end
       end
+      # rubocop:enable Metrics/MethodLength
 
       # Creates a new TraceOperation, with events bounds to this Tracer instance.
       # @return [TraceOperation]
@@ -402,6 +402,7 @@ module Datadog
       end
 
       # rubocop:disable Lint/UnderscorePrefixedVariableName
+      # rubocop:disable Metrics/MethodLength
       def start_span(
         name,
         continue_from: nil,
@@ -454,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)
@@ -507,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
 
@@ -521,13 +521,11 @@ module Datadog
 
       # Flush finished spans from the trace buffer, send them to writer.
       def flush_trace(trace_op)
-        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
 

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

@@ -30,7 +30,7 @@ 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}"

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

@@ -95,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/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}"