ddtrace 0.52.0 → 0.54.2

data/lib/datadog/contrib.rb

@@ -26,9 +26,11 @@ module Datadog
 end
 
 require 'ddtrace/contrib/action_cable/integration'
+require 'ddtrace/contrib/action_mailer/integration'
 require 'ddtrace/contrib/action_pack/integration'
 require 'ddtrace/contrib/action_view/integration'
 require 'ddtrace/contrib/active_model_serializers/integration'
+require 'ddtrace/contrib/active_job/integration'
 require 'ddtrace/contrib/active_record/integration'
 require 'ddtrace/contrib/active_support/integration'
 require 'ddtrace/contrib/aws/integration'

data/lib/datadog/core/environment/vm_cache.rb

@@ -0,0 +1,46 @@
+# typed: true
+module Datadog
+  module Core
+    module Environment
+      # Reports Ruby VM cache performance statistics.
+      # This currently encompasses cache invalidation counters and is CRuby-specific.
+      #
+      # JRuby emulates some CRuby global cache statistics, but they are synthetic and don't
+      # provide actionable performance information in the same way CRuby does.
+      # @see https://github.com/jruby/jruby/issues/4384#issuecomment-267069314
+      #
+      # TruffleRuby does not have a global runtime cache invalidation cache.
+      # @see http://archive.today/2021.09.10-205702/https://medium.com/graalvm/precise-method-and-constant-invalidation-in-truffleruby-4dd56c6bac1a
+      module VMCache
+        module_function
+
+        # Global constant cache "generation" counter.
+        #
+        # Whenever a constant creation busts the global constant cache
+        # this value is incremented. This has a measurable performance impact
+        # and thus show be avoided after application warm up.
+        def global_constant_state
+          ::RubyVM.stat[:global_constant_state]
+        end
+
+        # Global method cache "generation" counter.
+        #
+        # Whenever a method creation busts the global method cache
+        # this value is incremented. This has a measurable performance impact
+        # and thus show be avoided after application warm up.
+        #
+        # Since Ruby 3.0, the method class is kept on a per-class basis,
+        # largely mitigating global method cache busting. `global_method_state`
+        # is thus not available since Ruby 3.0.
+        # @see https://bugs.ruby-lang.org/issues/16614
+        def global_method_state
+          ::RubyVM.stat[:global_method_state]
+        end
+
+        def available?
+          defined?(::RubyVM) && ::RubyVM.respond_to?(:stat)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/buffer.rb

@@ -14,7 +14,11 @@ module Datadog
     end
 
     # Add a new ``item`` in the local queue. This method doesn't block the execution
-    # even if the buffer is full. In that case, a random item is discarded.
+    # even if the buffer is full.
+    #
+    # When the buffer is full, we try to ensure that we are fairly sampling newly
+    # pushed traces by randomly inserting them into the buffer slots. This discards
+    # old traces randomly while trying to ensure that recent traces are still captured.
     def push(item)
       return if closed?
 
@@ -64,7 +68,7 @@ module Datadog
 
     protected
 
-    # Segment items into two distinct segments: underflow and overflow.
+    # Segment items into two segments: underflow and overflow.
     # Underflow are items that will fit into buffer.
     # Overflow are items that will exceed capacity, after underflow is added.
     # Returns each array, and nil if there is no underflow/overflow.
@@ -176,9 +180,6 @@ module Datadog
   # Buffer that stores objects, has a maximum size, and
   # can be safely used concurrently with CRuby.
   #
-  # Under extreme concurrency scenarios, this class can exceed
-  # its +max_size+ by up to 4%.
-  #
   # Because singular +Array+ operations are thread-safe in CRuby,
   # we can implement the trace buffer without an explicit lock,
   # while making the compromise of allowing the buffer to go
@@ -187,7 +188,6 @@ module Datadog
   # On the following scenario:
   # * 4.5 million spans/second.
   # * Pushed into a single CRubyTraceBuffer from 1000 threads.
-  # The buffer can exceed its maximum size by no more than 4%.
   #
   # This implementation allocates less memory and is faster
   # than {Datadog::ThreadSafeBuffer}.
