ddtrace 0.9.2 → 0.10.0

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

@@ -4,6 +4,9 @@ module Datadog
       # Patcher enables patching of 'active_record' module.
       # This is used in monkey.rb to manually apply patches
       module Patcher
+        include Base
+        register_as :active_record, auto_patch: false
+
         @patched = false
 
         module_function
@@ -41,7 +44,7 @@ module Datadog
         def self.datadog_trace
           # TODO: Consider using patcher for Rails as well.
           # @tracer ||= defined?(::Rails) && ::Rails.configuration.datadog_trace
-          @datadog_trace ||= defined?(::Sinatra) && ::Sinatra::Application.settings.datadog_tracer.cfg
+          @datadog_trace ||= defined?(::Sinatra) && Datadog.configuration[:sinatra].to_h
         end
 
         def self.adapter_name

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

@@ -7,6 +7,9 @@ module Datadog
 
       # Responsible for hooking the instrumentation into aws-sdk
       module Patcher
+        include Base
+        register_as :aws, auto_patch: true
+
         @patched = false
 
         class << self

data/lib/ddtrace/contrib/base.rb

@@ -0,0 +1,14 @@
+require 'ddtrace/registry'
+require 'ddtrace/configurable'
+
+module Datadog
+  module Contrib
+    # Base provides features that are shared across all integrations
+    module Base
+      def self.included(base)
+        base.send(:include, Registry::Registerable)
+        base.send(:include, Configurable)
+      end
+    end
+  end
+end

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

@@ -8,6 +8,9 @@ module Datadog
 
       # Responsible for hooking the instrumentation into `dalli`
       module Patcher
+        include Base
+        register_as :dalli, auto_patch: true
+
         @patched = false
 
         class << self

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

@@ -14,6 +14,9 @@ module Datadog
       # Patcher enables patching of 'elasticsearch/transport' module.
       # This is used in monkey.rb to automatically apply patches
       module Patcher
+        include Base
+        register_as :elasticsearch, auto_patch: true
+
         @patched = false
 
         module_function

data/lib/ddtrace/contrib/faraday/middleware.rb

@@ -1,13 +1,15 @@
 require 'faraday'
 require 'ddtrace/ext/http'
 require 'ddtrace/ext/net'
-require 'ddtrace/ext/distributed'
+require 'ddtrace/propagation/http_propagator'
 
 module Datadog
   module Contrib
     module Faraday
       # Middleware implements a faraday-middleware for ddtrace instrumentation
       class Middleware < ::Faraday::Middleware
+        include Ext::DistributedTracing
+
         DEFAULT_ERROR_HANDLER = lambda do |env|
           Ext::HTTP::ERROR_RANGE.cover?(env[:status])
         end
@@ -26,7 +28,7 @@ module Datadog
         def call(env)
           dd_pin.tracer.trace(SERVICE) do |span|
             annotate!(span, env)
-            propagate!(span, env) if options[:distributed_tracing]
+            propagate!(span, env) if options[:distributed_tracing] && dd_pin.tracer.enabled
             app.call(env).on_complete { |resp| handle_response(span, resp) }
           end
         end
@@ -54,10 +56,7 @@ module Datadog
         end
 
         def propagate!(span, env)
-          env[:request_headers].merge!(
-            Ext::DistributedTracing::HTTP_HEADER_TRACE_ID => span.trace_id.to_s,
-            Ext::DistributedTracing::HTTP_HEADER_PARENT_ID => span.span_id.to_s
-          )
+          Datadog::HTTPPropagator.inject!(span.context, env[:request_headers])
         end
 
         def dd_pin

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

@@ -6,6 +6,9 @@ module Datadog
 
       # Responsible for hooking the instrumentation into faraday
       module Patcher
+        include Base
+        register_as :faraday, auto_patch: true
+
         @patched = false
 
         class << self

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

