ddtrace 0.41.0 → 0.52.0

data/lib/datadog/core/environment/socket.rb

@@ -0,0 +1,17 @@
+# typed: true
+require 'socket'
+
+module Datadog
+  module Core
+    module Environment
+      # For runtime identity
+      module Socket
+        module_function
+
+        def hostname
+          ::Socket.gethostname
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/environment/thread_count.rb

@@ -0,0 +1,19 @@
+# typed: true
+module Datadog
+  module Core
+    module Environment
+      # Retrieves number of threads from runtime
+      module ThreadCount
+        module_function
+
+        def value
+          Thread.list.count
+        end
+
+        def available?
+          Thread.respond_to?(:list)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/environment/variable_helpers.rb

@@ -0,0 +1,42 @@
+# typed: false
+module Datadog
+  module Core
+    # Namespace for handling application environment
+    module Environment
+      # Defines helper methods for environment
+      module VariableHelpers
+        extend self
+
+        def env_to_bool(var, default = nil)
+          var = decode_array(var)
+          var && ENV.key?(var) ? ENV[var].to_s.strip.downcase == 'true' : default
+        end
+
+        def env_to_int(var, default = nil)
+          var = decode_array(var)
+          var && ENV.key?(var) ? ENV[var].to_i : default
+        end
+
+        def env_to_float(var, default = nil)
+          var = decode_array(var)
+          var && ENV.key?(var) ? ENV[var].to_f : default
+        end
+
+        def env_to_list(var, default = [])
+          var = decode_array(var)
+          if var && ENV.key?(var)
+            ENV[var].split(',').map(&:strip)
+          else
+            default
+          end
+        end
+
+        private
+
+        def decode_array(var)
+          var.is_a?(Array) ? var.find { |env_var| ENV.key?(env_var) } : var
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace.rb

@@ -1,5 +1,4 @@
-require 'thread'
-
+# typed: strict
 # During development, we load `ddtrace` by through `ddtrace.gemspec`,
 # which in turn eager loads 'ddtrace/version'.
 #
@@ -15,64 +14,39 @@ require 'ddtrace/quantization/http'
 require 'ddtrace/pipeline'
 require 'ddtrace/configuration'
 require 'ddtrace/patcher'
-require 'ddtrace/augmentation'
 require 'ddtrace/metrics'
+require 'ddtrace/auto_instrument_base'
+require 'ddtrace/profiling'
+
+require 'datadog/contrib'
+require 'ddtrace/contrib/auto_instrument'
+require 'ddtrace/contrib/extensions'
+
+require 'ddtrace/opentelemetry/extensions'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
-  extend Augmentation
   extend Configuration
+  extend AutoInstrumentBase
 
-  # Load and extend Contrib by default
-  require 'ddtrace/contrib/extensions'
+  # Load built-in Datadog integrations
   extend Contrib::Extensions
+  # Load Contrib auto instrumentation
+  extend Contrib::AutoInstrument
+  # Load Contrib extension to global Datadog objects
+  Configuration::Settings.include Contrib::Extensions::Configuration::Settings
 
   # Load and extend OpenTelemetry compatibility by default
-  require 'ddtrace/opentelemetry/extensions'
   extend OpenTelemetry::Extensions
 
   # Add shutdown hook:
   # Ensures the tracer has an opportunity to flush traces
   # and cleanup before terminating the process.
-  at_exit { Datadog.shutdown! }
+  at_exit do
+    if Interrupt === $! # rubocop:disable Style/SpecialGlobalVars is process terminating due to a ctrl+c or similar?
+      Datadog.send(:handle_interrupt_shutdown!)
+    else
+      Datadog.shutdown!
+    end
+  end
 end