@@ -195,19 +195,31 @@ module Datadog
   # @see spec/ddtrace/benchmark/buffer_benchmark_spec.rb Buffer benchmarks
   # @see https://github.com/ruby-concurrency/concurrent-ruby/blob/c1114a0c6891d9634f019f1f9fe58dcae8658964/lib/concurrent-ruby/concurrent/array.rb#L23-L27
   class CRubyBuffer < Buffer
+    # A very large number to allow us to effectively
+    # drop all items when invoking `slice!(i, FIXNUM_MAX)`.
+    FIXNUM_MAX = (1 << 62) - 1
+
     # Add a new ``trace`` in the local queue. This method doesn't block the execution
     # even if the buffer is full. In that case, a random trace is discarded.
     def replace!(item)
-      # we should replace a random trace with the new one
-      replace_index = rand(@items.size)
-      replaced_trace = @items.delete_at(replace_index)
-      @items << item
-
-      # We might have deleted an element right when the buffer
-      # was drained, thus +replaced_trace+ will be +nil+.
-      # In that case, nothing was replaced, and this method
-      # performed a simple insertion into the buffer.
-      replaced_trace
+      # Ensure buffer stays within +max_size+ items.
+      # This can happen when there's concurrent modification
+      # between a call the check in `full?` and the `add!` call in
+      # `full? ? replace!(item) : add!(item)`.
+      #
+      # We can still have `@items.size > @max_size` for a short period of
+      # time, but we will always try to correct it here.
+      #
+      # `slice!` is performed before `delete_at` & `<<` to avoid always
+      # removing the item that was just inserted.
+      #
+      # DEV: `slice!` with two integer arguments is ~10% faster than
+      # `slice!` with a {Range} argument.
+      @items.slice!(@max_size, FIXNUM_MAX)
+
+      # We should replace a random trace with the new one
+      replace_index = rand(@max_size)
+      @items[replace_index] = item
     end
   end
 

data/lib/ddtrace/configuration/agent_settings_resolver.rb

@@ -20,25 +20,49 @@ module Datadog
     class AgentSettingsResolver
       AgentSettings = \
         Struct.new(
+          :adapter,
           :ssl,
           :hostname,
           :port,
+          :uds_path,
           :timeout_seconds,
           :deprecated_for_removal_transport_configuration_proc,
           :deprecated_for_removal_transport_configuration_options
         ) do
           def initialize(
+            adapter:,
             ssl:,
             hostname:,
             port:,
+            uds_path:,
             timeout_seconds:,
             deprecated_for_removal_transport_configuration_proc:,
             deprecated_for_removal_transport_configuration_options:
           )
-            super(ssl, hostname, port, timeout_seconds, deprecated_for_removal_transport_configuration_proc, \
-              deprecated_for_removal_transport_configuration_options)
+            super(
+              adapter,
+              ssl,
+              hostname,
+              port,
+              uds_path,
+              timeout_seconds,
+              deprecated_for_removal_transport_configuration_proc,
+              deprecated_for_removal_transport_configuration_options,
+            )
             freeze
           end
+
+          # Returns a frozen copy of this struct
+          # with the provided +member_values+ modified.
+          def merge(**member_values)
+            new_struct = dup
+
+            member_values.each do |member, value|
+              new_struct[member] = value
+            end
+
+            new_struct.freeze
+          end
         end
 
       def self.call(settings, logger: Datadog.logger)
@@ -58,9 +82,11 @@ module Datadog
 
       def call
         AgentSettings.new(
+          adapter: adapter,
           ssl: ssl?,
           hostname: hostname,
           port: port,
+          uds_path: uds_path,
           timeout_seconds: timeout_seconds,
           # NOTE: When provided, the deprecated_for_removal_transport_configuration_proc can override all
           # values above (ssl, hostname, port, timeout), or even make them irrelevant (by using an unix socket or
@@ -72,65 +98,99 @@ module Datadog
         )
       end
 
