datadog 2.19.0 → 2.20.0

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

@@ -30,26 +30,26 @@ module Datadog
           default_sampler: nil
         )
           @rules = if default_sample_rate && !default_sampler
-                     # Add to the end of the rule list a rule always matches any trace
-                     rules << SimpleRule.new(sample_rate: default_sample_rate)
-                   else
-                     rules
-                   end
+            # Add to the end of the rule list a rule always matches any trace
+            rules << SimpleRule.new(sample_rate: default_sample_rate)
+          else
+            rules
+          end
           @rate_limiter = if rate_limiter
-                            rate_limiter
-                          elsif rate_limit
-                            Core::TokenBucket.new(rate_limit)
-                          else
-                            Core::UnlimitedLimiter.new
-                          end
+            rate_limiter
+          elsif rate_limit
+            Core::TokenBucket.new(rate_limit)
+          else
+            Core::UnlimitedLimiter.new
+          end
           @default_sampler = if default_sampler
-                               default_sampler
-                             elsif default_sample_rate
-                               nil
-                             else
-                               # TODO: Simplify .tags access, as `Tracer#tags` can't be arbitrarily changed anymore
-                               RateByServiceSampler.new(1.0, env: -> { Tracing.send(:tracer).tags['env'] })
-                             end
+            default_sampler
+          elsif default_sample_rate
+            nil
+          else
+            # TODO: Simplify .tags access, as `Tracer#tags` can't be arbitrarily changed anymore
+            RateByServiceSampler.new(1.0, env: -> { Tracing.send(:tracer).tags['env'] })
+          end
         end
 
         def self.parse(rules, rate_limit, default_sample_rate)
@@ -130,17 +130,17 @@ module Datadog
             set_limiter_metrics(trace, rate_limiter.effective_rate)
 
             provenance = case rule.provenance
-                         when Rule::PROVENANCE_REMOTE_USER
-                           Ext::Decision::REMOTE_USER_RULE
-                         when Rule::PROVENANCE_REMOTE_DYNAMIC
-                           Ext::Decision::REMOTE_DYNAMIC_RULE
-                         else
-                           Ext::Decision::TRACE_SAMPLING_RULE
-                         end
+            when Rule::PROVENANCE_REMOTE_USER
+              Ext::Decision::REMOTE_USER_RULE
+            when Rule::PROVENANCE_REMOTE_DYNAMIC
+              Ext::Decision::REMOTE_DYNAMIC_RULE
+            else
+              Ext::Decision::TRACE_SAMPLING_RULE
+            end
 
             trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, provenance)
           end
-        rescue StandardError => e
+        rescue => e
           Datadog.logger.error(
             "Rule sampling failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
@@ -153,10 +153,10 @@ module Datadog
         # was responsible for the sampling decision.
         def set_priority(trace, sampled)
           trace.sampling_priority = if sampled
-                                      Sampling::Ext::Priority::USER_KEEP
-                                    else
-                                      Sampling::Ext::Priority::USER_REJECT
-                                    end
+            Sampling::Ext::Priority::USER_KEEP
+          else
+            Sampling::Ext::Priority::USER_REJECT
+          end
         end
 
         def set_rule_metrics(trace, sample_rate)

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

@@ -28,7 +28,7 @@ module Datadog
                 list = JSON.parse(rules)
               rescue => e
                 Datadog.logger.warn(
-                  "Error parsing Span Sampling Rules `#{rules.inspect}`: "\
+                  "Error parsing Span Sampling Rules `#{rules.inspect}`: " \
                   "#{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
                 )
                 return nil

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

@@ -58,13 +58,6 @@ module Datadog
 
               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
 

data/lib/datadog/tracing/span.rb

@@ -113,7 +113,7 @@ module Datadog
       def stopped?
         !@end_time.nil?
       end
-      alias :finished? :stopped?
+      alias_method :finished?, :stopped?
 
       def duration
         return @duration if @duration

data/lib/datadog/tracing/span_event.rb

@@ -41,7 +41,7 @@ module Datadog
       # 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 = {'name' => @name, 'time_unix_nano' => @time_unix_nano}
         h['attributes'] = @attributes unless @attributes.empty?
         h
       end
@@ -51,15 +51,15 @@ module Datadog
       # 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 }
+        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: { values: value.map { |v| serialize_native_attribute(v) } } }
-                      else
-                        serialize_native_attribute(value)
-                      end
+            {type: ARRAY_TYPE, array_value: {values: value.map { |v| serialize_native_attribute(v) }}}
+          else
+            serialize_native_attribute(value)
+          end
         end
 
         h['attributes'] = attr unless @attributes.empty?
@@ -144,13 +144,13 @@ module Datadog
       def serialize_native_attribute(value)
         case value
         when String
-          { type: STRING_TYPE, string_value: value }
+          {type: STRING_TYPE, string_value: value}
         when TrueClass, FalseClass
-          { type: BOOLEAN_TYPE, bool_value: value }
+          {type: BOOLEAN_TYPE, bool_value: value}
         when Integer
-          { type: INTEGER_TYPE, int_value: value }
+          {type: INTEGER_TYPE, int_value: value}
         when Float
-          { type: DOUBLE_TYPE, double_value: value }
+          {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}."

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
@@ -387,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,
@@ -448,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