-
-require 'ddtrace/contrib/action_cable/integration'
-require 'ddtrace/contrib/action_pack/integration'
-require 'ddtrace/contrib/action_view/integration'
-require 'ddtrace/contrib/active_model_serializers/integration'
-require 'ddtrace/contrib/active_record/integration'
-require 'ddtrace/contrib/active_support/integration'
-require 'ddtrace/contrib/aws/integration'
-require 'ddtrace/contrib/concurrent_ruby/integration'
-require 'ddtrace/contrib/dalli/integration'
-require 'ddtrace/contrib/delayed_job/integration'
-require 'ddtrace/contrib/elasticsearch/integration'
-require 'ddtrace/contrib/ethon/integration'
-require 'ddtrace/contrib/excon/integration'
-require 'ddtrace/contrib/faraday/integration'
-require 'ddtrace/contrib/grape/integration'
-require 'ddtrace/contrib/graphql/integration'
-require 'ddtrace/contrib/grpc/integration'
-require 'ddtrace/contrib/http/integration'
-require 'ddtrace/contrib/httprb/integration'
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/kafka/integration'
-require 'ddtrace/contrib/presto/integration'
-require 'ddtrace/contrib/que/integration'
-require 'ddtrace/contrib/mysql2/integration'
-require 'ddtrace/contrib/mongodb/integration'
-require 'ddtrace/contrib/racecar/integration'
-require 'ddtrace/contrib/rack/integration'
-require 'ddtrace/contrib/rails/integration'
-require 'ddtrace/contrib/rake/integration'
-require 'ddtrace/contrib/redis/integration'
-require 'ddtrace/contrib/resque/integration'
-require 'ddtrace/contrib/rest_client/integration'
-require 'ddtrace/contrib/sequel/integration'
-require 'ddtrace/contrib/shoryuken/integration'
-require 'ddtrace/contrib/sidekiq/integration'
-require 'ddtrace/contrib/sinatra/integration'
-require 'ddtrace/contrib/sneakers/integration'
-require 'ddtrace/contrib/sucker_punch/integration'
-require 'ddtrace/monkey'

data/lib/ddtrace/analytics.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/ext/analytics'
 
 module Datadog
@@ -6,11 +7,13 @@ module Datadog
     class << self
       def set_sample_rate(span, sample_rate)
         return if span.nil? || !sample_rate.is_a?(Numeric)
+
         span.set_metric(Datadog::Ext::Analytics::TAG_SAMPLE_RATE, sample_rate)
       end
 
       def set_measured(span, value = true)
         return if span.nil?
+
         # rubocop:disable Style/MultipleComparison
         value = value == true || value == 1 ? 1 : 0
         span.set_metric(Datadog::Ext::Analytics::TAG_MEASURED, value)

data/lib/ddtrace/auto_instrument.rb

@@ -0,0 +1,5 @@
+# typed: strict
+require 'ddtrace'
+
+Datadog.add_auto_instrument
+Datadog.profiler.start if Datadog.profiler

data/lib/ddtrace/auto_instrument_base.rb

@@ -0,0 +1,7 @@
+# typed: true
+module Datadog
+  # base methods stubbed for adding auto instrument extensions
+  module AutoInstrumentBase
+    def add_auto_instrument; end
+  end
+end

data/lib/ddtrace/buffer.rb

@@ -1,136 +1,179 @@
-require 'thread'
+# typed: true
 require 'ddtrace/diagnostics/health'
-require 'ddtrace/runtime/object_space'
 
 # Trace buffer that accumulates traces for a consumer.
 # Consumption can happen from a different thread.
 module Datadog
-  # Aggregate metrics:
-  # They reflect buffer activity since last #pop.
-  # These may not be as accurate or as granular, but they
-  # don't use as much network traffic as live stats.
-  class MeasuredBuffer
-    def initialize
-      @buffer_accepted = 0
-      @buffer_accepted_lengths = 0
-      @buffer_dropped = 0
-      @buffer_spans = 0
+  # Buffer that stores objects. The buffer has a maximum size and when
+  # the buffer is full, a random object is discarded.
+  class Buffer
+    def initialize(max_size)
+      @max_size = max_size
+      @items = []
+      @closed = false
     end
 
-    def measure_accept(trace)
-      @buffer_accepted += 1
-      @buffer_accepted_lengths += trace.length
+    # Add a new ``item`` in the local queue. This method doesn't block the execution
+    # even if the buffer is full. In that case, a random item is discarded.
+    def push(item)
+      return if closed?
 
-      @buffer_spans += trace.length
-    rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
+      full? ? replace!(item) : add!(item)
+      item
     end
 