@@ -6,6 +6,9 @@ module Datadog
       # Patcher that introduces more instrumentation for Grape endpoints, so that
       # new signals are executed at the beginning of each step (filters, render and run)
       module Patcher
+        include Base
+        register_as :grape, auto_patch: true
+
         @patched = false
 
         module_function

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

@@ -12,13 +12,17 @@ module Datadog
       APP = 'net/http'.freeze
       SERVICE = 'net/http'.freeze
 
-      @distributed_tracing_enabled = false
+      module_function
 
-      class << self
-        attr_accessor :distributed_tracing_enabled
+      # TODO: Remove this once we drop support for legacy configuration
+      def distributed_tracing_enabled
+        Datadog.configuration[:http][:distributed_tracing_enabled]
       end
 
-      module_function
+      # TODO: Remove this once we drop support for legacy configuration
+      def distributed_tracing_enabled=(value)
+        Datadog.configuration[:http][:distributed_tracing_enabled] = value
+      end
 
       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)
@@ -42,15 +46,20 @@ module Datadog
       end
 
       def should_skip_distributed_tracing?(pin)
+        global_value = Datadog.configuration[:http][:distributed_tracing_enabled]
         unless pin.config.nil?
-          return !pin.config.fetch(:distributed_tracing_enabled, @distributed_tracing_enabled)
+          return !pin.config.fetch(:distributed_tracing_enabled, global_value)
         end
-        !@distributed_tracing_enabled
+        !global_value
       end
 
       # Patcher enables patching of 'net/http' module.
       # This is used in monkey.rb to automatically apply patches
       module Patcher
+        include Base
+        register_as :http, auto_patch: true
+        option :distributed_tracing_enabled, default: false
+
         @patched = false
 
         module_function
@@ -120,9 +129,15 @@ module Datadog
                   span.set_tag(Datadog::Ext::HTTP::URL, req.path)
                   span.set_tag(Datadog::Ext::HTTP::METHOD, req.method)
 
-                  unless Datadog::Contrib::HTTP.should_skip_distributed_tracing?(pin)
+                  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
                   end
                 rescue StandardError => e
                   Datadog::Tracer.log.error("error preparing span for http request: #{e}")

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

@@ -11,6 +11,9 @@ module Datadog
       # Use the `Datadog::Monkey.patch_module(:mongodb)` to activate tracing for
       # this module.
       module Patcher
+        include Base
+        register_as :mongo, auto_patch: true
+
         @patched = false
 
         module_function

data/lib/ddtrace/contrib/rack/middlewares.rb

@@ -1,41 +1,32 @@
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/http'
-require 'ddtrace/distributed'
+require 'ddtrace/propagation/http_propagator'
 
 module Datadog
   module Contrib
     # Rack module includes middlewares that are required to trace any framework
     # and application built on top of Rack.
     module Rack
-      # RACK headers to test when doing distributed tracing.
-      # They are slightly different from real headers as Rack uppercases everything
-
-      # Header used to transmit the trace ID.
-      HTTP_HEADER_TRACE_ID = 'HTTP_X_DATADOG_TRACE_ID'.freeze
-
-      # Header used to transmit the parent ID.
-      HTTP_HEADER_PARENT_ID = 'HTTP_X_DATADOG_PARENT_ID'.freeze
-
       # TraceMiddleware ensures that the Rack Request is properly traced
       # from the beginning to the end. The middleware adds the request span
       # in the Rack environment so that it can be retrieved by the underlying
       # application. If request tags are not set by the app, they will be set using
       # information available at the Rack level.
       class TraceMiddleware
-        DEFAULT_CONFIG = {
-          tracer: Datadog.tracer,
-          default_service: 'rack',
-          distributed_tracing_enabled: false
-        }.freeze
+        include Base
+        register_as :rack
+
+        option :tracer, default: Datadog.tracer
+        option :default_service, default: 'rack'
+        option :distributed_tracing_enabled, default: false
 
         def initialize(app, options = {})
           # update options with our configuration, unless it's already available
           [:tracer, :default_service, :distributed_tracing_enabled].each do |k|
