ddtrace 0.50.0 → 1.0.0

data/lib/ddtrace/configuration.rb

@@ -1,176 +0,0 @@
-require 'forwardable'
-require 'ddtrace/configuration/pin_setup'
-require 'ddtrace/configuration/settings'
-require 'ddtrace/configuration/components'
-
-module Datadog
-  # Configuration provides a unique access point for configurations
-  module Configuration
-    extend Forwardable
-
-    # Used to ensure that @components initialization/reconfiguration is performed one-at-a-time, by a single thread.
-    #
-    # This is important because components can end up being accessed from multiple application threads (for instance on
-    # a threaded webserver), and we don't want their initialization to clash (for instance, starting two profilers...).
-    #
-    # Note that a Mutex **IS NOT** reentrant: the same thread cannot grab the same Mutex more than once.
-    # This means below we are careful not to nest calls to methods that would trigger initialization and grab the lock.
-    #
-    # Every method that directly or indirectly mutates @components should be holding the lock (through
-    # #safely_synchronize) while doing so.
-    COMPONENTS_WRITE_LOCK = Mutex.new
-    private_constant :COMPONENTS_WRITE_LOCK
-
-    # We use a separate lock when reading the @components, so that they continue to be accessible during reconfiguration.
-    # This was needed because we ran into several issues where we still needed to read the old
-    # components while the COMPONENTS_WRITE_LOCK was being held (see https://github.com/DataDog/dd-trace-rb/pull/1387
-    # and https://github.com/DataDog/dd-trace-rb/pull/1373#issuecomment-799593022 ).
-    #
-    # Technically on MRI we could get away without this lock, but on non-MRI Rubies, we may run into issues because
-    # we fall into the "UnsafeDCLFactory" case of https://shipilev.net/blog/2014/safe-public-construction/ .
-    # Specifically, on JRuby reads from the @components do NOT have volatile semantics, and on TruffleRuby they do
-    # BUT just as an implementation detail, see https://github.com/jruby/jruby/wiki/Concurrency-in-jruby#volatility and
-    # https://github.com/DataDog/dd-trace-rb/pull/1329#issuecomment-776750377 .
-    # Concurrency is hard.
-    COMPONENTS_READ_LOCK = Mutex.new
-    private_constant :COMPONENTS_READ_LOCK
-
-    attr_writer :configuration
-
-    def configuration
-      @configuration ||= Settings.new
-    end
-
-    def configure(target = configuration, opts = {})
-      if target.is_a?(Settings)
-        yield(target) if block_given?
-
-        safely_synchronize do |write_components|
-          write_components.call(
-            if components?
-              replace_components!(target, @components)
-            else
-              build_components(target)
-            end
-          )
-        end
-
-        target
-      else
-        PinSetup.new(target, opts).call
-      end
-    end
-
-    def_delegators \
-      :components,
-      :health_metrics,
-      :profiler,
-      :runtime_metrics,
-      :tracer
-
-    def logger
-      # avoid initializing components if they didn't already exist
-      current_components = components(allow_initialization: false)
-
-      if current_components
-        @temp_logger = nil
-        current_components.logger
-      else
-        logger_without_components
-      end
-    end
-
-    # Gracefully shuts down all components.
-    #
-    # Components will still respond to method calls as usual,
-    # but might not internally perform their work after shutdown.
-    #
-    # This avoids errors being raised across the host application
-    # during shutdown, while allowing for graceful decommission of resources.
-    #
-    # Components won't be automatically reinitialized after a shutdown.
-    def shutdown!
-      safely_synchronize do
-        @components.shutdown! if components?
-      end
-    end
-
-    protected
-
-    def components(allow_initialization: true)
-      current_components = COMPONENTS_READ_LOCK.synchronize { defined?(@components) && @components }
-      return current_components if current_components || !allow_initialization
-
-      safely_synchronize do |write_components|
-        (defined?(@components) && @components) || write_components.call(build_components(configuration))
-      end
-    end
-
-    private
-
-    # Gracefully shuts down the tracer and disposes of component references,
-    # allowing execution to start anew.
-    #
-    # In contrast with +#shutdown!+, components will be automatically
-    # reinitialized after a reset.
-    #
-    # Used internally to ensure a clean environment between test runs.
-    def reset!
-      safely_synchronize do |write_components|
-        @components.shutdown! if components?
-        write_components.call(nil)
-        configuration.reset!
-      end
-    end
-
-    def safely_synchronize
-      # Writes to @components should only happen through this proc. Because this proc is only accessible to callers of
-      # safely_synchronize, this forces all writers to go through this method.
-      write_components = proc do |new_value|
-        COMPONENTS_READ_LOCK.synchronize { @components = new_value }
-      end
-
-      COMPONENTS_WRITE_LOCK.synchronize do
-        begin
-          yield write_components
-        rescue ThreadError => e
-          logger_without_components.error(
-            'Detected deadlock during ddtrace initialization. ' \
-            'Please report this at https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug' \
-            "\n\tSource:\n\t#{e.backtrace.join("\n\t")}"
-          )
-          nil
-        end
-      end
-    end
-
-    def components?
-      # This does not need to grab the COMPONENTS_READ_LOCK because it's not returning the components
-      (defined?(@components) && @components) != nil
-    end
-
-    def build_components(settings)
-      components = Components.new(settings)
-      components.startup!(settings)
-      components
-    end
-
-    def replace_components!(settings, old)
-      components = Components.new(settings)
-
-      old.shutdown!(components)
-      components.startup!(settings)
-      components
-    end
-
-    def logger_without_components
-      # Use default logger without initializing components.
-      # This enables logging during initialization, otherwise we'd run into deadlocks.
-      @temp_logger ||= begin
-        logger = configuration.logger.instance || Datadog::Logger.new($stdout)
-        logger.level = configuration.diagnostics.debug ? ::Logger::DEBUG : configuration.logger.level
-        logger
-      end
-    end
-  end
-end

