ddtrace 0.53.0 → 1.0.0.beta1

data/lib/datadog/tracing/configuration/ext.rb

@@ -0,0 +1,50 @@
+# typed: true
+module Datadog
+  module Tracing
+    module Configuration
+      module Ext
+        # @public_api
+        module Analytics
+          ENV_TRACE_ANALYTICS_ENABLED = 'DD_TRACE_ANALYTICS_ENABLED'.freeze
+        end
+
+        # @public_api
+        module Correlation
+          ENV_LOGS_INJECTION_ENABLED = 'DD_LOGS_INJECTION'.freeze
+        end
+
+        # @public_api
+        module Distributed
+          PROPAGATION_STYLE_DATADOG = 'Datadog'.freeze
+          PROPAGATION_STYLE_B3 = 'B3'.freeze
+          PROPAGATION_STYLE_B3_SINGLE_HEADER = 'B3 single header'.freeze
+          ENV_PROPAGATION_STYLE_INJECT = 'DD_PROPAGATION_STYLE_INJECT'.freeze
+          ENV_PROPAGATION_STYLE_EXTRACT = 'DD_PROPAGATION_STYLE_EXTRACT'.freeze
+        end
+
+        # @public_api
+        module NET
+          ENV_REPORT_HOSTNAME = 'DD_TRACE_REPORT_HOSTNAME'.freeze
+        end
+
+        # @public_api
+        module Sampling
+          ENV_SAMPLE_RATE = 'DD_TRACE_SAMPLE_RATE'.freeze
+          ENV_RATE_LIMIT = 'DD_TRACE_RATE_LIMIT'.freeze
+        end
+
+        # @public_api
+        module Test
+          ENV_MODE_ENABLED = 'DD_TRACE_TEST_MODE_ENABLED'.freeze
+        end
+
+        # @public_api
+        module Transport
+          ENV_DEFAULT_HOST = 'DD_AGENT_HOST'.freeze
+          ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'.freeze
+          ENV_DEFAULT_URL = 'DD_TRACE_AGENT_URL'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/context.rb

@@ -0,0 +1,67 @@
+# typed: true
+require 'datadog/core/utils/forking'
+
+module Datadog
+  module Tracing
+    # {Datadog::Tracing::Context} is used to keep track of a the active trace for the current
+    # execution flow. During each logical execution, the same {Datadog::Tracing::Context} is
+    # used to represent a single logical trace, even if the trace is built
+    # asynchronously.
+    #
+    # A single code execution may use multiple {Datadog::Tracing::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
+    # {Datadog::Tracing::Context}, it will be related to the original trace.
+    class Context
+      include Core::Utils::Forking
+
+      attr_reader \
+        :active_trace
+
+      def initialize(
+        trace: nil
+      )
+        activate!(trace)
+      end
+
+      # Handles trace activation.
+      #
+      # Permits nil, allowing traces to be deactivated.
+      #
+      # If given a block, it will reset to the original
+      # trace after the block completes.
+      #
+      # When restoring the original trace, if it is finished,
+      # it will deactivate it. This prevents the context from
+      # holding references to completed traces thereby releasing
+      # its memory.
+      def activate!(trace)
+        if block_given?
+          begin
+            original_trace = @active_trace
+            set_active_trace!(trace)
+            yield
+          ensure
+            set_active_trace!(original_trace)
+          end
+        else
+          set_active_trace!(trace)
+        end
+      end
+
+      # Creates a copy of the context, when forked.
+      def fork_clone
+        forked_trace = @active_trace && @active_trace.fork_clone
+        self.class.new(trace: forked_trace)
+      end
+
+      private
+
+      def set_active_trace!(trace)
+        # Don't retain finished traces
+        @active_trace = trace && !trace.finished? ? trace : nil
+      end
+    end
+  end
+end

data/lib/datadog/tracing/context_provider.rb

@@ -0,0 +1,67 @@
+# typed: true
+
+require 'datadog/tracing/context'
+
+module Datadog
+  module Tracing
+    # 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 {Datadog::Tracing::Context} for each thread. In synchronous tracer, this
+    # is required to prevent multiple threads sharing the same {Datadog::Tracing::Context}
+    # in different executions.
+    class ThreadLocalContext
+      # ThreadLocalContext can be used as a tracer global reference to create
+      # a different {Datadog::Tracing::Context} for each thread. In synchronous tracer, this
+      # is required to prevent multiple threads sharing the same {Datadog::Tracing::Context}
+      # in different executions.
+      #
+      # To support multiple tracers simultaneously, each {Datadog::Tracing::ThreadLocalContext}
+      # instance has its own thread-local variable.
+      def initialize
+        @key = "datadog_context_#{object_id}".to_sym
+
+        self.local = 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] ||= Context.new
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_cable/configuration/settings.rb

@@ -0,0 +1,34 @@
+# typed: false
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/action_cable/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActionCable
+        module Configuration
+          # Custom settings for the ActionCable integration
+          # @public_api
+          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, 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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_cable/event.rb

@@ -0,0 +1,71 @@
+# typed: true
+require 'datadog/tracing'
+require 'datadog/tracing/context'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/active_support/notifications/event'
+require 'datadog/tracing/contrib/action_cable/ext'
+
+module Datadog
+  module Tracing
+    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
+              if configuration[:service_name]
+                { service: configuration[:service_name] }
+              else
+                {}
+              end
+            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 Tracing.active_span
+
+              Tracing.send(:tracer).provider.context = Tracing::Context.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_cable/events/broadcast.rb

