ddtrace 0.53.0 → 1.9.0

data/lib/ddtrace/context.rb

@@ -1,326 +0,0 @@
-# typed: true
-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,82 +0,0 @@
-# typed: true
-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,62 +0,0 @@
-# typed: true
-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,31 +0,0 @@
-# typed: false
-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

data/lib/ddtrace/contrib/action_cable/event.rb

@@ -1,67 +0,0 @@
-# typed: true
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/active_support/notifications/event'
-require 'ddtrace/contrib/action_cable/ext'
-
-module Datadog
-  module Contrib
-    module ActionCable
-      # Defines basic behaviors for an event.
-      module Event
-        def self.included(base)
-          base.include(ActiveSupport::Notifications::Event)
-          base.extend(ClassMethods)
-        end
-
-        # Class methods for events.
-        module ClassMethods
-          def span_options
-            { service: configuration[:service_name] }
-          end
-
-          def tracer
-            -> { configuration[:tracer] }
-          end
-
-          def configuration
-            Datadog.configuration[:action_cable]
-          end
-        end
-      end
-
-      # Defines behavior for the first event of a thread execution.
-      #
-      # This event is not expected to be nested with other event,
-      # but to start a fresh tracing context.
-      module RootContextEvent
-        def self.included(base)
-          base.include(ActiveSupport::Notifications::Event)
-          base.extend(ClassMethods)
-        end
-
-        # Class methods for events.
-        module ClassMethods
-          include Contrib::ActionCable::Event::ClassMethods
-
-          def subscription(*args)
-            super.tap do |subscription|
-              subscription.before_trace { ensure_clean_context! }
-            end
-          end
-
-          private
-
-          # Context objects are thread-bound.
-          # If an integration re-uses threads, context from a previous trace
-          # could leak into the new trace. This "cleans" current context,
-          # preventing such a leak.
-          def ensure_clean_context!
-            return unless configuration[:tracer].call_context.current_span
-
-            configuration[:tracer].provider.context = Context.new
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/action_cable/events/broadcast.rb

@@ -1,50 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/action_cable/event'
-
-module Datadog
-  module Contrib
-    module ActionCable
-      module Events
-        # Defines instrumentation for 'broadcast.action_cable' event.
-        #
-        # A single 'broadcast' event will trigger as many 'transmit' events
-        # as there are clients subscribed to a channel.
-        module Broadcast
-          include ActionCable::Event
-
-          EVENT_NAME = 'broadcast.action_cable'.freeze
-
-          module_function
-
-          def event_name
-            self::EVENT_NAME
-          end
-
-          def span_name
-            Ext::SPAN_BROADCAST
-          end
-
-          def span_type
-            # Starts a broadcast of messages over WebSockets
-            Datadog::Ext::AppTypes::WEB
-          end
-
-          def process(span, _event, _id, payload)
-            channel = payload[:broadcasting] # Channel has high cardinality
-            span.service = configuration[:service_name]
-            span.span_type = span_type
-
-            # Set analytics sample rate
-            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
-            end
-
-            span.set_tag(Ext::TAG_CHANNEL, channel)
-            span.set_tag(Ext::TAG_BROADCAST_CODER, payload[:coder])
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/action_cable/events/perform_action.rb

@@ -1,56 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/action_cable/event'
-
-module Datadog
-  module Contrib
-    module ActionCable
-      module Events
-        # Defines instrumentation for 'perform_action.action_cable' event.
-        #
-        # An action, triggered by a WebSockets client, invokes a method
-        # in the server's channel instance.
-        module PerformAction
-          include ActionCable::RootContextEvent
-
-          EVENT_NAME = 'perform_action.action_cable'.freeze
-
-          module_function
-
-          def event_name
-            self::EVENT_NAME
-          end
-
-          def span_name
-            Ext::SPAN_ACTION
-          end
-
-          def span_type
-            # A request to perform_action comes from a WebSocket connection
-            Datadog::Ext::AppTypes::WEB
-          end
-
-          def process(span, _event, _id, payload)
-            channel_class = payload[:channel_class]
-            action = payload[:action]
-
-            span.service = configuration[:service_name]
-            span.resource = "#{channel_class}##{action}"
-            span.span_type = span_type
-
-            # Set analytics sample rate
-            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
-            end
-
-            # Measure service stats
-            Contrib::Analytics.set_measured(span)
-
-            span.set_tag(Ext::TAG_CHANNEL_CLASS, channel_class)
-            span.set_tag(Ext::TAG_ACTION, action)
-          end
-        end
-      end
-    end
-  end
-end