data/lib/ddtrace/context.rb

@@ -1,325 +0,0 @@
-require 'ddtrace/diagnostics/health'
-
-require 'ddtrace/context_flush'
-require 'ddtrace/context_provider'
-require 'ddtrace/utils/forking'
-
-module Datadog
-  # \Context is used to keep track of a hierarchy of spans for the current
-  # execution flow. During each logical execution, the same \Context is
-  # used to represent a single logical trace, even if the trace is built
-  # asynchronously.
-  #
-  # A single code execution may use multiple \Context if part of the execution
-  # must not be related to the current tracing. As example, a delayed job may
-  # compose a standalone trace instead of being related to the same trace that
-  # generates the job itself. On the other hand, if it's part of the same
-  # \Context, it will be related to the original trace.
-  #
-  # This data structure is thread-safe.
-  # rubocop:disable Metrics/ClassLength
-  class Context
-    include Datadog::Utils::Forking
-
-    # 100k spans is about a 100Mb footprint
-    DEFAULT_MAX_LENGTH = 100_000
-
-    attr_reader :max_length
-
-    # Initialize a new thread-safe \Context.
-    def initialize(options = {})
-      @mutex = Mutex.new
-      # max_length is the amount of spans above which, for a given trace,
-      # the context will simply drop and ignore spans, avoiding high memory usage.
-      @max_length = options.fetch(:max_length, DEFAULT_MAX_LENGTH)
-      reset(options)
-    end
-
-    def trace_id
-      @mutex.synchronize do
-        @parent_trace_id
-      end
-    end
-
-    def span_id
-      @mutex.synchronize do
-        @parent_span_id
-      end
-    end
-
-    def sampling_priority
-      @mutex.synchronize do
-        @sampling_priority
-      end
-    end
-
-    def sampling_priority=(priority)
-      @mutex.synchronize do
-        @sampling_priority = priority
-      end
-    end
-
-    def origin
-      @mutex.synchronize do
-        @origin
-      end
-    end
-
-    def origin=(origin)
-      @mutex.synchronize do
-        @origin = origin
-      end
-    end
-
-    # Return the last active span that corresponds to the last inserted
-    # item in the trace list. This cannot be considered as the current active
-    # span in asynchronous environments, because some spans can be closed
-    # earlier while child spans still need to finish their traced execution.
-    def current_span
-      @mutex.synchronize do
-        return @current_span
-      end
-    end
-
-    def current_root_span
-      @mutex.synchronize do
-        return @current_root_span
-      end
-    end
-
-    # Add a span to the context trace list, keeping it as the last active span.
-    def add_span(span)
-      @mutex.synchronize do
-        # If hitting the hard limit, just drop spans. This is really a rare case
-        # as it means despite the soft limit, the hard limit is reached, so the trace
-        # by default has 10000 spans, all of which belong to unfinished parts of a
-        # larger trace. This is a catch-all to reduce global memory usage.
-        if @max_length > 0 && @trace.length >= @max_length
-          # Detach the span from any context, it's being dropped and ignored.
-          span.context = nil
-          Datadog.logger.debug("context full, ignoring span #{span.name}")
-
-          # If overflow has already occurred, don't send this metric.
-          # Prevents metrics spam if buffer repeatedly overflows for the same trace.
-          unless @overflow
-            Datadog.health_metrics.error_context_overflow(1, tags: ["max_length:#{@max_length}"])
-            @overflow = true
-          end
-
-          return
-        end
-        set_current_span(span)
-        @current_root_span = span if @trace.empty?
-        @trace << span
-        span.context = self
-      end
-    end
-
-    # Mark a span as a finished, increasing the internal counter to prevent
-    # cycles inside _trace list.
-    def close_span(span)
-      @mutex.synchronize do
-        @finished_spans += 1
-        # Current span is only meaningful for linear tree-like traces,
-        # in other cases, this is just broken and one should rely
-        # on per-instrumentation code to retrieve handle parent/child relations.
-        set_current_span(span.parent)
-        return if span.tracer.nil?
-
-        if span.parent.nil? && !all_spans_finished?
-          if Datadog.configuration.diagnostics.debug
-            opened_spans = @trace.length - @finished_spans
-            Datadog.logger.debug("root span #{span.name} closed but has #{opened_spans} unfinished spans:")
-          end
-
-          @trace.reject(&:finished?).group_by(&:name).each do |unfinished_span_name, unfinished_spans|
-            Datadog.logger.debug("unfinished span: #{unfinished_spans.first}") if Datadog.configuration.diagnostics.debug
-            Datadog.health_metrics.error_unfinished_spans(
-              unfinished_spans.length,
-              tags: ["name:#{unfinished_span_name}"]
-            )
-          end
-        end
-      end
-    end
-
-    # Returns if the trace for the current Context is finished or not. A \Context
-    # is considered finished if all spans in this context are finished.
-    def finished?
-      @mutex.synchronize do
-        return all_spans_finished?
-      end
-    end
-
-    # @@return [Numeric] numbers of finished spans
-    def finished_span_count
-      @mutex.synchronize do
-        @finished_spans
-      end
-    end
-
-    # Returns true if the context is sampled, that is, if it should be kept
-    # and sent to the trace agent.
-    def sampled?
-      @mutex.synchronize do
-        return @sampled
-      end
-    end
-
-    # Returns both the trace list generated in the current context and
-    # if the context is sampled or not.
-    #
-    # It returns +[nil,@sampled]+ if the \Context is
-    # not finished.
-    #
-    # If a trace is returned, the \Context will be reset so that it
-    # can be re-used immediately.
-    #
-    # This operation is thread-safe.
-    #
-    # @return [Array<Array<Span>, Boolean>] finished trace and sampled flag
-    def get
-      @mutex.synchronize do
-        trace = @trace
-        sampled = @sampled
-
-        # still return sampled attribute, even if context is not finished
-        return nil, sampled unless all_spans_finished?
-
-        # Root span is finished at this point, we can configure it
-        annotate_for_flush!(@current_root_span)
-
-        # Allow caller to modify trace before context is reset
-        yield(trace) if block_given?
-
-        reset
-        [trace, sampled]
-      end
-    end
-
-    # Delete any span matching the condition. This is thread safe.
-    #
-    # @return [Array<Span>] deleted spans
-    def delete_span_if
-      @mutex.synchronize do
-        [].tap do |deleted_spans|
-          @trace.delete_if do |span|
-            finished = span.finished?
-
-            next unless yield span
-
-            deleted_spans << span
-
-            # We need to detach the span from the context, else, some code
-            # finishing it afterwards would mess up with the number of
-            # finished_spans and possibly cause other side effects.
-            span.context = nil
-            # Acknowledge there's one span less to finish, if needed.
-            # It's very important to keep this balanced.
-            @finished_spans -= 1 if finished
-
-            true
-          end
-        end
-      end
-    end
-
-    # Set tags to root span required for flush
-    def annotate_for_flush!(span)
-      attach_sampling_priority(span) if @sampled && @sampling_priority
-      attach_origin(span) if @origin
-    end
-
-    def attach_sampling_priority(span)
-      span.set_metric(
-        Ext::DistributedTracing::SAMPLING_PRIORITY_KEY,
-        @sampling_priority
-      )
-    end
-
-    def attach_origin(span)
-      span.set_tag(
-        Ext::DistributedTracing::ORIGIN_KEY,
-        @origin
-      )
-    end
-
-    # Return a string representation of the context.
-    def to_s
-      @mutex.synchronize do
-        # rubocop:disable Layout/LineLength
-        "Context(trace.length:#{@trace.length},sampled:#{@sampled},finished_spans:#{@finished_spans},current_span:#{@current_span})"
-      end
-    end
-
-    # Generates equivalent context for forked processes.
-    #
-    # When Context from parent process is forked, child process
-    # should have a Context belonging to the same trace but not
-    # have the parent process spans.
-    def fork_clone
-      self.class.new(
-        trace_id: trace_id,
-        span_id: span_id,
-        sampled: sampled?,
-        sampling_priority: sampling_priority,
-        origin: origin
-      )
-    end
-
-    private
-
-    def reset(options = {})
-      @trace = []
-      @parent_trace_id = options.fetch(:trace_id, nil)
-      @parent_span_id = options.fetch(:span_id, nil)
-      @sampled = options.fetch(:sampled, false)
-      @sampling_priority = options.fetch(:sampling_priority, nil)
-      @origin = options.fetch(:origin, nil)
-      @finished_spans = 0
-      @current_span = nil
-      @current_root_span = nil
-      @overflow = false
-    end
-
-    def set_current_span(span)
-      @current_span = span
-      if span
-        @parent_trace_id = span.trace_id
-        @parent_span_id = span.span_id
-        @sampled = span.sampled
-      else
-        @parent_span_id = nil
-      end
-    end
-
-    # Returns if the trace for the current Context is finished or not.
-    # Low-level internal function, not thread-safe.
-    def all_spans_finished?
-      @finished_spans > 0 && @trace.length == @finished_spans
-    end
-
-    # Return the start time of the root span, or nil if there are no spans or this is undefined.
-    def start_time
-      @mutex.synchronize do
-        return nil if @trace.empty?
-
-        @trace[0].start_time
-      end
-    end
-
-    # Return the length of the current trace held by this context.
-    def length
-      @mutex.synchronize do
-        @trace.length
-      end
-    end
-
-    # Iterate on each span within the trace. This is thread safe.
-    def each_span(&block)
-      @mutex.synchronize do
-        @trace.each(&block)
-      end
-    end
-  end
-end

