ddtrace 0.45.0 → 0.52.0

data/lib/ddtrace/configuration/settings.rb

@@ -1,10 +1,13 @@
+# typed: false
 require 'logger'
 require 'ddtrace/configuration/base'
 
 require 'ddtrace/ext/analytics'
 require 'ddtrace/ext/distributed'
-require 'ddtrace/ext/runtime'
+require 'ddtrace/ext/environment'
+require 'ddtrace/ext/profiling'
 require 'ddtrace/ext/sampling'
+require 'ddtrace/ext/test'
 
 module Datadog
   module Configuration
@@ -13,9 +16,32 @@ module Datadog
     class Settings
       include Base
 
-      #
-      # Configuration options
-      #
+      def initialize(*_)
+        super
+
+        # WORKAROUND: The values for services, version, and env can get set either directly OR as a side effect of
+        # accessing tags (reading or writing). This is of course really confusing and error-prone, e.g. in an app
+        # WITHOUT this workaround where you define `DD_TAGS=env:envenvtag,service:envservicetag,version:envversiontag`
+        # and do:
+        #
+        # puts Datadog.configuration.instance_exec { "#{service} #{env} #{version}" }
+        # Datadog.configuration.tags
+        # puts Datadog.configuration.instance_exec { "#{service} #{env} #{version}" }
+        #
+        # the output will be:
+        #
+        # [empty]
+        # envservicetag envenvtag envversiontag
+        #
+        # That is -- the proper values for service/env/version are only set AFTER something accidentally or not triggers
+        # the resolution of the tags.
+        # This is really confusing, error prone, etc, so calling tags here is a really hacky but effective way to
+        # avoid this. I could not think of a better way of fixing this issue without massive refactoring of tags parsing
+        # (so that the individual service/env/version get correctly set even from their tags values, not as a side
+        # effect). Sorry :(
+        tags
+      end
+
       settings :analytics do
         option :enabled do |o|
           o.default { env_to_bool(Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) }
@@ -92,6 +118,7 @@ module Datadog
       end
 
       option :env do |o|
+        # NOTE: env also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
         o.default { ENV.fetch(Ext::Environment::ENV_ENVIRONMENT, nil) }
         o.lazy
       end
@@ -108,6 +135,55 @@ module Datadog
         get_option(:logger).instance = logger
       end
 
+      settings :profiling do
+        option :enabled do |o|
+          o.default { env_to_bool(Ext::Profiling::ENV_ENABLED, false) }
+          o.lazy
+        end
+
+        settings :exporter do
+          option :transport
+          option :transport_options do |o|
+            o.setter do
+              # NOTE: As of April 2021 there may be a few profiler private beta customers with this setting, but since I'm
+              # marking this as deprecated before public beta, we can remove this for 1.0 without concern.
+              Datadog.logger.warn(
+                'Configuring the profiler c.profiling.exporter.transport_options is no longer needed, as the profiler ' \
+                'will reuse your existing global or tracer configuration. ' \
+                'This setting is deprecated for removal in a future ddtrace version ' \
+                '(1.0 or profiling GA, whichever comes first).'
+              )
+              nil
+            end
+            o.default { nil }
+            o.lazy
+          end
+        end
+
+        settings :advanced do
+          option :max_events, default: 32768
+
+          # Controls the maximum number of frames for each thread sampled. Can be tuned to avoid omitted frames in the
+          # produced profiles. Increasing this may increase the overhead of profiling.
+          option :max_frames do |o|
+            o.default { env_to_int(Ext::Profiling::ENV_MAX_FRAMES, 400) }
+            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
+        end
+
+        settings :upload do
+          option :timeout_seconds do |o|
+            o.setter { |value| value.nil? ? 30.0 : value.to_f }
+            o.default { env_to_float(Ext::Profiling::ENV_UPLOAD_TIMEOUT, 30.0) }
+            o.lazy
+          end
+        end
+      end
+
       option :report_hostname do |o|
         o.default { env_to_bool(Ext::NET::ENV_REPORT_HOSTNAME, false) }
         o.lazy
@@ -156,8 +232,17 @@ module Datadog
       end
 
       option :service do |o|
-        o.default { ENV.fetch(Ext::Environment::ENV_SERVICE, nil) }
+        # NOTE: service also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
+        o.default { ENV.fetch(Ext::Environment::ENV_SERVICE, Ext::Environment::FALLBACK_SERVICE_NAME) }
         o.lazy
+
+        # There's a few cases where we don't want to use the fallback service name, so this helper allows us to get a
+        # nil instead so that one can do
+        # nice_service_name = Datadog.configure.service_without_fallback || nice_service_name_default
+        o.helper(:service_without_fallback) do
+          service_name = service
+          service_name unless service_name.equal?(Ext::Environment::FALLBACK_SERVICE_NAME)
+        end
       end
 
       option :site do |o|