-    def measure_drop(trace)
-      @buffer_dropped += 1
+    # A bulk push alternative to +#push+. Use this method if
+    # pushing more than one item for efficiency.
+    def concat(items)
+      return if closed?
 
-      @buffer_spans -= trace.length
-    rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
+      # Segment items into underflow and overflow
+      underflow, overflow = overflow_segments(items)
+
+      # Concatenate items do not exceed capacity.
+      add_all!(underflow) unless underflow.nil?
+
+      # Iteratively replace items, to ensure pseudo-random replacement.
+      overflow.each { |item| replace!(item) } unless overflow.nil?
     end
 
-    def measure_pop(traces)
-      # Accepted, cumulative totals
-      Datadog.health_metrics.queue_accepted(@buffer_accepted)
-      Datadog.health_metrics.queue_accepted_lengths(@buffer_accepted_lengths)
+    # Stored items are returned and the local buffer is reset.
+    def pop
+      drain!
+    end
 
-      # Dropped, cumulative totals
-      Datadog.health_metrics.queue_dropped(@buffer_dropped)
-      # TODO: are we missing a +queue_dropped_lengths+ metric?
+    # Return the current number of stored traces.
+    def length
+      @items.length
+    end
 
-      # Queue gauges, current values
-      Datadog.health_metrics.queue_max_length(@max_size)
-      Datadog.health_metrics.queue_spans(@buffer_spans)
-      Datadog.health_metrics.queue_length(traces.length)
+    # Return if the buffer is empty.
+    def empty?
+      @items.empty?
+    end
 
-      # Reset aggregated metrics
-      @buffer_accepted = 0
-      @buffer_accepted_lengths = 0
-      @buffer_dropped = 0
-      @buffer_spans = 0
-    rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
+    # Closes this buffer, preventing further pushing.
+    # Draining is still allowed.
+    def close
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+
+    protected
+
+    # Segment items into two distinct segments: underflow and overflow.
+    # Underflow are items that will fit into buffer.
+    # Overflow are items that will exceed capacity, after underflow is added.
+    # Returns each array, and nil if there is no underflow/overflow.
+    def overflow_segments(items)
+      underflow = nil
+      overflow = nil
+
+      overflow_size = @max_size > 0 ? (@items.length + items.length) - @max_size : 0
+
+      if overflow_size > 0
+        # Items will overflow
+        if overflow_size < items.length
+          # Partial overflow
+          underflow_end_index = items.length - overflow_size - 1
+          underflow = items[0..underflow_end_index]
+          overflow = items[(underflow_end_index + 1)..-1]
+        else
+          # Total overflow
+          overflow = items
+        end
+      else
+        # Items do not exceed capacity.
+        underflow = items
+      end
+
+      [underflow, overflow]
+    end
+
+    def full?
+      @max_size > 0 && @items.length >= @max_size
+    end
+
+    def add_all!(items)
+      @items.concat(items)
+    end
+
+    def add!(item)
+      @items << item
+    end
+
+    def replace!(item)
+      # Choose random item to be replaced
+      replace_index = rand(@items.length)
+
+      # Replace random item
+      discarded_item = @items[replace_index]
+      @items[replace_index] = item
+
+      # Return discarded item
+      discarded_item
+    end
+
+    def drain!
+      items = @items
+      @items = []
+      items
     end
   end
 
-  # Trace buffer that stores application traces and
+  # Buffer that stores objects, has a maximum size, and
   # can be safely used concurrently on any environment.
   #
   # This implementation uses a {Mutex} around public methods, incurring
-  # overhead in order to ensure full thread-safety.
+  # overhead in order to ensure thread-safety.
   #
   # This is implementation is recommended for non-CRuby environments.
-  # If using CRuby, {Datadog::CRubyTraceBuffer} is a faster implementation with minimal compromise.
-  class ThreadSafeBuffer < MeasuredBuffer
+  # If using CRuby, {Datadog::CRubyBuffer} is a faster implementation with minimal compromise.
+  class ThreadSafeBuffer < Buffer
     def initialize(max_size)
-      super()
+      super
 
