ddtrace 0.38.0

data/lib/ddtrace.rb

@@ -0,0 +1,76 @@
+require 'thread'
+
+# During development, we load `ddtrace` by through `ddtrace.gemspec`,
+# which in turn eager loads 'ddtrace/version'.
+#
+# Users load this gem by requiring this file.
+# We need to ensure that any files loaded in our gemspec are also loaded here.
+require 'ddtrace/version'
+
+require 'ddtrace/pin'
+require 'ddtrace/tracer'
+require 'ddtrace/error'
+require 'ddtrace/quantization/hash'
+require 'ddtrace/quantization/http'
+require 'ddtrace/pipeline'
+require 'ddtrace/configuration'
+require 'ddtrace/patcher'
+require 'ddtrace/augmentation'
+require 'ddtrace/metrics'
+
+# \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
+module Datadog
+  extend Augmentation
+  extend Configuration
+
+  # Load and extend Contrib by default
+  require 'ddtrace/contrib/extensions'
+  extend Contrib::Extensions
+
+  # 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! }
+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/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/sucker_punch/integration'
+require 'ddtrace/monkey'

data/lib/ddtrace/analytics.rb

@@ -0,0 +1,36 @@
+require 'ddtrace/ext/analytics'
+
+module Datadog
+  # Defines analytics behavior
+  module Analytics
+    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)
+      end
+    end
+
+    # Extension for Datadog::Span
+    module Span
+      def set_tag(key, value)
+        case key
+        when Ext::Analytics::TAG_ENABLED
+          # If true, set rate to 1.0, otherwise set 0.0.
+          value = value == true ? Ext::Analytics::DEFAULT_SAMPLE_RATE : 0.0
+          Analytics.set_sample_rate(self, value)
+        when Ext::Analytics::TAG_SAMPLE_RATE
+          Analytics.set_sample_rate(self, value)
+        else
+          super if defined?(super)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/augmentation.rb

@@ -0,0 +1,13 @@
+require 'ddtrace/augmentation/method_wrapper'
+require 'ddtrace/augmentation/method_wrapping'
+require 'ddtrace/augmentation/shim'
+
+module Datadog
+  # Namespace for components that help modify
+  # existing code for instrumentation purposes.
+  module Augmentation
+    def shim(object, &block)
+      Shim.new(object, &block)
+    end
+  end
+end

data/lib/ddtrace/augmentation/method_wrapper.rb

@@ -0,0 +1,20 @@
+module Datadog
+  # Represents an wrapped method, with a reference to the original block
+  # and the block that wraps around it.
+  class MethodWrapper
+    attr_reader \
+      :original,
+      :wrapper
+
+    DEFAULT_WRAPPER = proc { |original, *args, &block| original.call(*args, &block) }
+
+    def initialize(original, &block)
+      @original = original
+      @wrapper = block_given? ? block : DEFAULT_WRAPPER
+    end
+
+    def call(*args, &block)
+      wrapper.call(original, *args, &block)
+    end
+  end
+end

data/lib/ddtrace/augmentation/method_wrapping.rb

@@ -0,0 +1,38 @@
+require 'set'
+require 'ddtrace/patcher'
+
+module Datadog
+  # Shorthands for wrapping methods
+  module MethodWrapping
+    include Datadog::Patcher
+
+    def wrapped_methods
+      @wrapped_methods ||= Set.new
+    end
+
+    # Adds method block directly to the object.
+    # Block is evaluated in the context of the object.
+    # Faster than #wrap_method!
+    def override_method!(method_name, &block)
+      return unless block_given?
+
+      without_warnings do
+        define_singleton_method(method_name, &block).tap do
+          wrapped_methods.add(method_name)
+        end
+      end
+    end
+
+    # Adds method wrapper to the object.
+    # Block is evaluated in the original context of the block.
+    # Slower than #override_method!
+    def wrap_method!(original_method, &block)
+      return unless block_given?
+      original_method = original_method.is_a?(Symbol) ? method(original_method) : original_method
+
+      override_method!(original_method.name) do |*original_args, &original_block|
+        block.call(original_method, *original_args, &original_block)
+      end
+    end
+  end
+end

data/lib/ddtrace/augmentation/shim.rb