-      def hostname
-        pick_from(
-          configurations_in_priority_order: [
-            DetectedConfiguration.new(
-              friendly_name: "'c.tracer.hostname'",
-              value: settings.tracer.hostname
-            ),
-            DetectedConfiguration.new(
-              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} environment variable",
-              value: parsed_url && parsed_url.hostname
-            ),
-            DetectedConfiguration.new(
-              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST} environment variable",
-              value: ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST]
-            )
-          ],
-          or_use_default: Datadog::Ext::Transport::HTTP::DEFAULT_HOST
+      def adapter
+        # If no agent settings have been provided, we try to connect using a local unix socket.
+        # We only do so if the socket is present when `ddtrace` runs.
+        if should_use_uds_fallback?
+          Ext::Transport::UnixSocket::ADAPTER
+        else
+          Ext::Transport::HTTP::ADAPTER
+        end
+      end
+
+      def configured_hostname
+        return @configured_hostname if defined?(@configured_hostname)
+
+        @configured_hostname = pick_from(
+          DetectedConfiguration.new(
+            friendly_name: "'c.tracer.hostname'",
+            value: settings.tracer.hostname
+          ),
+          DetectedConfiguration.new(
+            friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} environment variable",
+            value: parsed_url && parsed_url.hostname
+          ),
+          DetectedConfiguration.new(
+            friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST} environment variable",
+            value: ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST]
+          )
         )
       end
 
-      def port
-        port_from_env = ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT]
+      def configured_port
+        return @configured_port if defined?(@configured_port)
+
         parsed_port_from_env =
-          if port_from_env
-            begin
-              Integer(port_from_env)
-            rescue ArgumentError
-              log_warning(
-                "Invalid value for #{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable " \
-                "('#{port_from_env}'). Ignoring this configuration."
-              )
-            end
-          end
+          try_parsing_as_integer(
+            friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable",
+            value: ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT],
+          )
 
-        pick_from(
-          configurations_in_priority_order: [
-            DetectedConfiguration.new(
-              friendly_name: '"c.tracer.port"',
-              value: settings.tracer.port
-            ),
-            DetectedConfiguration.new(
-              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} environment variable",
-              value: parsed_url && parsed_url.port
-            ),
-            DetectedConfiguration.new(
-              friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable",
-              value: parsed_port_from_env
-            )
-          ],
-          or_use_default: Datadog::Ext::Transport::HTTP::DEFAULT_PORT
+        parsed_settings_tracer_port =
+          try_parsing_as_integer(
+            friendly_name: '"c.tracer.port"',
+            value: settings.tracer.port,
+          )
+
+        @configured_port = pick_from(
+          DetectedConfiguration.new(
+            friendly_name: '"c.tracer.port"',
+            value: parsed_settings_tracer_port,
+          ),
+          DetectedConfiguration.new(
+            friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL} environment variable",
+            value: parsed_url && parsed_url.port,
+          ),
+          DetectedConfiguration.new(
+            friendly_name: "#{Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT} environment variable",
+            value: parsed_port_from_env,
+          )
         )
       end
 
+      def try_parsing_as_integer(value:, friendly_name:)
+        return unless value
+
+        begin
+          Integer(value)
+        rescue ArgumentError, TypeError
+          log_warning("Invalid value for #{friendly_name} (#{value.inspect}). Ignoring this configuration.")
+
+          nil
+        end
+      end
+
       def ssl?
         !parsed_url.nil? && parsed_url.scheme == 'https'
       end
 
+      def hostname
+        configured_hostname || (should_use_uds_fallback? ? nil : Datadog::Ext::Transport::HTTP::DEFAULT_HOST)
+      end
+
+      def port
+        configured_port || (should_use_uds_fallback? ? nil : Datadog::Ext::Transport::HTTP::DEFAULT_PORT)
+      end
+
+      # Unix socket path in the file system
+      def uds_path
+        uds_fallback
+      end
+
+      # Defaults to +nil+, letting the adapter choose what default
+      # works best in their case.
       def timeout_seconds
-        Datadog::Ext::Transport::HTTP::DEFAULT_TIMEOUT_SECONDS
+        nil
       end
 
       def deprecated_for_removal_transport_configuration_proc