-      @max_size = max_size
-
-      @mutex = Mutex.new()
-      @traces = []
-      @closed = false
+      @mutex = Mutex.new
     end
 
-    # Add a new ``trace`` in the local queue. This method doesn't block the execution
-    # even if the buffer is full. In that case, a random trace is discarded.
-    def push(trace)
-      @mutex.synchronize do
-        return if @closed
-        len = @traces.length
-        if len < @max_size || @max_size <= 0
-          @traces << trace
-        else
-          # we should replace a random trace with the new one
-          replace_index = rand(len)
-          replaced_trace = @traces[replace_index]
-          @traces[replace_index] = trace
-          measure_drop(replaced_trace)
-        end
+    # Add a new ``item`` in the local queue. This method doesn't block the execution
+    # even if the buffer is full. In that case, a random item is discarded.
+    def push(item)
+      synchronize { super }
+    end
 
-        measure_accept(trace)
-      end
+    def concat(items)
+      synchronize { super }
     end
 
     # Return the current number of stored traces.
     def length
-      @mutex.synchronize do
-        return @traces.length
-      end
+      synchronize { super }
     end
 
     # Return if the buffer is empty.
     def empty?
-      @mutex.synchronize do
-        return @traces.empty?
-      end
+      synchronize { super }
     end
 
     # Stored traces are returned and the local buffer is reset.
     def pop
-      @mutex.synchronize do
-        traces = @traces
-        @traces = []
-
-        measure_pop(traces)
-
-        return traces
-      end
+      synchronize { super }
     end
 
     def close
-      @mutex.synchronize do
-        @closed = true
-      end
+      synchronize { super }
+    end
+
+    def synchronize(&block)
+      @mutex.synchronize(&block)
     end
   end
 
-  # Trace buffer that stores application traces and
+  # Buffer that stores objects, has a maximum size, and
   # can be safely used concurrently with CRuby.
   #
   # Under extreme concurrency scenarios, this class can exceed
@@ -151,80 +194,135 @@ module Datadog
   #
   # @see spec/ddtrace/benchmark/buffer_benchmark_spec.rb Buffer benchmarks
   # @see https://github.com/ruby-concurrency/concurrent-ruby/blob/c1114a0c6891d9634f019f1f9fe58dcae8658964/lib/concurrent-ruby/concurrent/array.rb#L23-L27
-  class CRubyTraceBuffer < MeasuredBuffer
-    def initialize(max_size)
-      super()
+  class CRubyBuffer < Buffer
+    # Add a new ``trace`` in the local queue. This method doesn't block the execution
+    # even if the buffer is full. In that case, a random trace is discarded.
+    def replace!(item)
+      # we should replace a random trace with the new one
+      replace_index = rand(@items.size)
+      replaced_trace = @items.delete_at(replace_index)
+      @items << item
+
+      # We might have deleted an element right when the buffer
+      # was drained, thus +replaced_trace+ will be +nil+.
+      # In that case, nothing was replaced, and this method
+      # performed a simple insertion into the buffer.
+      replaced_trace
+    end
+  end
 
-      @max_size = max_size
+  # Health metrics for trace buffers.
+  module MeasuredBuffer
+    include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
 
-      @traces = []
-      @closed = false
+    def initialize(*_)
+      super
+
+      @buffer_accepted = 0
+      @buffer_accepted_lengths = 0
+      @buffer_dropped = 0
+      @buffer_spans = 0
     end
 
-    # Add a new ``trace`` in the local queue. This method doesn't block the execution
-    # even if the buffer is full. In that case, a random trace is discarded.
-    def push(trace)
-      return if @closed
-      len = @traces.length
-      if len < @max_size || @max_size <= 0
-        @traces << trace
-      else
-        # we should replace a random trace with the new one
-        replace_index = rand(len)
-        replaced_trace = @traces.delete_at(replace_index)
-        @traces << trace
-
-        # Check if we deleted the element right when the buffer
-        # was popped. In that case we didn't actually delete anything,
-        # we just inserted into a newly cleared buffer instead.
-        measure_drop(replaced_trace) if replaced_trace
-      end
+    def add!(trace)
+      super
 
+      # Emit health metrics
       measure_accept(trace)
     end
 