@@ -184,18 +269,17 @@ module Datadog
 
         o.setter do |new_value, old_value|
           # Coerce keys to strings
-          string_tags = Hash[new_value.collect { |k, v| [k.to_s, v] }]
+          string_tags = new_value.collect { |k, v| [k.to_s, v] }.to_h
 
           # Cross-populate tag values with other settings
-          if env.nil? && string_tags.key?(Ext::Environment::TAG_ENV)
-            self.env = string_tags[Ext::Environment::TAG_ENV]
-          end
+
+          self.env = string_tags[Ext::Environment::TAG_ENV] if env.nil? && string_tags.key?(Ext::Environment::TAG_ENV)
 
           if version.nil? && string_tags.key?(Ext::Environment::TAG_VERSION)
             self.version = string_tags[Ext::Environment::TAG_VERSION]
           end
 
-          if service.nil? && string_tags.key?(Ext::Environment::TAG_SERVICE)
+          if service_without_fallback.nil? && string_tags.key?(Ext::Environment::TAG_SERVICE)
             self.service = string_tags[Ext::Environment::TAG_SERVICE]
           end
 
@@ -206,6 +290,39 @@ module Datadog
         o.lazy
       end
 
+      settings :test_mode do
+        option :enabled do |o|
+          o.default { env_to_bool(Ext::Test::ENV_MODE_ENABLED, false) }
+          o.lazy
+        end
+
+        option :context_flush do |o|
+          o.default { nil }
+          o.lazy
+        end
+
+        option :writer_options do |o|
+          o.default { {} }
+          o.lazy
+        end
+      end
+
+      option :time_now_provider do |o|
+        o.default { ::Time.now }
+
+        o.on_set do |time_provider|
+          Utils::Time.now_provider = time_provider
+        end
+
+        o.resetter do |_value|
+          # TODO: Resetter needs access to the default value
+          # TODO: to help reduce duplication.
+          -> { ::Time.now }.tap do |default|
+            Utils::Time.now_provider = default
+          end
+        end
+      end
+
       settings :tracer do
         option :enabled do |o|
           o.default { env_to_bool(Datadog::Ext::Diagnostics::DD_TRACE_ENABLED, true) }
@@ -277,6 +394,7 @@ module Datadog
       end
 
       option :version do |o|
+        # NOTE: version also gets set as a side effect of tags. See the WORKAROUND note in #initialize for details.
         o.default { ENV.fetch(Ext::Environment::ENV_VERSION, nil) }
         o.lazy
       end

data/lib/ddtrace/configuration.rb

@@ -1,14 +1,42 @@
+# typed: true
 require 'forwardable'
-
 require 'ddtrace/configuration/pin_setup'
 require 'ddtrace/configuration/settings'
 require 'ddtrace/configuration/components'
 
 module Datadog
   # Configuration provides a unique access point for configurations
-  module Configuration
+  module Configuration # rubocop:disable Metrics/ModuleLength
+    include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
     extend Forwardable
 
+    # Used to ensure that @components initialization/reconfiguration is performed one-at-a-time, by a single thread.
+    #
+    # This is important because components can end up being accessed from multiple application threads (for instance on
+    # a threaded webserver), and we don't want their initialization to clash (for instance, starting two profilers...).
+    #
+    # Note that a Mutex **IS NOT** reentrant: the same thread cannot grab the same Mutex more than once.
+    # This means below we are careful not to nest calls to methods that would trigger initialization and grab the lock.
+    #
+    # Every method that directly or indirectly mutates @components should be holding the lock (through
+    # #safely_synchronize) while doing so.
+    COMPONENTS_WRITE_LOCK = Mutex.new
+    private_constant :COMPONENTS_WRITE_LOCK
+
+    # We use a separate lock when reading the @components, so that they continue to be accessible during reconfiguration.
+    # This was needed because we ran into several issues where we still needed to read the old
+    # components while the COMPONENTS_WRITE_LOCK was being held (see https://github.com/DataDog/dd-trace-rb/pull/1387
+    # and https://github.com/DataDog/dd-trace-rb/pull/1373#issuecomment-799593022 ).
+    #
+    # Technically on MRI we could get away without this lock, but on non-MRI Rubies, we may run into issues because
+    # we fall into the "UnsafeDCLFactory" case of https://shipilev.net/blog/2014/safe-public-construction/ .
+    # Specifically, on JRuby reads from the @components do NOT have volatile semantics, and on TruffleRuby they do
+    # BUT just as an implementation detail, see https://github.com/jruby/jruby/wiki/Concurrency-in-jruby#volatility and
+    # https://github.com/DataDog/dd-trace-rb/pull/1329#issuecomment-776750377 .
+    # Concurrency is hard.
+    COMPONENTS_READ_LOCK = Mutex.new
+    private_constant :COMPONENTS_READ_LOCK
+
     attr_writer :configuration
 
     def configuration