data/lib/ddtrace/context_flush.rb

@@ -1,81 +0,0 @@
-module Datadog
-  module ContextFlush
-    # Consumes only completed traces (where all spans have finished)
-    class Finished
-      # Consumes and returns completed traces (where all spans have finished)
-      # from the provided +context+, if any.
-      #
-      # Any traces consumed are removed from +context+ as a side effect.
-      #
-      # @return [Array<Span>] trace to be flushed, or +nil+ if the trace is not finished
-      def consume!(context)
-        trace, sampled = get_trace(context)
-        trace if sampled
-      end
-
-      protected
-
-      def get_trace(context)
-        context.get
-      end
-    end
-
-    # Performs partial trace flushing to avoid large traces residing in memory for too long
-    class Partial
-      # Start flushing partial trace after this many active spans in one trace
-      DEFAULT_MIN_SPANS_FOR_PARTIAL_FLUSH = 500
-
-      def initialize(options = {})
-        @min_spans_for_partial = options.fetch(:min_spans_before_partial_flush, DEFAULT_MIN_SPANS_FOR_PARTIAL_FLUSH)
-      end
-
-      # Consumes and returns completed or partially completed
-      # traces from the provided +context+, if any.
-      #
-      # Partially completed traces, where not all spans have finished,
-      # will only be returned if there are at least
-      # +@min_spans_for_partial+ finished spans.
-      #
-      # Any spans consumed are removed from +context+ as a side effect.
-      #
-      # @return [Array<Span>] partial or complete trace to be flushed, or +nil+ if no spans are finished
-      def consume!(context)
-        trace, sampled = get_trace(context)
-
-        return nil unless sampled
-        return trace if trace && !trace.empty?
-
-        partial_trace(context)
-      end
-
-      protected
-
-      def get_trace(context)
-        context.get
-      end
-
-      private
-
-      def partial_trace(context)
-        return nil if context.finished_span_count < @min_spans_for_partial
-
-        finished_spans(context)
-      end
-
-      def finished_spans(context)
-        trace = context.delete_span_if(&:finished?)
-
-        # Ensure that the first span in a partial trace has
-        # sampling and origin information.
-        if trace[0]
-          context.annotate_for_flush!(trace[0])
-        else
-          Datadog.logger.debug('Tried to retrieve trace from context, but got nothing. ' \
-            "Is there another consumer for this context? #{context.trace_id}")
-        end
-
-        trace unless trace.empty?
-      end
-    end
-  end
-end