@@ -150,6 +210,26 @@ module Datadog
         end
       end
 
+      # We only use the default unix socket if it is already present.
+      # This is by design, as we still want to use the default host:port if no unix socket is present.
+      def uds_fallback
+        return @uds_fallback if defined?(@uds_fallback)
+
+        @uds_fallback =
+          if configured_hostname.nil? &&
+             configured_port.nil? &&
+             deprecated_for_removal_transport_configuration_proc.nil? &&
+             deprecated_for_removal_transport_configuration_options.nil? &&
+             File.exist?(Ext::Transport::UnixSocket::DEFAULT_PATH)
+
+            Ext::Transport::UnixSocket::DEFAULT_PATH
+          end
+      end
+
+      def should_use_uds_fallback?
+        uds_fallback != nil
+      end
+
       def parsed_url
         return @parsed_url if defined?(@parsed_url)
 
@@ -177,7 +257,7 @@ module Datadog
         @unparsed_url_from_env ||= ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL]
       end
 
-      def pick_from(configurations_in_priority_order:, or_use_default:)
+      def pick_from(*configurations_in_priority_order)
         detected_configurations_in_priority_order = configurations_in_priority_order.select(&:value?)
 
         if detected_configurations_in_priority_order.any?
@@ -186,8 +266,6 @@ module Datadog
           # The configurations are listed in priority, so we only need to look at the first; if there's more than
           # one, we emit a warning above
           detected_configurations_in_priority_order.first.value
-        else
-          or_use_default
         end
       end
 
@@ -197,8 +275,8 @@ module Datadog
         log_warning(
           'Configuration mismatch: values differ between ' \
           "#{detected_configurations_in_priority_order
-            .map { |config| "#{config.friendly_name} ('#{config.value}')" }.join(' and ')}" \
-          ". Using '#{detected_configurations_in_priority_order.first.value}'."
+            .map { |config| "#{config.friendly_name} (#{config.value.inspect})" }.join(' and ')}" \
+          ". Using #{detected_configurations_in_priority_order.first.value.inspect}."
         )
       end
 

data/lib/ddtrace/configuration/components.rb

@@ -117,7 +117,7 @@ module Datadog
 
           trace_identifiers_helper = Datadog::Profiling::TraceIdentifiers::Helper.new(
             tracer: tracer,
-            extract_trace_resource: settings.profiling.advanced.extract_trace_resource
+            endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled
           )
 
           recorder = build_profiler_recorder(settings)

data/lib/ddtrace/configuration/settings.rb

@@ -161,6 +161,9 @@ module Datadog
         end
 
         settings :advanced do
+          # This should never be reduced, as it can cause the resulting profiles to become biased.
+          # The current default should be enough for most services, allowing 16 threads to be sampled around 30 times
+          # per second for a 60 second period.
           option :max_events, default: 32768
 
           # Controls the maximum number of frames for each thread sampled. Can be tuned to avoid omitted frames in the
@@ -170,9 +173,16 @@ module Datadog
             o.lazy
           end
 
-          # When using profiling together with tracing, this controls if trace resources (usually the endpoint names)
-          # are gathered and reported together with profiles.
-          option :extract_trace_resource, default: true
+          settings :endpoint do
+            settings :collection do
+              # When using profiling together with tracing, this controls if endpoint names
+              # are gathered and reported together with profiles.
+              option :enabled do |o|
+                o.default { env_to_bool(Ext::Profiling::ENV_ENDPOINT_COLLECTION_ENABLED, true) }
+                o.lazy
+              end
+            end
+          end
         end
 
         settings :upload do

data/lib/ddtrace/context.rb

@@ -78,13 +78,21 @@ module Datadog
     # earlier while child spans still need to finish their traced execution.
     def current_span
       @mutex.synchronize do
-        return @current_span
+        @current_span
       end
     end
 
     def current_root_span
       @mutex.synchronize do