@@ -19,13 +47,15 @@ module Datadog
       if target.is_a?(Settings)
         yield(target) if block_given?
 
-        # Build immutable components from settings
-        @components ||= nil
-        @components = if @components
-                        replace_components!(target, @components)
-                      else
-                        build_components(target)
-                      end
+        safely_synchronize do |write_components|
+          write_components.call(
+            if components?
+              replace_components!(target, @components)
+            else
+              build_components(target)
+            end
+          )
+        end
 
         target
       else
@@ -36,22 +66,19 @@ module Datadog
     def_delegators \
       :components,
       :health_metrics,
+      :profiler,
       :runtime_metrics,
       :tracer
 
     def logger
-      if instance_variable_defined?(:@components) && @components
+      # avoid initializing components if they didn't already exist
+      current_components = components(allow_initialization: false)
+
+      if current_components
         @temp_logger = nil
-        components.logger
+        current_components.logger
       else
-        # Use default logger without initializing components.
-        # This prevents recursive loops while initializing.
-        # e.g. Get logger --> Build components --> Log message --> Repeat...
-        @temp_logger ||= begin
-          logger = configuration.logger.instance || Datadog::Logger.new(STDOUT)
-          logger.level = configuration.diagnostics.debug ? ::Logger::DEBUG : configuration.logger.level
-          logger
-        end
+        logger_without_components
       end
     end
 
@@ -65,26 +92,64 @@ module Datadog
     #
     # Components won't be automatically reinitialized after a shutdown.
     def shutdown!
-      components.shutdown! if instance_variable_defined?(:@components) && @components
+      safely_synchronize do
+        @components.shutdown! if components?
+      end
     end
 
+    protected
+
+    def components(allow_initialization: true)
+      current_components = COMPONENTS_READ_LOCK.synchronize { defined?(@components) && @components }
+      return current_components if current_components || !allow_initialization
+
+      safely_synchronize do |write_components|
+        (defined?(@components) && @components) || write_components.call(build_components(configuration))
+      end
+    end
+
+    private
+
     # Gracefully shuts down the tracer and disposes of component references,
     # allowing execution to start anew.
     #
     # In contrast with +#shutdown!+, components will be automatically
     # reinitialized after a reset.
+    #
+    # Used internally to ensure a clean environment between test runs.
     def reset!
-      shutdown!
-      @components = nil
+      safely_synchronize do |write_components|
+        @components.shutdown! if components?
+        write_components.call(nil)
+        configuration.reset!
+      end
     end
 
-    protected
+    def safely_synchronize
+      # Writes to @components should only happen through this proc. Because this proc is only accessible to callers of
+      # safely_synchronize, this forces all writers to go through this method.
+      write_components = proc do |new_value|
+        COMPONENTS_READ_LOCK.synchronize { @components = new_value }
+      end
 
-    def components
-      @components ||= build_components(configuration)
+      COMPONENTS_WRITE_LOCK.synchronize do
+        begin
+          yield write_components
+        rescue ThreadError => e
+          logger_without_components.error(
+            'Detected deadlock during ddtrace initialization. ' \
+            'Please report this at https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug' \
+            "\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
+          )
+          nil
+        end
+      end
     end
 
-    private
+    def components?
+      # This does not need to grab the COMPONENTS_READ_LOCK because it's not returning the components
+      (defined?(@components) && @components) != nil
+    end
 
     def build_components(settings)
       components = Components.new(settings)
@@ -99,5 +164,32 @@ module Datadog
       components.startup!(settings)
       components
     end
+
+    def logger_without_components
+      # Use default logger without initializing components.
+      # This enables logging during initialization, otherwise we'd run into deadlocks.
+      @temp_logger ||= begin
+        logger = configuration.logger.instance || Datadog::Logger.new($stdout)
+        logger.level = configuration.diagnostics.debug ? ::Logger::DEBUG : configuration.logger.level
+        logger
+      end
+    end
+
+    # Called from our at_exit hook whenever there was a pending Interrupt exception (e.g. typically due to ctrl+c)
+    # to print a nice message whenever we're taking a bit longer than usual to finish the process.
+    def handle_interrupt_shutdown!
+      logger = Datadog.logger
+      shutdown_thread = Thread.new { shutdown! }
+      print_message_treshold_seconds = 0.2
+
+      slow_shutdown = shutdown_thread.join(print_message_treshold_seconds).nil?
+
+      if slow_shutdown
+        logger.info 'Reporting remaining data... Press ctrl+c to exit immediately.'
+        shutdown_thread.join
+      end
+
+      nil
+    end
   end
 end

