ddtrace 0.49.0 → 0.50.0

data/lib/datadog/ci/ext/settings.rb

@@ -0,0 +1,10 @@
+module Datadog
+  module CI
+    module Ext
+      # Defines constants for test tags
+      module Settings
+        ENV_MODE_ENABLED = 'DD_TRACE_CI_MODE_ENABLED'.freeze
+      end
+    end
+  end
+end

data/lib/datadog/ci/ext/test.rb

@@ -0,0 +1,28 @@
+module Datadog
+  module CI
+    module Ext
+      # Defines constants for test tags
+      module Test
+        CONTEXT_ORIGIN = 'ciapp-test'.freeze
+
+        TAG_ARGUMENTS = 'test.arguments'.freeze
+        TAG_FRAMEWORK = 'test.framework'.freeze
+        TAG_NAME = 'test.name'.freeze
+        TAG_SKIP_REASON = 'test.skip_reason'.freeze
+        TAG_STATUS = 'test.status'.freeze
+        TAG_SUITE = 'test.suite'.freeze
+        TAG_TRAITS = 'test.traits'.freeze
+        TAG_TYPE = 'test.type'.freeze
+
+        # TODO: is there a better place for SPAN_KIND?
+        TAG_SPAN_KIND = 'span.kind'.freeze
+
+        module Status
+          PASS = 'pass'.freeze
+          FAIL = 'fail'.freeze
+          SKIP = 'skip'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/ci/extensions.rb

@@ -0,0 +1,17 @@
+require 'ddtrace/configuration/settings'
+require 'ddtrace/configuration/components'
+
+require 'datadog/ci/configuration/settings'
+require 'datadog/ci/configuration/components'
+
+module Datadog
+  module CI
+    # Extends Datadog tracing with CI features
+    module Extensions
+      def self.activate!
+        Datadog::Configuration::Settings.extend(CI::Configuration::Settings)
+        Datadog::Configuration::Components.prepend(CI::Configuration::Components)
+      end
+    end
+  end
+end

data/lib/datadog/ci/test.rb

@@ -0,0 +1,63 @@
+require 'ddtrace/contrib/analytics'
+
+require 'datadog/ci/ext/app_types'
+require 'datadog/ci/ext/test'
+
+module Datadog
+  module CI
+    # Common behavior for CI tests
+    module Test
+      # Creates a new span for a CI test
+      def self.trace(tracer, span_name, options = {})
+        span_options = {
+          span_type: Ext::AppTypes::TEST
+        }.merge(options[:span_options] || {})
+
+        if block_given?
+          tracer.trace(span_name, span_options) do |span|
+            set_tags!(span, options)
+            yield(span)
+          end
+        else
+          span = tracer.trace(span_name, span_options)
+          set_tags!(span, options)
+          span
+        end
+      end
+
+      # Adds tags to a CI test span.
+      def self.set_tags!(span, tags = {})
+        tags ||= {}
+
+        # Set default tags
+        span.context.origin = Ext::Test::CONTEXT_ORIGIN if span.context
+        Datadog::Contrib::Analytics.set_measured(span)
+        span.set_tag(Ext::Test::TAG_SPAN_KIND, Ext::AppTypes::TEST)
+        Ext::Environment.tags(ENV).each { |k, v| span.set_tag(k, v) }
+
+        # Set contextual tags
+        span.set_tag(Ext::Test::TAG_FRAMEWORK, tags[:framework]) if tags[:framework]
+        span.set_tag(Ext::Test::TAG_NAME, tags[:test_name]) if tags[:test_name]
+        span.set_tag(Ext::Test::TAG_SUITE, tags[:test_suite]) if tags[:test_suite]
+        span.set_tag(Ext::Test::TAG_TYPE, tags[:test_type]) if tags[:test_type]
+
+        span
+      end
+
+      def self.passed!(span)
+        span.set_tag(Ext::Test::TAG_STATUS, Ext::Test::Status::PASS)
+      end
+
+      def self.failed!(span, exception = nil)
+        span.status = 1
+        span.set_tag(Ext::Test::TAG_STATUS, Ext::Test::Status::FAIL)
+        span.set_error(exception) unless exception.nil?
+      end
+
+      def self.skipped!(span, exception = nil)
+        span.set_tag(Ext::Test::TAG_STATUS, Ext::Test::Status::SKIP)
+        span.set_error(exception) unless exception.nil?
+      end
+    end
+  end
+end

data/lib/ddtrace.rb

@@ -48,7 +48,6 @@ require 'ddtrace/contrib/active_record/integration'
 require 'ddtrace/contrib/active_support/integration'
 require 'ddtrace/contrib/aws/integration'
 require 'ddtrace/contrib/concurrent_ruby/integration'
