ddtrace 0.42.0 → 0.52.0

data/lib/ddtrace/configuration/dependency_resolver.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'tsort'
 
 module Datadog

data/lib/ddtrace/configuration/option.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module Configuration
     # Represents an instance of an integration configuration option

data/lib/ddtrace/configuration/option_definition.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/configuration/option'
 
 module Datadog
@@ -60,7 +61,7 @@ module Datadog
         end
 
         def default(value = nil, &block)
-          @default = block_given? ? block : value
+          @default = block || value
         end
 
         def delegate_to(&block)
@@ -71,8 +72,6 @@ module Datadog
           @helpers[name] = block
         end
 
-        # rubocop:disable Style/TrivialAccessors
-        # (Rubocop erroneously thinks #lazy == #lazy= )
         def lazy(value = true)
           @lazy = value
         end

data/lib/ddtrace/configuration/option_definition_set.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/configuration/dependency_resolver'
 
 module Datadog

data/lib/ddtrace/configuration/option_set.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module Configuration
     class OptionSet < Hash

data/lib/ddtrace/configuration/options.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/configuration/option_set'
 require 'ddtrace/configuration/option_definition'
 require 'ddtrace/configuration/option_definition_set'
@@ -7,17 +8,15 @@ module Datadog
     # Behavior for a configuration object that has options
     module Options
       def self.included(base)
-        base.send(:extend, ClassMethods)
-        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
       end
 
       # Class behavior for a configuration object with options
       module ClassMethods
         def options
-          @options ||= begin
-            # Allows for class inheritance of option definitions
-            superclass <= Options ? superclass.options.dup : OptionDefinitionSet.new
-          end
+          # Allows for class inheritance of option definitions
+          @options ||= superclass <= Options ? superclass.options.dup : OptionDefinitionSet.new
         end
 
         protected
@@ -51,6 +50,7 @@ module Datadog
         def define_helpers(helpers)
           helpers.each do |name, block|
             next unless block.is_a?(Proc)
+
             define_method(name, &block)
           end
         end
@@ -102,9 +102,7 @@ module Datadog
         end
 
         def assert_valid_option!(name)
-          unless option_defined?(name)
-            raise(InvalidOptionError, "#{self.class.name} doesn't define the option: #{name}")
-          end
+          raise(InvalidOptionError, "#{self.class.name} doesn't define the option: #{name}") unless option_defined?(name)
         end
       end
 

data/lib/ddtrace/configuration/pin_setup.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   module Configuration
     # PinSetup translates a flat hash into a Pin configuration

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) }
@@ -69,7 +95,8 @@ module Datadog
         option :propagation_extract_style do |o|
           o.default do
             # Look for all headers by default
-            env_to_list(Ext::DistributedTracing::PROPAGATION_EXTRACT_STYLE_ENV,
+            env_to_list([Ext::DistributedTracing::PROPAGATION_STYLE_EXTRACT_ENV,
+                         Ext::DistributedTracing::PROPAGATION_EXTRACT_STYLE_ENV_OLD],
                         [Ext::DistributedTracing::PROPAGATION_STYLE_DATADOG,
                          Ext::DistributedTracing::PROPAGATION_STYLE_B3,
                          Ext::DistributedTracing::PROPAGATION_STYLE_B3_SINGLE_HEADER])
@@ -81,7 +108,8 @@ module Datadog
         option :propagation_inject_style do |o|
           o.default do
             # Only inject Datadog headers by default
-            env_to_list(Ext::DistributedTracing::PROPAGATION_INJECT_STYLE_ENV,
+            env_to_list([Ext::DistributedTracing::PROPAGATION_STYLE_INJECT_ENV,
+                         Ext::DistributedTracing::PROPAGATION_INJECT_STYLE_ENV_OLD],
                         [Ext::DistributedTracing::PROPAGATION_STYLE_DATADOG])
           end
 
@@ -90,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
@@ -106,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
@@ -154,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|
@@ -182,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
 
@@ -204,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) }
@@ -275,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/context.rb

@@ -1,8 +1,9 @@
-require 'thread'
+# typed: true
 require 'ddtrace/diagnostics/health'
 
 require 'ddtrace/context_flush'
 require 'ddtrace/context_provider'
+require 'ddtrace/utils/forking'
 
 module Datadog
   # \Context is used to keep track of a hierarchy of spans for the current
@@ -19,6 +20,8 @@ module Datadog
   # This data structure is thread-safe.
   # rubocop:disable Metrics/ClassLength
   class Context
+    include Datadog::Utils::Forking
+
     # 100k spans is about a 100Mb footprint
     DEFAULT_MAX_LENGTH = 100_000
 
@@ -123,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
@@ -186,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
@@ -224,14 +231,43 @@ 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
 
+    # Generates equivalent context for forked processes.
+    #
+    # When Context from parent process is forked, child process
+    # should have a Context belonging to the same trace but not
+    # have the parent process spans.
+    def fork_clone
+      self.class.new(
+        trace_id: trace_id,
+        span_id: span_id,
+        sampled: sampled?,
+        sampling_priority: sampling_priority,
+        origin: origin
+      )
+    end
+
     private
 
     def reset(options = {})
@@ -264,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
@@ -294,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)