-            options[k] ||= DEFAULT_CONFIG[k]
+            Datadog.configuration[:rack][k] = options[k] unless options[k].nil?
           end
 
           @app = app
-          @options = options
         end
 
         def configure
@@ -43,9 +34,9 @@ module Datadog
           return clean_context if @tracer && @service
 
           # retrieve the current tracer and service
-          @tracer = @options.fetch(:tracer)
-          @service = @options.fetch(:default_service)
-          @distributed_tracing_enabled = @options.fetch(:distributed_tracing_enabled)
+          @tracer = Datadog.configuration[:rack][:tracer]
+          @service = Datadog.configuration[:rack][:default_service]
+          @distributed_tracing_enabled = Datadog.configuration[:rack][:distributed_tracing_enabled]
 
           # configure the Rack service
           @tracer.set_service_info(
@@ -66,21 +57,16 @@ module Datadog
             span_type: Datadog::Ext::HTTP::TYPE
           }
 
-          # start a new request span and attach it to the current Rack environment;
-          # we must ensure that the span `resource` is set later
-          request_span = @tracer.trace('rack.request', trace_options)
-
-          if @distributed_tracing_enabled
-            # Merge distributed trace ids if present
-            #
-            # Use integer values for tests, as it will catch both
-            # a non-existing header or a badly formed one.
-            trace_id, parent_id = Datadog::Distributed.parse_trace_headers(
-              env[Datadog::Contrib::Rack::HTTP_HEADER_TRACE_ID],
-              env[Datadog::Contrib::Rack::HTTP_HEADER_PARENT_ID]
-            )
-            request_span.trace_id = trace_id unless trace_id.nil?
-            request_span.parent_id = parent_id unless parent_id.nil?
+          request_span = nil
+          begin
+            if @distributed_tracing_enabled
+              context = HTTPPropagator.extract(env)
+              @tracer.provider.context = context if context.trace_id
+            end
+          ensure
+            # start a new request span and attach it to the current Rack environment;
+            # we must ensure that the span `resource` is set later
+            request_span = @tracer.trace('rack.request', trace_options)
           end
 
           env[:datadog_rack_request_span] = request_span

data/lib/ddtrace/contrib/rails/action_controller.rb

@@ -13,8 +13,8 @@ module Datadog
 
         def self.start_processing(payload)
           # trace the execution
-          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
-          service = ::Rails.configuration.datadog_trace.fetch(:default_controller_service)
+          tracer = Datadog.configuration[:rails][:tracer]
+          service = Datadog.configuration[:rails][:default_controller_service]
           type = Datadog::Ext::HTTP::TYPE
           span = tracer.trace('rails.action_controller', service: service, span_type: type)
 

data/lib/ddtrace/contrib/rails/action_view.rb

@@ -15,7 +15,7 @@ module Datadog
           tracing_context = payload.fetch(:tracing_context)
 
           # create a new Span and add it to the tracing context
-          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          tracer = Datadog.configuration[:rails][:tracer]
           span = tracer.trace('rails.render_template', span_type: Datadog::Ext::HTTP::TEMPLATE)
           tracing_context[:dd_rails_template_span] = span
         rescue StandardError => e
@@ -48,7 +48,7 @@ module Datadog
           # retrieve the tracing context
           tracing_context = payload.fetch(:tracing_context)
 
-          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          tracer = Datadog.configuration[:rails][:tracer]
           span = tracer.trace('rails.render_partial', span_type: Datadog::Ext::HTTP::TEMPLATE)
           tracing_context[:dd_rails_partial_span] = span
         rescue StandardError => e

data/lib/ddtrace/contrib/rails/active_record.rb

@@ -18,8 +18,8 @@ module Datadog
         end
 
         def self.sql(_name, start, finish, _id, payload)
