ddtrace 0.24.0 → 0.25.0

data/lib/ddtrace/configuration.rb

@@ -6,16 +6,24 @@ module Datadog
   module Configuration
     attr_writer :configuration
 
+    RUBY_19_DEPRECATION_WARNING = %(
+      Support for Ruby versions < 2.0 in dd-trace-rb is DEPRECATED.
+      Last version to support Ruby < 2.0 will be 0.26.x, which will only receive critical bugfixes to existing features.
+      Support for Ruby versions < 2.0 will be REMOVED with version 0.27.0.).freeze
+
     def configuration
       @configuration ||= Settings.new
     end
 
     def configure(target = configuration, opts = {})
       if target.is_a?(Settings)
-        yield(target)
+        yield(target) if block_given?
       else
         PinSetup.new(target, opts).call
       end
+
+      # Raise Ruby 1.9 deprecation warning, if necessary.
+      raise_ruby_19_deprecation_warning!
     end
 
     # Helper methods
@@ -26,5 +34,16 @@ module Datadog
     def runtime_metrics
       tracer.writer.runtime_metrics
     end
+
+    # TODO: Remove with version 0.27.0
+    def raise_ruby_19_deprecation_warning!
+      return unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.0')
+
+      require 'ddtrace/patcher'
+
+      Datadog::Patcher.do_once(:ruby_19_deprecation_warning) do
+        Datadog::Tracer.log.warn(RUBY_19_DEPRECATION_WARNING)
+      end
+    end
   end
 end

data/lib/ddtrace/contrib/http/circuit_breaker.rb

@@ -5,24 +5,52 @@ module Datadog
       # HTTP integration circuit breaker behavior
       # For avoiding recursive traces.
       module CircuitBreaker
-        def should_skip_tracing?(req, address, port, transport, pin)
-          # we don't want to trace our own call to the API (they use net/http)
-          # when we know the host & port (from the URI) we use it, else (most-likely
+        def should_skip_tracing?(req, address, port, tracer)
+          return true if datadog_http_request?(req, address, port, tracer)
+
+          # we don't want a "shotgun" effect with two nested traces for one
+          # logical get, and request is likely to call itself recursively
+          active = tracer.active_span
+          return true if active && (active.name == Ext::SPAN_REQUEST)
+
+          false
+        end
+
+        # We don't want to trace our own call to the API (they use net/http)
+        # TODO: We don't want this kind of coupling with the transport.
+        #       Remove this when transport implements its own "skip tracing" mechanism.
+        def datadog_http_request?(req, address, port, tracer)
+          transport = tracer.writer.transport
+
+          transport_hostname = nil
+          transport_port = nil
+
+          # Get settings from transport, if available.
+          case transport
+          when Datadog::HTTPTransport
+            transport_hostname = transport.hostname.to_s
+            transport_port = transport.port.to_i
+          when Datadog::Transport::HTTP::Client
+            adapter = transport.current_api.adapter
+            if adapter.is_a?(Datadog::Transport::HTTP::Adapters::Net)
+              transport_hostname = adapter.hostname.to_s
+              transport_port = adapter.port.to_i
+            end
+          end
+
+          # When we know the host & port (from the URI) we use it, else (most-likely
           # called with a block) rely on the URL at the end.
           if req.respond_to?(:uri) && req.uri
-            if req.uri.host.to_s == transport.hostname.to_s &&
-               req.uri.port.to_i == transport.port.to_i
+            if req.uri.host.to_s == transport_hostname &&
+               req.uri.port.to_i == transport_port
               return true
             end
           elsif address && port &&
-                address.to_s == transport.hostname.to_s &&
-                port.to_i == transport.port.to_i
+                address.to_s == transport_hostname &&
+                port.to_i == transport_port
             return true
           end
-          # we don't want a "shotgun" effect with two nested traces for one
-          # logical get, and request is likely to call itself recursively
-          active = pin.tracer.active_span
-          return true if active && (active.name == Ext::SPAN_REQUEST)
+
           false
         end
 

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

@@ -54,9 +54,7 @@ module Datadog
             pin = datadog_pin
             return super(req, body, &block) unless pin && pin.tracer
 
-            transport = pin.tracer.writer.transport
-
-            if Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, transport, pin)
+            if Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, pin.tracer)
               return super(req, body, &block)
             end
 
@@ -67,14 +65,7 @@ module Datadog
                 span.resource = req.method
 
                 if pin.tracer.enabled && !Datadog::Contrib::HTTP.should_skip_distributed_tracing?(pin)