-    # Return the current number of stored traces.
-    def length
-      @traces.length
-    end
+    def add_all!(traces)
+      super
 
-    # Return if the buffer is empty.
-    def empty?
-      @traces.empty?
+      # Emit health metrics
+      traces.each { |trace| measure_accept(trace) }
     end
 
-    # Return all traces stored and reset buffer.
-    def pop
-      traces = @traces.pop(VERY_LARGE_INTEGER)
+    def replace!(trace)
+      discarded_trace = super
 
-      measure_pop(traces)
+      # Emit health metrics
+      measure_accept(trace)
+      measure_drop(discarded_trace) if discarded_trace
 
+      discarded_trace
+    end
+
+    # Stored traces are returned and the local buffer is reset.
+    def drain!
+      traces = super
+      measure_pop(traces)
       traces
     end
 
-    # Very large value, to ensure that we drain the whole buffer.
-    # 1<<62-1 happens to be the largest integer that can be stored inline in CRuby.
-    VERY_LARGE_INTEGER = 1 << 62 - 1
+    def measure_accept(trace)
+      @buffer_accepted += 1
+      @buffer_accepted_lengths += trace.length
 
-    def close
-      @closed = true
+      @buffer_spans += trace.length
+    rescue StandardError => e
+      Datadog.logger.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
+    end
+
+    def measure_drop(trace)
+      @buffer_dropped += 1
+
+      @buffer_spans -= trace.length
+    rescue StandardError => e
+      Datadog.logger.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
+    end
+
+    def measure_pop(traces)
+      # Accepted, cumulative totals
+      Datadog.health_metrics.queue_accepted(@buffer_accepted)
+      Datadog.health_metrics.queue_accepted_lengths(@buffer_accepted_lengths)
+
+      # Dropped, cumulative totals
+      Datadog.health_metrics.queue_dropped(@buffer_dropped)
+      # TODO: are we missing a +queue_dropped_lengths+ metric?
+
+      # Queue gauges, current values
+      Datadog.health_metrics.queue_max_length(@max_size)
+      Datadog.health_metrics.queue_spans(@buffer_spans)
+      Datadog.health_metrics.queue_length(traces.length)
+
+      # Reset aggregated metrics
+      @buffer_accepted = 0
+      @buffer_accepted_lengths = 0
+      @buffer_dropped = 0
+      @buffer_spans = 0
+    rescue StandardError => e
+      Datadog.logger.debug("Failed to measure queue. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
     end
   end
 
-  # Choose default TraceBuffer implementation for current platform.
-  BUFFER_IMPLEMENTATION = if Datadog::Ext::Runtime::RUBY_ENGINE == 'ruby'
-                            CRubyTraceBuffer
-                          else
-                            ThreadSafeBuffer
-                          end
-  private_constant :BUFFER_IMPLEMENTATION
+  # Trace buffer that stores application traces, has a maximum size, and
+  # can be safely used concurrently on any environment.
+  #
+  # @see {Datadog::ThreadSafeBuffer}
+  class ThreadSafeTraceBuffer < ThreadSafeBuffer
+    prepend MeasuredBuffer
+  end
+
+  # Trace buffer that stores application traces, has a maximum size, and
+  # can be safely used concurrently with CRuby.
+  #
+  # @see {Datadog::CRubyBuffer}
+  class CRubyTraceBuffer < CRubyBuffer
+    prepend MeasuredBuffer
+  end
 
   # Trace buffer that stores application traces. The buffer has a maximum size and when
   # the buffer is full, a random trace is discarded. This class is thread-safe and is used
   # automatically by the ``Tracer`` instance when a ``Span`` is finished.
   #
+  # We choose the default TraceBuffer implementation for current platform dynamically here.
+  #
   # TODO We should restructure this module, so that classes are not declared at top-level ::Datadog.
   # TODO Making such a change is potentially breaking for users manually configuring the tracer.
-  class TraceBuffer < BUFFER_IMPLEMENTATION
-  end
+  TraceBuffer = if Datadog::Core::Environment::Ext::RUBY_ENGINE == 'ruby'
+                  CRubyTraceBuffer
+                else
+                  ThreadSafeTraceBuffer
+                end
 end