-require 'ddtrace/contrib/cucumber/integration'
 require 'ddtrace/contrib/dalli/integration'
 require 'ddtrace/contrib/delayed_job/integration'
 require 'ddtrace/contrib/elasticsearch/integration'
@@ -75,7 +74,6 @@ require 'ddtrace/contrib/rake/integration'
 require 'ddtrace/contrib/redis/integration'
 require 'ddtrace/contrib/resque/integration'
 require 'ddtrace/contrib/rest_client/integration'
-require 'ddtrace/contrib/rspec/integration'
 require 'ddtrace/contrib/sequel/integration'
 require 'ddtrace/contrib/shoryuken/integration'
 require 'ddtrace/contrib/sidekiq/integration'

data/lib/ddtrace/configuration.rb

@@ -2,11 +2,10 @@ require 'forwardable'
 require 'ddtrace/configuration/pin_setup'
 require 'ddtrace/configuration/settings'
 require 'ddtrace/configuration/components'
-require 'ddtrace/utils/only_once'
 
 module Datadog
   # Configuration provides a unique access point for configurations
-  module Configuration # rubocop:disable Metrics/ModuleLength
+  module Configuration
     extend Forwardable
 
     # Used to ensure that @components initialization/reconfiguration is performed one-at-a-time, by a single thread.
@@ -43,8 +42,6 @@ module Datadog
     end
 
     def configure(target = configuration, opts = {})
-      ruby_version_deprecation_warning
-
       if target.is_a?(Settings)
         yield(target) if block_given?
 
@@ -175,24 +172,5 @@ module Datadog
         logger
       end
     end
-
-    # Perform version check only once
-    DEPRECATED_RUBY_VERSION = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.1')
-    private_constant :DEPRECATED_RUBY_VERSION
-
-    RUBY_VERSION_DEPRECATION_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
-    private_constant :RUBY_VERSION_DEPRECATION_ONLY_ONCE
-
-    def ruby_version_deprecation_warning
-      return unless DEPRECATED_RUBY_VERSION
-
-      RUBY_VERSION_DEPRECATION_ONLY_ONCE.run do
-        Datadog.logger.warn(
-          "Support for Ruby versions < 2.1 in dd-trace-rb is DEPRECATED.\n" \
-          "Last version to support Ruby < 2.1 will be 0.49.x, which will only receive critical bugfixes.\n" \
-          'Support for Ruby versions < 2.1 will be REMOVED in version 0.50.0.'
-        )
-      end
-    end
   end
 end

data/lib/ddtrace/configuration/agent_settings_resolver.rb

@@ -27,15 +27,12 @@ module Datadog
           :deprecated_for_removal_transport_configuration_options
         ) do
           def initialize(
-            # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
-            ssl: raise(ArgumentError, 'missing keyword :ssl'),
-            hostname: raise(ArgumentError, 'missing keyword :hostname'),
-            port: raise(ArgumentError, 'missing keyword :port'),
-            timeout_seconds: raise(ArgumentError, 'missing keyword :timeout_seconds'),
-            deprecated_for_removal_transport_configuration_proc: \
-              raise(ArgumentError, 'missing keyword :deprecated_for_removal_transport_configuration_proc'),
-            deprecated_for_removal_transport_configuration_options: \
-              raise(ArgumentError, 'missing keyword :deprecated_for_removal_transport_configuration_options')
+            ssl:,
+            hostname:,
+            port:,
+            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)
@@ -179,11 +176,7 @@ module Datadog
         @unparsed_url_from_env ||= ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL]
       end
 
-      def pick_from(
-        # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
-        configurations_in_priority_order: raise(ArgumentError, 'missing keyword :configurations'),
-        or_use_default: raise(ArgumentError, 'missing keyword :or_use_default')
-      )
+      def pick_from(configurations_in_priority_order:, or_use_default:)
         detected_configurations_in_priority_order = configurations_in_priority_order.select(&:value?)
 
         if detected_configurations_in_priority_order.any?
@@ -213,11 +206,7 @@ module Datadog
       end
 
       DetectedConfiguration = Struct.new(:friendly_name, :value) do
-        def initialize(
-          # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
-          friendly_name: raise(ArgumentError, 'missing keyword :friendly_name'),
-          value: raise(ArgumentError, 'missing keyword :value')
-        )
+        def initialize(friendly_name:, value:)
           super(friendly_name, value)
           freeze
         end

data/lib/ddtrace/configuration/base.rb

@@ -6,12 +6,12 @@ module Datadog
     # Basic configuration behavior
     module Base
       def self.included(base)
-        base.send(:extend, Datadog::Environment::Helpers)
-        base.send(:include, Datadog::Environment::Helpers)
-        base.send(:include, Options)
+        base.extend(Datadog::Environment::Helpers)
+        base.include(Datadog::Environment::Helpers)
+        base.include(Options)
 