-          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
-          database_service = ::Rails.configuration.datadog_trace.fetch(:default_database_service)
+          tracer = Datadog.configuration[:rails][:tracer]
+          database_service = Datadog.configuration[:rails][:default_database_service]
           adapter_name = ::ActiveRecord::Base.connection_config[:adapter]
           adapter_name = Datadog::Contrib::Rails::Utils.normalize_vendor(adapter_name)
           span_type = Datadog::Ext::SQL::TYPE

data/lib/ddtrace/contrib/rails/active_support.rb

@@ -12,7 +12,7 @@ module Datadog
         end
 
         def self.start_trace_cache(payload)
-          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          tracer = Datadog.configuration[:rails][:tracer]
           tracing_context = payload.fetch(:tracing_context)
 
           # In most of the cases Rails ``fetch()`` and ``read()`` calls are nested.
@@ -26,7 +26,7 @@ module Datadog
                     payload[:action] == 'GET'
 
           # create a new ``Span`` and add it to the tracing context
-          service = ::Rails.configuration.datadog_trace.fetch(:default_cache_service)
+          service = Datadog.configuration[:rails][:default_cache_service]
           type = Datadog::Ext::CACHE::TYPE
           span = tracer.trace('rails.cache', service: service, span_type: type)
           span.resource = payload.fetch(:action)

data/lib/ddtrace/contrib/rails/framework.rb

@@ -30,82 +30,60 @@ module Datadog
       # - handle configuration entries which are specific to Datadog tracing
       # - instrument parts of the framework when needed
       module Framework
-        # default configurations for the Rails integration; by default
-        # the Datadog.tracer is enabled, while the Rails auto instrumentation
-        # is kept disabled.
-        DEFAULT_CONFIG = {
-          enabled: true,
-          auto_instrument: false,
-          auto_instrument_redis: false,
-          auto_instrument_grape: false,
-          default_service: 'rails-app',
-          default_controller_service: 'rails-controller',
-          default_cache_service: 'rails-cache',
-          default_grape_service: 'grape',
-          template_base_path: 'views/',
-          tracer: Datadog.tracer,
-          debug: false,
-          trace_agent_hostname: Datadog::Writer::HOSTNAME,
-          trace_agent_port: Datadog::Writer::PORT,
-          env: nil,
-          tags: {}
-        }.freeze
-
         # configure Datadog settings
         # rubocop:disable Metrics/MethodLength