data/lib/ddtrace/context_provider.rb

@@ -1,61 +0,0 @@
-module Datadog
-  # DefaultContextProvider is a default context provider that retrieves
-  # all contexts from the current thread-local storage. It is suitable for
-  # synchronous programming.
-  class DefaultContextProvider
-    # Initializes the default context provider with a thread-bound context.
-    def initialize
-      @context = ThreadLocalContext.new
-    end
-
-    # Sets the current context.
-    def context=(ctx)
-      @context.local = ctx
-    end
-
-    # Return the local context.
-    def context(key = nil)
-      current_context = key.nil? ? @context.local : @context.local(key)
-
-      # Rebuild/reset context after a fork
-      #
-      # We don't want forked processes to copy and retransmit spans
-      # that were generated from the parent process. Reset it such
-      # that it acts like a distributed trace.
-      current_context.after_fork! do
-        current_context = self.context = current_context.fork_clone
-      end
-
-      current_context
-    end
-  end
-
-  # ThreadLocalContext can be used as a tracer global reference to create
-  # a different \Context for each thread. In synchronous tracer, this
-  # is required to prevent multiple threads sharing the same \Context
-  # in different executions.
-  class ThreadLocalContext
-    # ThreadLocalContext can be used as a tracer global reference to create
-    # a different \Context for each thread. In synchronous tracer, this
-    # is required to prevent multiple threads sharing the same \Context
-    # in different executions.
-    #
-    # To support multiple tracers simultaneously, each \ThreadLocalContext
-    # instance has its own thread-local variable.
-    def initialize
-      @key = "datadog_context_#{object_id}".to_sym
-
-      self.local = Datadog::Context.new
-    end
-
-    # Override the thread-local context with a new context.
-    def local=(ctx)
-      Thread.current[@key] = ctx
-    end
-
-    # Return the thread-local context.
-    def local(thread = Thread.current)
-      thread[@key] ||= Datadog::Context.new
-    end
-  end
-end

data/lib/ddtrace/contrib/action_cable/configuration/settings.rb

@@ -1,30 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/action_cable/ext'
-
-module Datadog
-  module Contrib
-    module ActionCable
-      module Configuration
-        # Custom settings for the ActionCable integration
-        class Settings < Contrib::Configuration::Settings
-          option :enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
-            o.lazy
-          end
-
-          option :analytics_enabled do |o|
-            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-
-          option :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end