@@ -0,0 +1,102 @@
+require 'set'
+require 'ddtrace/patcher'
+require 'ddtrace/augmentation/method_wrapping'
+
+module Datadog
+  # A "stand-in" that intercepts calls to another object. i.e. man-in-the-middle.
+  # This shim forwards all methods to object, except those overriden.
+  # Useful if you want to intercept inbound behavior to an object without modifying
+  # the object in question, especially useful if the overridding behavior shouldn't be global.
+  class Shim
+    extend Forwardable
+    include Datadog::Patcher
+    include Datadog::MethodWrapping
+
+    METHODS = Set[
+      :override_method!,
+      :shim,
+      :shim?,
+      :shim_target,
+      :wrap_method!,
+      :wrapped_methods
+    ].freeze
+
+    EXCLUDED_METHODS = Set[
+      # For all objects
+      :__binding__,
+      :__id__,
+      :__send__,
+      :extend,
+      :itself,
+      :object_id,
+      :respond_to?,
+      :tap
+    ].freeze
+
+    attr_reader :shim_target, :shim
+
+    def self.shim?(object)
+      # Check whether it responds to #shim? because otherwise the
+      # Shim forwards all method calls, including type checks to
+      # the wrapped object, to mimimize its intrusion.
+      object.respond_to?(:shim?)
+    end
+
+    # Pass this a block to override methods
+    def initialize(shim_target)
+      @shim = self
+      @shim_target = shim_target
+
+      # Save a reference to the original :define_singleton_method
+      # so methods can be defined on the shim after forwarding is applied.
+      @definition_method = method(:define_singleton_method)
+
+      # Wrap any methods
+      yield(self) if block_given?
+
+      # Forward methods
+      forwarded_methods = (
+        shim_target.public_methods.to_set \
+        - METHODS \
+        - EXCLUDED_METHODS \
+        - wrapped_methods
+      )
+      forward_methods!(*forwarded_methods)
+    end
+
+    def override_method!(method_name, &block)
+      return unless block_given?
+
+      without_warnings do
+        @definition_method.call(method_name, &block).tap do
+          wrapped_methods.add(method_name)
+        end
+      end
+    end
+
+    def wrap_method!(method_name, &block)
+      super(shim_target.method(method_name), &block)
+    end
+
+    def shim?
+      true
+    end
+
+    def respond_to?(method_name)
+      return true if METHODS.include?(method_name)
+      shim_target.respond_to?(method_name)
+    end
+
+    private
+
+    def forward_methods!(*forwarded_methods)
+      return if forwarded_methods.empty?
+
+      singleton_class.send(
+        :def_delegators,
+        :@shim_target,
+        *forwarded_methods
+      )
+    end
+  end
+end

data/lib/ddtrace/buffer.rb

@@ -0,0 +1,119 @@
+require 'thread'
+require 'ddtrace/diagnostics/health'
+require 'ddtrace/runtime/object_space'
+
+module Datadog
+  # 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.
+  class TraceBuffer
+    def initialize(max_size)
+      @max_size = max_size
+
+      @mutex = Mutex.new()
+      @traces = []
+      @closed = false
+
+      # Initialize metric values
+      @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)
+      @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
+
+        measure_accept(trace)
+      end
+    end
+
+    # Return the current number of stored traces.
+    def length
+      @mutex.synchronize do
+        return @traces.length
+      end
+    end
+
+    # Return if the buffer is empty.
+    def empty?
+      @mutex.synchronize do
+        return @traces.empty?
+      end
+    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
+    end
+
+    def close
+      @mutex.synchronize do
+        @closed = true
+      end
+    end
+
+    # 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.
+
+    def measure_accept(trace)
+      @buffer_spans += trace.length
+      @buffer_accepted += 1
+      @buffer_accepted_lengths += trace.length
+    rescue StandardError => e
+      Datadog.logger.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+
+    def measure_drop(trace)
+      @buffer_dropped += 1
+      @buffer_spans -= trace.length
+      @buffer_accepted_lengths -= trace.length
+    rescue StandardError => e
+      Datadog.logger.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+
+    def measure_pop(traces)
+      # Accepted
+      Datadog.health_metrics.queue_accepted(@buffer_accepted)
+      Datadog.health_metrics.queue_accepted_lengths(@buffer_accepted_lengths)
+
+      # Dropped
+      Datadog.health_metrics.queue_dropped(@buffer_dropped)
+
+      # Queue gauges
+      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: #{e.backtrace.first}")
+    end
+  end
+end

data/lib/ddtrace/chunker.rb

@@ -0,0 +1,34 @@
+require 'json'
+require 'msgpack'
+
+module Datadog
+  # Chunks list of elements into batches
+  module Chunker
+    module_function
+
+    # Chunks a list into batches of at most +max_chunk_size+ elements each.
+    #
+    # An exception can occur if a single element is too large. That single
+    # element will be returned in its own chunk. You have to verify by yourself
+    # when such elements are returned.
+    #
+    # @param list [Enumerable] list of elements
+    # @param max_chunk_size [Numeric] maximum acceptable chunk size
+    # @return [Enumerable] lazy list of chunks
+    def chunk_by_size(list, max_chunk_size)
+      chunk_agg = 0
+      list.slice_before do |elem|
+        size = elem.size
+        chunk_agg += size
+        if chunk_agg > max_chunk_size
+          # Can't fit element in current chunk, start a new one.
+          chunk_agg = size
+          true
+        else
+          # Add to current chunk
+          false
+        end
+      end
+    end
+  end
+end