datadog 2.19.0 → 2.21.0

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}"

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

@@ -33,10 +33,10 @@ module Datadog
 
                 # Write to IO
                 result = if block_given?
-                           yield(out, data)
-                         else
-                           write_data(out, data)
-                         end
+                  yield(out, data)
+                else
+                  write_data(out, data)
+                end
 
                 # Generate response
                 Traces::Response.new(result)

data/lib/datadog/tracing/transport/statistics.rb

@@ -47,7 +47,7 @@ module Datadog
         end
 
         def metrics_for_exception(_exception)
-          { api_errors: Core::Metrics::Metric.new(:api_errors, nil, 1) }
+          {api_errors: Core::Metrics::Metric.new(:api_errors, nil, 1)}
         end
 
         # Stat counts

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

@@ -66,11 +66,11 @@ module Datadog
           #   number of traces
           def encode_in_chunks(traces)
             encoded_traces = if traces.respond_to?(:filter_map)
-                               # DEV Supported since Ruby 2.7, saves an intermediate object creation
-                               traces.filter_map { |t| encode_one(t) }
-                             else
-                               traces.map { |t| encode_one(t) }.reject(&:nil?)
-                             end
+              # DEV Supported since Ruby 2.7, saves an intermediate object creation
+              traces.filter_map { |t| encode_one(t) }
+            else
+              traces.map { |t| encode_one(t) }.reject(&:nil?)
+            end
 
             Datadog::Core::Chunker.chunk_by_size(encoded_traces, max_size).map do |chunk|
               [encoder.join(chunk), chunk.size]

data/lib/datadog/tracing/workers/trace_writer.rb

@@ -45,7 +45,7 @@ module Datadog
         def write_traces(traces)
           traces = process_traces(traces)
           flush_traces(traces)
-        rescue StandardError => e
+        rescue => e
           logger.warn(
             "Error while writing traces: dropped #{traces.length} items. Cause: #{e} Location: #{Array(e.backtrace).first}"
           )
@@ -119,7 +119,7 @@ module Datadog
         # WARNING: This method breaks the Liskov Substitution Principle -- TraceWriter#perform is spec'd to return the
         # result from the writer, whereas this method always returns nil.
         def perform(traces)
-          super(traces).tap do |responses|
+          super.tap do |responses|
             loop_back_off! if responses.find(&:server_error?)
           end
 
@@ -152,16 +152,16 @@ module Datadog
 
         def fork_policy=(policy)
           # Translate to Workers::Async::Thread policy
-          thread_fork_policy =  case policy
-                                when Core::Workers::Async::Thread::FORK_POLICY_STOP
-                                  policy
-                                when FORK_POLICY_SYNC
-                                  # Stop the async thread because the writer
-                                  # will bypass and run synchronously.
-                                  Core::Workers::Async::Thread::FORK_POLICY_STOP
-                                else
-                                  Core::Workers::Async::Thread::FORK_POLICY_RESTART
-                                end
+          thread_fork_policy = case policy
+          when Core::Workers::Async::Thread::FORK_POLICY_STOP
+            policy
+          when FORK_POLICY_SYNC
+            # Stop the async thread because the writer
+            # will bypass and run synchronously.
+            Core::Workers::Async::Thread::FORK_POLICY_STOP
+          else
+            Core::Workers::Async::Thread::FORK_POLICY_RESTART
+          end
 
           # Update thread fork policy
           super(thread_fork_policy)

data/lib/datadog/tracing/workers.rb

@@ -53,7 +53,7 @@ module Datadog
             traces = @trace_buffer.pop
             traces = Pipeline.process!(traces)
             @trace_task.call(traces, @transport) unless @trace_task.nil? || traces.empty?
-          rescue StandardError => e
+          rescue => e
             # ensures that the thread will not die because of an exception.
             # TODO[manu]: findout the reason and reschedule the send if it's not
             # a fatal exception
@@ -107,7 +107,7 @@ module Datadog
 
         private
 
-        alias flush_data callback_traces
+        alias_method :flush_data, :callback_traces
 
         def perform
           loop do

data/lib/datadog/tracing.rb

@@ -81,7 +81,7 @@ module Datadog
       # @public_api
       def keep!
         trace = active_trace
-        trace.keep! if trace
+        trace&.keep!
       end
 
       # (see Datadog::Tracing::TraceSegment#reject!)
@@ -89,7 +89,7 @@ module Datadog
       # @public_api
       def reject!
         trace = active_trace
-        trace.reject! if trace
+        trace&.reject!
       end
 
       # (see Datadog::Tracing::Tracer#active_correlation)

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 19
+    MINOR = 21
     PATCH = 0
     PRE = nil
     BUILD = nil