ddtrace 0.34.1 → 1.23.1

data/lib/ddtrace/context_flush.rb

@@ -1,69 +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 = context.get
-        trace if sampled
-      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 = context.get
-
-        return nil unless sampled
-        return trace if trace && !trace.empty?
-
-        partial_trace(context)
-      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.log.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,50 +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 current context.
-    def context
-      @context.local
-    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.current[@key] ||= Datadog::Context.new
-    end
-  end
-end

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

@@ -1,25 +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 :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 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,65 +0,0 @@
-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.send(:include, ActiveSupport::Notifications::Event)
-          base.send(: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.send(:include, ActiveSupport::Notifications::Event)
-          base.send(: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,49 +0,0 @@
-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,55 +0,0 @@
-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

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

@@ -1,50 +0,0 @@
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/action_cable/event'
-
-module Datadog
-  module Contrib
-    module ActionCable
-      module Events
-        # Defines instrumentation for 'transmit.action_cable' event.
-        #
-        # A 'transmit' event sends a message to a single client subscribed to a channel.
-        module Transmit
-          include ActionCable::Event
-
-          EVENT_NAME = 'transmit.action_cable'.freeze
-
-          module_function
-
-          def event_name
-            self::EVENT_NAME
-          end
-
-          def span_name
-            Ext::SPAN_TRANSMIT
-          end
-
-          def span_type
-            # ActionCable transmits data over WebSockets
-            Datadog::Ext::AppTypes::WEB
-          end
-
-          def process(span, _event, _id, payload)
-            channel_class = payload[:channel_class]
-
-            span.service = configuration[:service_name]
-            span.resource = channel_class
-            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_CLASS, channel_class)
-            span.set_tag(Ext::TAG_TRANSMIT_VIA, payload[:via])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-require 'ddtrace/contrib/action_cable/event'
-require 'ddtrace/contrib/action_cable/events/broadcast'
-require 'ddtrace/contrib/action_cable/events/perform_action'
-require 'ddtrace/contrib/action_cable/events/transmit'
-
-module Datadog
-  module Contrib
-    module ActionCable
-      # Defines collection of instrumented ActionCable events
-      module Events
-        ALL = [
-          Events::Broadcast,
-          Events::PerformAction,
-          Events::Transmit
-        ].freeze
-
-        module_function
-
-        def all
-          self::ALL
-        end
-
-        def subscriptions
-          all.collect(&:subscriptions).collect(&:to_a).flatten
-        end
-
-        def subscribe!
-          all.each(&:subscribe!)
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-module Datadog
-  module Contrib
-    module ActionCable
-      # ActionCable integration constants
-      module Ext
-        APP = 'action_cable'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_ACTION_CABLE_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_ACTION_CABLE_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'action_cable'.freeze
-        SPAN_ACTION = 'action_cable.action'.freeze
-        SPAN_BROADCAST = 'action_cable.broadcast'.freeze
-        SPAN_ON_OPEN = 'action_cable.on_open'.freeze
-        SPAN_TRANSMIT = 'action_cable.transmit'.freeze
-        TAG_ACTION = 'action_cable.action'.freeze
-        TAG_BROADCAST_CODER = 'action_cable.broadcast.coder'.freeze
-        TAG_CHANNEL = 'action_cable.channel'.freeze
-        TAG_CHANNEL_CLASS = 'action_cable.channel_class'.freeze
-        TAG_CONNECTION = 'action_cable.connection'.freeze
-        TAG_TRANSMIT_VIA = 'action_cable.transmit.via'.freeze
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-module Datadog
-  module Contrib
-    module ActionCable
-      module Instrumentation
-        # When a new WebSocket is open, we receive a Rack request resource name "GET -1".
-        # This module overrides the current Rack resource name to provide a meaningful name.
-        module ActionCableConnection
-          def on_open
-            Datadog.tracer.trace(Ext::SPAN_ON_OPEN) do |span|
-              begin
-                span.resource = "#{self.class}#on_open"
-                span.span_type = Datadog::Ext::AppTypes::WEB
-
-                span.set_tag(Ext::TAG_ACTION, 'on_open')
-                span.set_tag(Ext::TAG_CONNECTION, self.class.to_s)
-
-                # Set the resource name of the Rack request span
-                rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
-                rack_request_span.resource = span.resource if rack_request_span
-              rescue StandardError => e
-                Datadog::Logger.log.error("Error preparing span for ActionCable::Connection: #{e}")
-              end
-
-              super
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/action_cable/configuration/settings'
-require 'ddtrace/contrib/action_cable/patcher'
-
-module Datadog
-  module Contrib
-    module ActionCable
-      # Description of ActionCable integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('5.0.0')
-
-        register_as :action_cable, auto_patch: false
-
-        def self.version
-          Gem.loaded_specs['actioncable'] && Gem.loaded_specs['actioncable'].version
-        end
-
-        def self.loaded?
-          !defined?(::ActionCable).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/action_cable/ext'
-require 'ddtrace/contrib/action_cable/events'
-require 'ddtrace/contrib/action_cable/instrumentation'
-
-module Datadog
-  module Contrib
-    module ActionCable
-      # Patcher enables patching of 'action_cable' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          Events.subscribe!
-          ::ActionCable::Connection::Base.prepend(Instrumentation::ActionCableConnection)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/action_pack/action_controller/instrumentation.rb

@@ -1,148 +0,0 @@
-require 'ddtrace/ext/http'
-
-require 'ddtrace/contrib/action_pack/ext'
-require 'ddtrace/contrib/action_pack/utils'
-require 'ddtrace/contrib/rack/middlewares'
-require 'ddtrace/contrib/analytics'
-
-module Datadog
-  module Contrib
-    module ActionPack
-      module ActionController
-        # Instrumentation for ActionController components
-        module Instrumentation
-          module_function
-
-          def start_processing(payload)
-            # trace the execution
-            tracer = Datadog.configuration[:action_pack][:tracer]
-            service = Datadog.configuration[:action_pack][:controller_service]
-            type = Datadog::Ext::HTTP::TYPE_INBOUND
-            span = tracer.trace(Ext::SPAN_ACTION_CONTROLLER, service: service, span_type: type)
-
-            # attach the current span to the tracing context
-            tracing_context = payload.fetch(:tracing_context)
-            tracing_context[:dd_request_span] = span
-          rescue StandardError => e
-            Datadog::Logger.log.error(e.message)
-          end
-
-          def finish_processing(payload)
-            # retrieve the tracing context and the latest active span
-            tracing_context = payload.fetch(:tracing_context)
-            env = payload.fetch(:env)
-            span = tracing_context[:dd_request_span]
-            return unless span && !span.finished?
-
-            begin
-              # Set the resource name, if it's still the default name
-              if span.resource == span.name
-                span.resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
-              end
-
-              # Set the resource name of the Rack request span unless this is an exception controller.
-              unless exception_controller?(payload)
-                rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
-                rack_request_span.resource = span.resource if rack_request_span
-              end
-
-              # Set analytics sample rate
-              Utils.set_analytics_sample_rate(span)
-
-              # Measure service stats
-              Contrib::Analytics.set_measured(span)
-
-              # Associate with runtime metrics
-              Datadog.runtime_metrics.associate_with_span(span)
-
-              span.set_tag(Ext::TAG_ROUTE_ACTION, payload.fetch(:action))
-              span.set_tag(Ext::TAG_ROUTE_CONTROLLER, payload.fetch(:controller))
-
-              exception = payload[:exception_object]
-              if exception.nil?
-                # [christian] in some cases :status is not defined,
-                # rather than firing an error, simply acknowledge we don't know it.
-                status = payload.fetch(:status, '?').to_s
-                span.status = 1 if status.starts_with?('5')
-              elsif Utils.exception_is_error?(exception)
-                span.set_error(exception)
-              end
-            ensure
-              span.finish
-            end
-          rescue StandardError => e
-            Datadog::Logger.log.error(e.message)
-          end
-
-          def exception_controller?(payload)
-            exception_controller_class = Datadog.configuration[:action_pack][:exception_controller]
-            controller = payload.fetch(:controller)
-            headers = payload.fetch(:headers)
-
-            # If no exception controller class has been set,
-            # guess whether this is an exception controller from the headers.
-            if exception_controller_class.nil?
-              !headers[:request_exception].nil?
-            # If an exception controller class has been specified,
-            # check if the controller is a kind of the exception controller class.
-            elsif exception_controller_class.is_a?(Class) || exception_controller_class.is_a?(Module)
-              controller <= exception_controller_class
-            # Otherwise if the exception controller class is some other value (like false)
-            # assume that this controller doesn't handle exceptions.
-            else
-              false
-            end
-          end
-
-          # Instrumentation for ActionController::Metal
-          module Metal
-            def process_action(*args)
-              # mutable payload with a tracing context that is used in two different
-              # signals; it propagates the request span so that it can be finished
-              # no matter what
-              payload = {
-                controller: self.class,
-                action: action_name,
-                env: request.env,
-                headers: {
-                  # The exception this controller was given in the request,
-                  # which is typical if the controller is configured to handle exceptions.
-                  request_exception: request.headers['action_dispatch.exception']
-                },
-                tracing_context: {}
-              }
-
-              begin
-                # process and catch request exceptions
-                Instrumentation.start_processing(payload)
-                result = super(*args)
-                status = datadog_response_status
-                payload[:status] = status unless status.nil?
-                result
-              # rubocop:disable Lint/RescueException
-              rescue Exception => e
-                payload[:exception] = [e.class.name, e.message]
-                payload[:exception_object] = e
-                raise e
-              end
-            # rubocop:enable Lint/RescueException
-            ensure
-              Instrumentation.finish_processing(payload)
-            end
-
-            def datadog_response_status
-              case response
-              when ::ActionDispatch::Response
-                response.status
-              when Array
-                # Likely a Rack response array: first element is the status.
-                status = response.first
-                status.class <= Integer ? status : nil
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end