-        def self.configure(config)
-          # tracer defaults
-          # merge default configurations with users settings
-          user_config = config[:config].datadog_trace rescue {}
-          datadog_config = DEFAULT_CONFIG.merge(user_config)
-          datadog_config[:tracer].enabled = datadog_config[:enabled]
-
-          # set debug logging
-          Datadog::Tracer.debug_logging = datadog_config[:debug]
-
-          # set the address of the trace agent
-          datadog_config[:tracer].configure(
-            hostname: datadog_config[:trace_agent_hostname],
-            port: datadog_config[:trace_agent_port]
+        # rubocop:disable Metrics/AbcSize
+        def self.configure(rails_config)
+          user_config = rails_config[:config].datadog_trace rescue {}
+          Datadog.configuration.use(:rails, user_config)
+          tracer = Datadog.configuration[:rails][:tracer]
+
+          tracer.enabled = Datadog.configuration[:rails][:enabled]
+          tracer.class.debug_logging = Datadog.configuration[:rails][:debug]
+
+          tracer.configure(
+            hostname: Datadog.configuration[:rails][:trace_agent_hostname],
+            port: Datadog.configuration[:rails][:trace_agent_port],
+            priority_sampling: Datadog.configuration[:rails][:priority_sampling]
           )
 
-          # set default tracer tags
-          datadog_config[:tracer].set_tags(datadog_config[:tags])
-
-          datadog_config[:tracer].set_tags('env' => datadog_config[:env]) if datadog_config[:env]
+          tracer.set_tags(Datadog.configuration[:rails][:tags])
+          tracer.set_tags('env' => Datadog.configuration[:rails][:env]) if Datadog.configuration[:rails][:env]
 
-          # set default service details
-          datadog_config[:tracer].set_service_info(
-            datadog_config[:default_service],
+          tracer.set_service_info(
+            Datadog.configuration[:rails][:default_service],
             'rack',
             Datadog::Ext::AppTypes::WEB
           )
 
-          datadog_config[:tracer].set_service_info(
-            datadog_config[:default_controller_service],
+          tracer.set_service_info(
+            Datadog.configuration[:rails][:default_controller_service],
             'rails',
             Datadog::Ext::AppTypes::WEB
           )
-
-          datadog_config[:tracer].set_service_info(
-            datadog_config[:default_cache_service],
+          tracer.set_service_info(
+            Datadog.configuration[:rails][:default_cache_service],
             'rails',
             Datadog::Ext::AppTypes::CACHE
           )
 
           # By default, default service would be guessed from the script
           # being executed, but here we know better, get it from Rails config.
-          datadog_config[:tracer].default_service = datadog_config[:default_service]
+          tracer.default_service = Datadog.configuration[:rails][:default_service]
+
+          Datadog.configuration[:rack][:tracer] = tracer
+          Datadog.configuration[:rack][:default_service] = Datadog.configuration[:rails][:default_service]
+          Datadog.configuration[:rack][:distributed_tracing_enabled] = \
+            Datadog.configuration[:rails][:distributed_tracing_enabled]
 
           if defined?(::ActiveRecord)
             begin
               # set default database service details and store it in the configuration
               conn_cfg = ::ActiveRecord::Base.connection_config()
               adapter_name = Datadog::Contrib::Rails::Utils.normalize_vendor(conn_cfg[:adapter])
-              database_service = datadog_config.fetch(:default_database_service, adapter_name)
-              datadog_config[:default_database_service] = database_service
-              datadog_config[:tracer].set_service_info(
-                database_service,
+              Datadog.configuration[:rails][:default_database_service] ||= adapter_name
+              tracer.set_service_info(
+                Datadog.configuration[:rails][:default_database_service],
                 adapter_name,
                 Datadog::Ext::AppTypes::DB
               )
@@ -115,11 +93,11 @@ module Datadog
           end
 
           # update global configurations
-          ::Rails.configuration.datadog_trace = datadog_config
+          ::Rails.configuration.datadog_trace = Datadog.registry[:rails].to_h
         end
 
         def self.auto_instrument_redis
-          return unless ::Rails.configuration.datadog_trace[:auto_instrument_redis]
+          return unless Datadog.configuration[:rails][:auto_instrument_redis]
           Datadog::Tracer.log.debug('Enabling auto-instrumentation for Redis client')
 
           # patch the Redis library and reload the CacheStore if it was using Redis
@@ -142,7 +120,7 @@ module Datadog
         end
 
         def self.auto_instrument_grape
-          return unless ::Rails.configuration.datadog_trace[:auto_instrument_grape]
+          return unless Datadog.configuration[:rails][:auto_instrument_grape]
 
           # patch the Grape library so that endpoints are traced
           Datadog::Monkey.patch_module(:grape)
@@ -150,13 +128,13 @@ module Datadog
           # update the Grape pin object
           pin = Datadog::Pin.get_from(::Grape)
           return unless pin && pin.enabled?
-          pin.tracer = ::Rails.configuration.datadog_trace[:tracer]
-          pin.service = ::Rails.configuration.datadog_trace[:default_grape_service]
+          pin.tracer = Datadog.configuration[:rails][:tracer]
+          pin.service = Datadog.configuration[:rails][:default_grape_service]
         end
 
         # automatically instrument all Rails component
         def self.auto_instrument
-          return unless ::Rails.configuration.datadog_trace[:auto_instrument]
+          return unless Datadog.configuration[:rails][:auto_instrument]
           Datadog::Tracer.log.debug('Enabling auto-instrumentation for core components')
 
           # instrumenting Rails framework