ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/context_provider.rb

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,66 @@
+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.rb

@@ -0,0 +1,33 @@
+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/events/broadcast.rb

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,55 @@
+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

@@ -0,0 +1,50 @@
+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/ext.rb

@@ -0,0 +1,26 @@
+module Datadog
+  module Contrib
+    module ActionCable
+      # ActionCable integration constants
+      module Ext
+        APP = 'action_cable'.freeze
+        ENV_ENABLED = 'DD_TRACE_ACTION_CABLE_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTION_CABLE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_ACTION_CABLE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTION_CABLE_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = '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

@@ -0,0 +1,31 @@
+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.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

@@ -0,0 +1,45 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/action_cable/configuration/settings'
+require 'ddtrace/contrib/action_cable/patcher'
+require 'ddtrace/contrib/rails/utils'
+
+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
+
+        # enabled by rails integration so should only auto instrument
+        # if detected that it is being used without rails
+        def auto_instrument?
+          !Datadog::Contrib::Rails::Utils.railtie_supported?
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end