@@ -0,0 +1,57 @@
+# typed: false
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/action_cable/event'
+require 'datadog/tracing/contrib/action_cable/ext'
+require 'datadog/tracing/contrib/analytics'
+
+module Datadog
+  module Tracing
+    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
+              Tracing::Metadata::Ext::AppTypes::TYPE_WEB
+            end
+
+            def process(span, _event, _id, payload)
+              channel = payload[:broadcasting] # Channel has high cardinality
+              span.service = configuration[:service_name] if 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])
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_BROADCAST)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_cable/events/perform_action.rb

@@ -0,0 +1,62 @@
+# typed: false
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/action_cable/event'
+
+module Datadog
+  module Tracing
+    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
+              Tracing::Metadata::Ext::AppTypes::TYPE_WEB
+            end
+
+            def process(span, _event, _id, payload)
+              channel_class = payload[:channel_class]
+              action = payload[:action]
+
+              span.service = configuration[:service_name] if 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)
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ACTION)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_cable/events/transmit.rb

@@ -0,0 +1,58 @@
+# typed: false
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/action_cable/event'
+require 'datadog/tracing/contrib/action_cable/ext'
+require 'datadog/tracing/contrib/analytics'
+
+module Datadog
+  module Tracing
+    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
+              Tracing::Metadata::Ext::AppTypes::TYPE_WEB
+            end
+
+            def process(span, _event, _id, payload)
+              channel_class = payload[:channel_class]
+
+              span.service = configuration[:service_name] if 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])
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_TRANSMIT)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_cable/events.rb

@@ -0,0 +1,36 @@
+# typed: false
+require 'datadog/tracing/contrib/action_cable/event'
+require 'datadog/tracing/contrib/action_cable/events/broadcast'
+require 'datadog/tracing/contrib/action_cable/events/perform_action'
+require 'datadog/tracing/contrib/action_cable/events/transmit'
+
+module Datadog
+  module Tracing
+    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
+end

data/lib/datadog/tracing/contrib/action_cable/ext.rb

@@ -0,0 +1,31 @@
+# typed: true
+module Datadog
+  module Tracing
+    module Contrib
+      module ActionCable
+        # ActionCable integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_ACTION_CABLE_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTION_CABLE_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTION_CABLE_ANALYTICS_SAMPLE_RATE'.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_COMPONENT = 'action_cable'.freeze
+          TAG_CONNECTION = 'action_cable.connection'.freeze
+          TAG_OPERATION_ACTION = 'action'.freeze
+          TAG_OPERATION_BROADCAST = 'broadcast'.freeze
+          TAG_OPERATION_ON_OPEN = 'on_open'.freeze
+          TAG_OPERATION_TRANSMIT = 'transmit'.freeze
+          TAG_TRANSMIT_VIA = 'action_cable.transmit.via'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_cable/instrumentation.rb

@@ -0,0 +1,91 @@
+# typed: false
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/action_cable/ext'
+require 'datadog/tracing/contrib/analytics'
+
+module Datadog
+  module Tracing
+    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
+              Tracing.trace(Ext::SPAN_ON_OPEN) do |span, trace|
+                begin
+                  span.resource = "#{self.class}#on_open"
+                  span.span_type = Tracing::Metadata::Ext::AppTypes::TYPE_WEB
+
+                  span.set_tag(Ext::TAG_ACTION, 'on_open')
+                  span.set_tag(Ext::TAG_CONNECTION, self.class.to_s)
+
+                  span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                  span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ON_OPEN)
+
+                  # Set the resource name of the trace
+                  trace.resource = span.resource
+                rescue StandardError => e
+                  Datadog.logger.error("Error preparing span for ActionCable::Connection: #{e}")
+                end
+
+                super
+              end
+            end
+          end
+
+          # Instrumentation for when a Channel is subscribed to/unsubscribed from.
+          module ActionCableChannel
+            def self.included(base)
+              base.class_eval do
+                set_callback(
+                  :subscribe,
+                  :around,
+                  ->(channel, block) { Tracer.trace(channel, :subscribe, &block) },
+                  prepend: true
+                )
+
+                set_callback(
+                  :unsubscribe,
+                  :around,
+                  ->(channel, block) { Tracer.trace(channel, :unsubscribe, &block) },
+                  prepend: true
+                )
+              end
+            end
+
+            # Instrumentation for Channel hooks.
+            class Tracer
+              def self.trace(channel, hook)
+                configuration = Datadog.configuration[:action_cable]
+
+                Tracing.trace("action_cable.#{hook}") do |span|
+                  span.service = configuration[:service_name] if configuration[:service_name]
+                  span.resource = "#{channel.class}##{hook}"
+                  span.span_type = Tracing::Metadata::Ext::AppTypes::TYPE_WEB
+
+                  # 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.to_s)
+
+                  span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                  span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, hook)
+
+                  yield
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_cable/integration.rb

@@ -0,0 +1,49 @@
+# typed: false
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/action_cable/configuration/settings'
+require 'datadog/tracing/contrib/action_cable/patcher'
+require 'datadog/tracing/contrib/rails/utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActionCable
+        # Description of ActionCable integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('5.0.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          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
+
+          # enabled by rails integration so should only auto instrument
+          # if detected that it is being used without rails
+          def auto_instrument?
+            !Contrib::Rails::Utils.railtie_supported?
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end