data/lib/ddtrace/context.rb

@@ -1,4 +1,4 @@
-require 'thread'
+# typed: true
 require 'ddtrace/diagnostics/health'
 
 require 'ddtrace/context_flush'
@@ -126,6 +126,7 @@ module Datadog
         # 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
@@ -189,6 +190,9 @@ module Datadog
         # 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
@@ -227,10 +231,24 @@ module Datadog
       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 Metrics/LineLength
+        # rubocop:disable Layout/LineLength
         "Context(trace.length:#{@trace.length},sampled:#{@sampled},finished_spans:#{@finished_spans},current_span:#{@current_span})"
       end
     end
@@ -282,24 +300,11 @@ module Datadog
       @finished_spans > 0 && @trace.length == @finished_spans
     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 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
@@ -312,11 +317,9 @@ module Datadog
     end
 
     # Iterate on each span within the trace. This is thread safe.
-    def each_span
+    def each_span(&block)
       @mutex.synchronize do
-        @trace.each do |span|
-          yield span
-        end
+        @trace.each(&block)
       end
     end
   end

data/lib/ddtrace/context_flush.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module ContextFlush
     # Consumes only completed traces (where all spans have finished)
@@ -9,9 +10,15 @@ module Datadog
       #
       # @return [Array<Span>] trace to be flushed, or +nil+ if the trace is not finished
       def consume!(context)
-        trace, sampled = context.get
+        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
@@ -34,7 +41,7 @@ module Datadog
       #
       # @return [Array<Span>] partial or complete trace to be flushed, or +nil+ if no spans are finished
       def consume!(context)
-        trace, sampled = context.get
+        trace, sampled = get_trace(context)
 
         return nil unless sampled
         return trace if trace && !trace.empty?
@@ -42,6 +49,12 @@ module Datadog
         partial_trace(context)
       end
 
+      protected
+
+      def get_trace(context)
+        context.get
+      end
+
       private
 
       def partial_trace(context)

data/lib/ddtrace/context_provider.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   # DefaultContextProvider is a default context provider that retrieves
   # all contexts from the current thread-local storage. It is suitable for
@@ -55,7 +56,6 @@ module Datadog
 
     # Return the thread-local context.
     def local(thread = Thread.current)
-      raise ArgumentError, '\'thread\' must be a Thread.' unless thread.is_a?(Thread)
       thread[@key] ||= Datadog::Context.new
     end
   end

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

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/contrib/configuration/settings'
 require 'ddtrace/contrib/action_cable/ext'
 

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

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/active_support/notifications/event'
 require 'ddtrace/contrib/action_cable/ext'
@@ -8,8 +9,8 @@ module Datadog
       # Defines basic behaviors for an event.
       module Event
         def self.included(base)
-          base.send(:include, ActiveSupport::Notifications::Event)
-          base.send(:extend, ClassMethods)
+          base.include(ActiveSupport::Notifications::Event)
+          base.extend(ClassMethods)
         end
 
         # Class methods for events.
@@ -34,8 +35,8 @@ module Datadog
       # but to start a fresh tracing context.
       module RootContextEvent
         def self.included(base)
-          base.send(:include, ActiveSupport::Notifications::Event)
-          base.send(:extend, ClassMethods)
+          base.include(ActiveSupport::Notifications::Event)
+          base.extend(ClassMethods)
         end
 
         # Class methods for events.
@@ -56,6 +57,7 @@ module Datadog
           # preventing such a leak.
           def ensure_clean_context!
             return unless configuration[:tracer].call_context.current_span
+
             configuration[:tracer].provider.context = Context.new
           end
         end

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

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/action_cable/event'
 

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

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/action_cable/event'
 

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

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/contrib/analytics'
 require 'ddtrace/contrib/action_cable/event'
 

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

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/contrib/action_cable/event'
 require 'ddtrace/contrib/action_cable/events/broadcast'
 require 'ddtrace/contrib/action_cable/events/perform_action'

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

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module Contrib
     module ActionCable

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

@@ -1,3 +1,4 @@
+# typed: false
 module Datadog
   module Contrib
     module ActionCable

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

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/contrib/integration'
 require 'ddtrace/contrib/action_cable/configuration/settings'
 require 'ddtrace/contrib/action_cable/patcher'

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

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/contrib/patcher'
 require 'ddtrace/ext/app_types'
 require 'ddtrace/contrib/action_cable/ext'