-                  req.add_field(Datadog::Ext::DistributedTracing::HTTP_HEADER_TRACE_ID, span.trace_id)
-                  req.add_field(Datadog::Ext::DistributedTracing::HTTP_HEADER_PARENT_ID, span.span_id)
-                  if span.context.sampling_priority
-                    req.add_field(
-                      Datadog::Ext::DistributedTracing::HTTP_HEADER_SAMPLING_PRIORITY,
-                      span.context.sampling_priority
-                    )
-                  end
+                  Datadog::HTTPPropagator.inject!(span.context, req)
                 end
               rescue StandardError => e
                 Datadog::Tracer.log.error("error preparing span for http request: #{e}")

data/lib/ddtrace/ext/forced_tracing.rb

@@ -1,9 +1,25 @@
+require 'ddtrace/ext/manual_tracing'
+require 'ddtrace/tracer'
+
 module Datadog
   module Ext
     # Defines constants for forced tracing
     module ForcedTracing
-      TAG_KEEP = 'manual.drop'.freeze
-      TAG_DROP = 'manual.keep'.freeze
+      @deprecation_warning_shown = false
+
+      def self.const_missing(name)
+        super unless Ext::ManualTracing.const_defined?(name)
+
+        # Only log each deprecation warning once (safeguard against log spam)
+        unless @deprecation_warning_shown
+          Datadog::Tracer.log.warn(
+            'forced tracing: Datadog::Ext::ForcedTracing has been renamed to Datadog::Ext::ManualTracing'
+          )
+          @deprecation_warning_shown = true
+        end
+
+        Ext::ManualTracing.const_get(name)
+      end
     end
   end
 end

data/lib/ddtrace/ext/manual_tracing.rb

@@ -0,0 +1,9 @@
+module Datadog
+  module Ext
+    # Defines constants for manual tracing
+    module ManualTracing
+      TAG_KEEP = 'manual.keep'.freeze
+      TAG_DROP = 'manual.drop'.freeze
+    end
+  end
+end

data/lib/ddtrace/ext/metrics.rb

@@ -4,7 +4,6 @@ module Datadog
       TAG_LANG = 'language'.freeze
       TAG_LANG_INTERPRETER = 'language-interpreter'.freeze
       TAG_LANG_VERSION = 'language-version'.freeze
-      TAG_RUNTIME_ID = 'runtime-id'.freeze
       TAG_TRACER_VERSION = 'tracer-version'.freeze
     end
   end

data/lib/ddtrace/ext/runtime.rb

@@ -16,7 +16,6 @@ module Datadog
       TRACER_VERSION = Datadog::VERSION::STRING
 
       TAG_LANG = 'language'.freeze
-      TAG_RUNTIME_ID = 'runtime-id'.freeze
 
       # Metrics
       module Metrics

data/lib/ddtrace/forced_tracing.rb

@@ -1,4 +1,4 @@
-require 'ddtrace/ext/forced_tracing'
+require 'ddtrace/ext/manual_tracing'
 require 'ddtrace/ext/priority'
 
 module Datadog
@@ -49,9 +49,9 @@ module Datadog
           # Configure sampling priority if they give us a forced tracing tag
           # DEV: Do not set if the value they give us is explicitly "false"
           case key
-          when Ext::ForcedTracing::TAG_KEEP
+          when Ext::ManualTracing::TAG_KEEP
             ForcedTracing.keep(self) unless value == false
-          when Ext::ForcedTracing::TAG_DROP
+          when Ext::ManualTracing::TAG_DROP
             ForcedTracing.drop(self) unless value == false
           else
             # Otherwise, set the tag normally.

data/lib/ddtrace/metrics.rb

@@ -117,9 +117,6 @@ module Datadog
         # and defaults are unfrozen for mutation in Statsd.
         DEFAULT.dup.tap do |options|
           options[:tags] = options[:tags].dup
-
-          # Add runtime ID dynamically because it might change during fork.
-          options[:tags] << "#{Ext::Metrics::TAG_RUNTIME_ID}:#{Runtime::Identity.id}".freeze
         end
       end
     end

data/lib/ddtrace/runtime/metrics.rb

@@ -26,7 +26,6 @@ module Datadog
 
         # Tag span with language and runtime ID for association with metrics
         span.set_tag(Ext::Runtime::TAG_LANG, Runtime::Identity.lang)
-        span.set_tag(Ext::Runtime::TAG_RUNTIME_ID, Runtime::Identity.id)
       end
 
       # Associate service with runtime metrics

data/lib/ddtrace/sync_writer.rb

@@ -12,7 +12,7 @@ module Datadog
     def initialize(options = {})
       @transport = options.fetch(:transport) do
         transport_options = options.fetch(:transport_options, {})