-        return @current_root_span
+        @current_root_span
+      end
+    end
+
+    # Same as calling #current_span and #current_root_span, but works atomically thus preventing races when we need to
+    # retrieve both
+    def current_span_and_root_span
+      @mutex.synchronize do
+        [@current_span, @current_root_span]
       end
     end
 

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

@@ -26,6 +26,52 @@ module Datadog
             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]
+
+              Datadog.tracer.trace("action_cable.#{hook}") do |span|
+                span.service = configuration[:service_name]
+                span.resource = "#{channel.class}##{hook}"
+                span.span_type = Datadog::Ext::AppTypes::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)
+
+                yield
+              end
+            end
+          end
+        end
       end
     end
   end

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

@@ -21,6 +21,7 @@ module Datadog
         def patch
           Events.subscribe!
           ::ActionCable::Connection::Base.prepend(Instrumentation::ActionCableConnection)
+          ::ActionCable::Channel::Base.include(Instrumentation::ActionCableChannel)
         end
       end
     end

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

@@ -0,0 +1,32 @@
+# typed: false
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/action_mailer/ext'
+
+module Datadog
+  module Contrib
+    module ActionMailer
+      module Configuration
+        # Custom settings for the ActionMailer 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
+          option :email_data, default: false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: false
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_support/notifications/event'
+require 'ddtrace/contrib/action_mailer/ext'
+
+module Datadog
+  module Contrib
+    module ActionMailer
+      # Defines basic behaviors for an ActionMailer event.
+      module Event
+        def self.included(base)
+          base.send(:include, ActiveSupport::Notifications::Event)
+          base.send(:extend, ClassMethods)
+        end
+
+        # Class methods for ActionMailer events.
+        module ClassMethods
+          def span_options
+            { service: configuration[:service_name] }
+          end
+
+          def tracer
+            -> { configuration[:tracer] }
+          end
+
+          def configuration
+            Datadog.configuration[:action_mailer]
+          end
+
+          def process(span, event, _id, payload)
+            span.service = configuration[:service_name]
+            span.resource = payload[:mailer]
+
+            # 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)
+
+            report_if_exception(span, payload)
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_mailer/events/deliver.rb

@@ -0,0 +1,54 @@
+# typed: false
+require 'ddtrace/contrib/action_mailer/ext'
+require 'ddtrace/contrib/action_mailer/event'
+
+module Datadog
+  module Contrib
+    module ActionMailer
+      module Events
+        # Defines instrumentation for process.action_mailer event
+        module Deliver
+          include ActionMailer::Event
+
+          EVENT_NAME = 'deliver.action_mailer'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_DELIVER
+          end
+
+          def span_type
+            # deliver.action_mailer sends emails
+            Datadog::Ext::AppTypes::WORKER
+          end
+
+          def process(span, event, _id, payload)
+            super
+
+            span.span_type = span_type
+            span.set_tag(Ext::TAG_MAILER, payload[:mailer])
+            span.set_tag(Ext::TAG_MSG_ID, payload[:message_id])
+
+            # Since email date can contain PII we disable by default
+            # Some of these fields can be either strings or arrays, so we try to normalize
+            # https://github.com/rails/rails/blob/18707ab17fa492eb25ad2e8f9818a320dc20b823/actionmailer/lib/action_mailer/base.rb#L742-L754
+            if configuration[:email_data] == true
+              span.set_tag(Ext::TAG_SUBJECT, payload[:subject].to_s) if payload[:subject]
+              span.set_tag(Ext::TAG_TO, payload[:to].join(',')) if payload[:to]
+              span.set_tag(Ext::TAG_FROM, payload[:from].join(',')) if payload[:from]
+              span.set_tag(Ext::TAG_BCC, payload[:bcc].join(',')) if payload[:bcc]
+              span.set_tag(Ext::TAG_CC, payload[:cc].join(',')) if payload[:cc]
+              span.set_tag(Ext::TAG_DATE, payload[:date].to_s) if payload[:date]
+              span.set_tag(Ext::TAG_PERFORM_DELIVERIES, payload[:perform_deliveries]) if payload[:perform_deliveries]
+            end
+          end
+        end
+      end
+    end
+  end
+end