-        base.send(:extend, ClassMethods)
-        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
       end
 
       # Class methods for configuration
@@ -53,10 +53,7 @@ module Datadog
           ordering = self.class.options.dependency_order
           sorted_opts = opts.sort_by do |name, _value|
             ordering.index(name) || (ordering.length + 1)
-          end
-
-          # Ruby 2.0 doesn't support Array#to_h
-          sorted_opts = Hash[*sorted_opts.flatten]
+          end.to_h
 
           # Apply options in sort order
           sorted_opts.each do |name, value|

data/lib/ddtrace/configuration/components.rb

@@ -4,11 +4,13 @@ require 'ddtrace/logger'
 require 'ddtrace/profiling'
 require 'ddtrace/runtime/metrics'
 require 'ddtrace/tracer'
+require 'ddtrace/sync_writer'
 require 'ddtrace/workers/runtime_metrics'
 
 module Datadog
   module Configuration
     # Global components for the trace library.
+    # rubocop:disable Metrics/ClassLength
     # rubocop:disable Layout/LineLength
     class Components
       class << self
@@ -63,7 +65,7 @@ module Datadog
           #       tracer initialization for now. Just reconfigure using the
           #       existing mutable #configure function. Remove when these components
           #       are extracted.
-          tracer.configure(agent_settings: agent_settings, **build_tracer_options(settings))
+          tracer.configure(agent_settings: agent_settings, **build_tracer_options(settings, agent_settings))
 
           tracer
         end
@@ -93,16 +95,37 @@ module Datadog
           end
         end
 
-        def build_tracer_options(settings)
-          settings = settings.tracer
+        def build_tracer_options(settings, agent_settings)
+          tracer_options = {}.tap do |opts|
+            tset = settings.tracer
+            opts[:min_spans_before_partial_flush] = tset.partial_flush.min_spans_threshold unless tset.partial_flush.min_spans_threshold.nil?
+            opts[:partial_flush] = tset.partial_flush.enabled unless tset.partial_flush.enabled.nil?
+            opts[:priority_sampling] = tset.priority_sampling unless tset.priority_sampling.nil?
+            opts[:sampler] = tset.sampler unless tset.sampler.nil?
+            opts[:writer] = tset.writer unless tset.writer.nil?
+            opts[:writer_options] = tset.writer_options if tset.writer.nil?
+          end
+
+          # Apply test mode settings if test mode is activated
+          if settings.test_mode.enabled
+            build_tracer_test_mode_options(tracer_options, settings, agent_settings)
+          else
+            tracer_options
+          end
+        end
+
+        def build_tracer_test_mode_options(tracer_options, settings, agent_settings)
+          tracer_options.tap do |opts|
+            # Do not sample any spans for tests; all must be preserved.
+            opts[:sampler] = Datadog::AllSampler.new
+
+            # If context flush behavior is provided, use it instead.
+            opts[:context_flush] = settings.test_mode.context_flush if settings.test_mode.context_flush
 
-          {}.tap do |opts|
-            opts[:min_spans_before_partial_flush] = settings.partial_flush.min_spans_threshold unless settings.partial_flush.min_spans_threshold.nil?
-            opts[:partial_flush] = settings.partial_flush.enabled unless settings.partial_flush.enabled.nil?
-            opts[:priority_sampling] = settings.priority_sampling unless settings.priority_sampling.nil?
-            opts[:sampler] = settings.sampler unless settings.sampler.nil?
-            opts[:writer] = settings.writer unless settings.writer.nil?
-            opts[:writer_options] = settings.writer_options if settings.writer.nil?
+            # Flush traces synchronously, to guarantee they are written.
+            writer_options = settings.test_mode.writer_options || {}
+            writer_options[:agent_settings] = agent_settings if agent_settings
+            opts[:writer] = Datadog::SyncWriter.new(writer_options)
           end
         end
 

data/lib/ddtrace/configuration/options.rb

@@ -7,8 +7,8 @@ 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

data/lib/ddtrace/configuration/settings.rb

@@ -6,6 +6,7 @@ require 'ddtrace/ext/distributed'
 require 'ddtrace/ext/profiling'
 require 'ddtrace/ext/runtime'
 require 'ddtrace/ext/sampling'
+require 'ddtrace/ext/test'
 
 module Datadog
   module Configuration
@@ -14,6 +15,32 @@ module Datadog
     class Settings
       include Base
 
+      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) }
@@ -90,6 +117,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
@@ -197,6 +225,7 @@ module Datadog
       end
 
       option :service do |o|
+        # 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, nil) }
         o.lazy
       end
@@ -225,9 +254,10 @@ 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
+
           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)
@@ -245,6 +275,23 @@ 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 }
 
@@ -332,6 +379,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