-        HTTPTransport.new(transport_options)
+        Transport::HTTP.default(transport_options)
       end
 
       # Runtime metrics

data/lib/ddtrace/tracer.rb

@@ -135,12 +135,9 @@ module Datadog
     #
     def configure(options = {})
       enabled = options.fetch(:enabled, nil)
-      hostname = options.fetch(:hostname, nil)
-      port = options.fetch(:port, nil)
 
       # Those are rare "power-user" options.
       sampler = options.fetch(:sampler, nil)
-      priority_sampling = options.fetch(:priority_sampling, nil)
       max_spans_before_partial_flush = options.fetch(:max_spans_before_partial_flush, nil)
       min_spans_before_partial_flush = options.fetch(:min_spans_before_partial_flush, nil)
       partial_flush_timeout = options.fetch(:partial_flush_timeout, nil)
@@ -148,19 +145,7 @@ module Datadog
       @enabled = enabled unless enabled.nil?
       @sampler = sampler unless sampler.nil?
 
-      # Re-build the sampler and writer if priority sampling is enabled,
-      # but neither are configured. Verify the sampler isn't already a
-      # priority sampler too, so we don't wrap one with another.
-      if priority_sampling != false && !@sampler.is_a?(PrioritySampler)
-        @sampler = PrioritySampler.new(base_sampler: @sampler)
-        @writer = Writer.new(priority_sampler: @sampler)
-      elsif priority_sampling == false
-        @sampler = sampler || Datadog::AllSampler.new if @sampler.is_a?(PrioritySampler)
-        @writer = Writer.new
-      end
-
-      @writer.transport.hostname = hostname unless hostname.nil?
-      @writer.transport.port = port unless port.nil?
+      configure_writer(options)
 
       @context_flush = Datadog::ContextFlush.new(options) unless min_spans_before_partial_flush.nil? &&
                                                                  max_spans_before_partial_flush.nil? &&
@@ -393,6 +378,82 @@ module Datadog
       @writer.write(trace)
     end
 
-    private :write, :guess_context_and_parent
+    # TODO: Move this kind of configuration building out of the tracer.
+    #       Tracer should not have this kind of knowledge of writer.
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
+    def configure_writer(options = {})
+      hostname = options.fetch(:hostname, nil)
+      port = options.fetch(:port, nil)
+      sampler = options.fetch(:sampler, nil)
+      priority_sampling = options.fetch(:priority_sampling, nil)
+      writer = options.fetch(:writer, nil)
+      transport_options = options.fetch(:transport_options, {})
+
+      # Compile writer options
+      rebuild_writer = false
+      writer_options = {}
+
+      # Re-build the sampler and writer if priority sampling is enabled,
+      # but neither are configured. Verify the sampler isn't already a
+      # priority sampler too, so we don't wrap one with another.
+      if options.key?(:writer)
+        if writer.priority_sampler.nil?
+          deactivate_priority_sampling!(sampler)
+        else
+          activate_priority_sampling!(writer.priority_sampler)
+        end
+      elsif priority_sampling != false && !@sampler.is_a?(PrioritySampler)
+        writer_options[:priority_sampler] = activate_priority_sampling!(@sampler)
+        rebuild_writer = true
+      elsif priority_sampling == false
+        deactivate_priority_sampling!(sampler)
+        rebuild_writer = true
+      elsif @sampler.is_a?(PrioritySampler)
+        # Make sure to add sampler to options if transport is rebuilt.
+        writer_options[:priority_sampler] = @sampler
+      end
+
+      # Apply options to transport
+      if transport_options.is_a?(Proc)
+        transport_options = { on_build: transport_options }
+        rebuild_writer = true
+      end
+
+      if hostname || port
+        transport_options[:hostname] = hostname unless hostname.nil?
+        transport_options[:port] = port unless port.nil?
+        rebuild_writer = true
+      end
+
+      writer_options[:transport_options] = transport_options
+
+      if rebuild_writer || writer
+        # Make sure old writer is shut down before throwing away.
+        # Don't want additional threads running...
+        @writer.stop unless writer.nil?
+        @writer = writer || Writer.new(writer_options)
+      end
+    end
+
+    def activate_priority_sampling!(base_sampler = nil)
+      @sampler = if base_sampler.is_a?(PrioritySampler)
+                   base_sampler
+                 else
+                   PrioritySampler.new(base_sampler: base_sampler)
+                 end
+    end
+
+    def deactivate_priority_sampling!(base_sampler = nil)
+      @sampler = base_sampler || Datadog::AllSampler.new if @sampler.is_a?(PrioritySampler)
+    end
+
+    private \
+      :activate_priority_sampling!,
+      :configure_writer,
+      :deactivate_priority_sampling!,
+      :guess_context_and_parent,
+      :write
   end
 end

data/lib/ddtrace/transport.rb

@@ -16,6 +16,12 @@ module Datadog
     DEFAULT_AGENT_HOST = '127.0.0.1'.freeze
     DEFAULT_TRACE_AGENT_PORT = '8126'.freeze
 
+    DEPRECATION_WARNING = %(
+      Datadog::HTTPTransport is deprecated as of version 0.24.0.
+      It has been replaced by Datadog::Transport:HTTP, which is the new default.
+      You can create one with `Datadog::Transport::HTTP.default`
+      Datadog::HTTPTransport will be REMOVED in version 0.25.0).freeze
+
     # seconds before the transport timeout
     TIMEOUT = 1
 
@@ -46,6 +52,9 @@ module Datadog
     private_constant :API
 
     def initialize(options = {})
+      # Log deprecation warning
+      Datadog::Tracer.log.warn(DEPRECATION_WARNING)
+
       api_version = options.fetch(:api_version, V3)
 
       @hostname = options[:hostname] || ENV['DD_AGENT_HOST'] || DEFAULT_AGENT_HOST

data/lib/ddtrace/transport/http.rb

@@ -0,0 +1,85 @@
+require 'ddtrace/version'
+require 'ddtrace/ext/runtime'
+
+require 'ddtrace/transport/http/builder'
+require 'ddtrace/transport/http/api'
+
+require 'ddtrace/transport/http/adapters/net'
+require 'ddtrace/transport/http/adapters/test'
+require 'ddtrace/transport/http/adapters/unix_socket'
+
+module Datadog
+  module Transport
+    # Namespace for HTTP transport components
+    module HTTP
+      DEFAULT_AGENT_HOST = '127.0.0.1'.freeze
+      DEFAULT_TRACE_AGENT_PORT = 8126
+      DEFAULT_HEADERS = {
+        'Datadog-Meta-Lang'.freeze => Datadog::Ext::Runtime::LANG,
+        'Datadog-Meta-Lang-Version'.freeze => Datadog::Ext::Runtime::LANG_VERSION,
+        'Datadog-Meta-Lang-Interpreter'.freeze => Datadog::Ext::Runtime::LANG_INTERPRETER,
+        'Datadog-Meta-Tracer-Version'.freeze => Datadog::Ext::Runtime::TRACER_VERSION
+      }.freeze
+
+      module_function
+
+      # Builds a new Transport::HTTP::Client
+      def new(&block)
+        Builder.new(&block).to_client
+      end
+
+      # Builds a new Transport::HTTP::Client with default settings
+      # Pass a block to override any settings.
+      def default(options = {})
+        new do |transport|
+          transport.adapter :net_http,
+                            ENV.fetch('DD_AGENT_HOST', DEFAULT_AGENT_HOST),
+                            ENV.fetch('DD_TRACE_AGENT_PORT', DEFAULT_TRACE_AGENT_PORT)
+
+          transport.headers DEFAULT_HEADERS
+
+          apis = API.defaults
+
+          transport.api API::V4, apis[API::V4], fallback: API::V3, default: true
+          transport.api API::V3, apis[API::V3], fallback: API::V2
+          transport.api API::V2, apis[API::V2]
+
+          # Apply any settings given by options
+          unless options.empty?
+            # Change hostname/port
+            if options.key?(:hostname) || options.key?(:port)
+              hostname = options.fetch(:hostname, default_hostname)
+              port = options.fetch(:port, default_port)
+              transport.adapter :net_http, hostname, port
+            end
+
+            # Change default API
+            transport.default_api = options[:api_version] if options.key?(:api_version)
+
+            # Add headers
+            transport.headers options[:headers] if options.key?(:headers)
+
+            # Execute on_build callback
+            options[:on_build].call(transport) if options[:on_build].is_a?(Proc)
+          end
+
+          # Call block to apply any customization, if provided.
+          yield(transport) if block_given?
+        end
+      end
+
+      def default_hostname
+        ENV.fetch('DD_AGENT_HOST', DEFAULT_AGENT_HOST)
+      end
+
+      def default_port
+        ENV.fetch('DD_TRACE_AGENT_PORT', DEFAULT_TRACE_AGENT_PORT)
+      end
+
+      # Add adapters to registry
+      Builder::REGISTRY.set(Adapters::Net, :net_http)
+      Builder::REGISTRY.set(Adapters::Test, :test)
+      Builder::REGISTRY.set(Adapters::UnixSocket, :unix)
+    end
+  end
+end