ddtrace 0.16.1 → 0.17.0

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

@@ -1,6 +1,7 @@
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/http'
 require 'ddtrace/propagation/http_propagator'
+require 'ddtrace/contrib/rack/ext'
 require 'ddtrace/contrib/rack/request_queue'
 
 module Datadog
@@ -15,6 +16,8 @@ module Datadog
       # information available at the Rack level.
       # rubocop:disable Metrics/ClassLength
       class TraceMiddleware
+        # DEPRECATED: Remove in 1.0 in favor of Datadog::Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN
+        # This constant will remain here until then, for backwards compatibility.
         RACK_REQUEST_SPAN = 'datadog.rack_request_span'.freeze
 
         def initialize(app)
@@ -29,7 +32,7 @@ module Datadog
           return if request_start.nil?
 
           tracer.trace(
-            'http_server.queue',
+            Ext::SPAN_HTTP_SERVER_QUEUE,
             start_time: request_start,
             service: Datadog.configuration[:rack][:web_service_name]
           )
@@ -56,7 +59,7 @@ module Datadog
 
           # 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)
+          request_span = tracer.trace(Ext::SPAN_REQUEST, trace_options)
           env[RACK_REQUEST_SPAN] = request_span
 
           # Add deprecation warnings

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

@@ -3,47 +3,26 @@ module Datadog
     module Rack
       # Provides instrumentation for `rack`
       module Patcher
-        include Base
+        include Contrib::Patcher
 
-        DEFAULT_HEADERS = {
-          response: [
-            'Content-Type',
-            'X-Request-ID'
-          ]
-        }.freeze
+        module_function
 
-        register_as :rack
-        option :tracer, default: Datadog.tracer
-        option :distributed_tracing, default: false
-        option :middleware_names, default: false
-        option :quantize, default: {}
-        option :application
-        option :service_name, default: 'rack', depends_on: [:tracer] do |value|
-          get_option(:tracer).set_service_info(value, 'rack', Ext::AppTypes::WEB)
-          value
-        end
-        option :request_queuing, default: false
-        option :web_service_name, default: 'web-server', depends_on: [:tracer, :request_queuing] do |value|
-          if get_option(:request_queuing)
-            get_option(:tracer).set_service_info(value, 'webserver', Ext::AppTypes::WEB)
-          end
-          value
+        def patched?
+          done?(:rack)
         end
-        option :headers, default: DEFAULT_HEADERS
-
-        module_function
 
         def patch
-          unless patched?
+          # Patch middleware
+          do_once(:rack) do
             require_relative 'middlewares'
-            @patched = true
           end
 
-          if (!instance_variable_defined?(:@middleware_patched) || !@middleware_patched) \
-             && get_option(:middleware_names)
+          # Patch middleware names
+          if !done?(:rack_middleware_names) && get_option(:middleware_names)
             if get_option(:application)
-              enable_middleware_names
-              @middleware_patched = true
+              do_once(:rack_middleware_names) do
+                patch_middleware_names
+              end
             else
               Datadog::Tracer.log.warn(%(
               Rack :middleware_names requires you to also pass :application.
@@ -51,15 +30,11 @@ module Datadog
               e.g. use: :rack, middleware_names: true, application: my_rack_app).freeze)
             end
           end
-
-          @patched || @middleware_patched
+        rescue StandardError => e
+          Datadog::Tracer.log.error("Unable to apply Rack integration: #{e}")
         end
 
-        def patched?
-          @patched ||= false
-        end
-
-        def enable_middleware_names
+        def patch_middleware_names
           retain_middleware_name(get_option(:application))
         rescue => e
           # We can safely ignore these exceptions since they happen only in the
@@ -81,9 +56,16 @@ module Datadog
             end
           end
 
-          following = middleware.instance_variable_get('@app')
+          following = if middleware.instance_variable_defined?('@app')
+                        middleware.instance_variable_get('@app')
+                      end
+
           retain_middleware_name(following)
         end
+
+        def get_option(option)
+          Datadog.configuration[:rack].get_option(option)
+        end
       end
     end
   end

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

@@ -1,5 +1,7 @@
 require 'ddtrace/ext/http'
 require 'ddtrace/ext/errors'
+require 'ddtrace/contrib/rack/ext'
+require 'ddtrace/contrib/rails/ext'
 
 module Datadog
   module Contrib
@@ -20,7 +22,7 @@ module Datadog
           tracer = Datadog.configuration[:rails][:tracer]
           service = Datadog.configuration[:rails][:controller_service]
           type = Datadog::Ext::HTTP::TYPE
-          span = tracer.trace('rails.action_controller', service: service, span_type: type)
+          span = tracer.trace(Ext::SPAN_ACTION_CONTROLLER, service: service, span_type: type)
 
           # attach the current span to the tracing context
           tracing_context = payload.fetch(:tracing_context)
@@ -32,6 +34,7 @@ module Datadog
         def self.finish_processing(payload)
           # retrieve the tracing context and the latest active span
           tracing_context = payload.fetch(:tracing_context)
+          env = payload.fetch(:env)
           span = tracing_context[:dd_request_span]
           return unless span && !span.finished?
 
@@ -41,14 +44,14 @@ module Datadog
               span.resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
             end
 
-            # Set the parent resource if it's a `rack.request` span,
-            # but not if its an exception contoller.
-            if !span.parent.nil? && span.parent.name == 'rack.request' && !exception_controller?(payload)
-              span.parent.resource = span.resource
+            # Set the resource name of the Rack request span unless this is an exception controller.
+            unless exception_controller?(payload)
+              rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
+              rack_request_span.resource = span.resource if rack_request_span
             end
 
-            span.set_tag('rails.route.action', payload.fetch(:action))
-            span.set_tag('rails.route.controller', payload.fetch(:controller))
+            span.set_tag(Ext::TAG_ROUTE_ACTION, payload.fetch(:action))
+            span.set_tag(Ext::TAG_ROUTE_CONTROLLER, payload.fetch(:controller))
 
             exception = payload[:exception_object]
             if exception.nil?

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

@@ -34,6 +34,7 @@ module Datadog
             payload = {
               controller: self.class,
               action: action_name,
+              env: request.env,
               headers: {
                 # The exception this controller was given in the request,
                 # which is typical if the controller is configured to handle exceptions.

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

@@ -1,5 +1,5 @@
 require 'thread'
-require 'ddtrace/ext/cache'
+require 'ddtrace/contrib/rails/ext'
 
 module Datadog
   module Contrib
@@ -24,16 +24,16 @@ module Datadog
           # NOTE: the ``finish_trace_cache()`` is fired but it already has a safe-guard
           # to avoid any kind of issue.
           current_span = tracer.active_span
-          return if payload[:action] == 'GET'.freeze &&
-                    current_span.try(:name) == 'rails.cache'.freeze &&
-                    current_span.try(:resource) == 'GET'.freeze
+          return if payload[:action] == Ext::RESOURCE_CACHE_GET &&
+                    current_span.try(:name) == Ext::SPAN_CACHE &&
+                    current_span.try(:resource) == Ext::RESOURCE_CACHE_GET
 
           tracing_context = payload.fetch(:tracing_context)
 
           # create a new ``Span`` and add it to the tracing context
           service = Datadog.configuration[:rails][:cache_service]
-          type = Datadog::Ext::CACHE::TYPE
-          span = tracer.trace('rails.cache'.freeze, service: service, span_type: type)
+          type = Ext::SPAN_TYPE_CACHE
+          span = tracer.trace(Ext::SPAN_CACHE, service: service, span_type: type)
           span.resource = payload.fetch(:action)
           tracing_context[:dd_cache_span] = span
         rescue StandardError => e
@@ -49,9 +49,9 @@ module Datadog
           begin
             # discard parameters from the cache_store configuration
             store, = *Array.wrap(::Rails.configuration.cache_store).flatten
-            span.set_tag('rails.cache.backend'.freeze, store)
-            cache_key = Datadog::Utils.truncate(payload.fetch(:key), Ext::CACHE::MAX_KEY_SIZE)
-            span.set_tag('rails.cache.key'.freeze, cache_key)
+            span.set_tag(Ext::TAG_CACHE_BACKEND, store)
+            cache_key = Datadog::Utils.truncate(payload.fetch(:key), Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+            span.set_tag(Ext::TAG_CACHE_KEY, cache_key)
             span.set_error(payload[:exception]) if payload[:exception]
           ensure
             span.finish

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

@@ -0,0 +1,26 @@
+require 'ddtrace/contrib/configuration/settings'
+
+module Datadog
+  module Contrib
+    module Rails
+      module Configuration
+        # Custom settings for the Rails integration
+        class Settings < Contrib::Configuration::Settings
+          option :cache_service
+          option :controller_service
+          option :database_service, depends_on: [:service_name] do |value|
+            value.tap do
+              # Update ActiveRecord service name too
+              Datadog.configuration[:active_record][:service_name] = value
+            end
+          end
+          option :distributed_tracing, default: false
+          option :exception_controller, default: nil
+          option :middleware, default: true
+          option :middleware_names, default: false
+          option :template_base_path, default: 'views/'
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require 'ddtrace/contrib/rails/ext'
+
 module Datadog
   # RailsRendererPatcher contains function to patch Rails rendering libraries.
   # rubocop:disable Lint/RescueException
@@ -6,11 +8,6 @@ module Datadog
   module RailsRendererPatcher
     include Datadog::Patcher
 
-    SPAN_NAME_RENDER_PARTIAL = 'rails.render_partial'.freeze
-    SPAN_NAME_RENDER_TEMPLATE = 'rails.render_template'.freeze
-    TAG_LAYOUT = 'rails.layout'.freeze
-    TAG_TEMPLATE_NAME = 'rails.template_name'.freeze
-
     module_function
 
     def patch_renderer
@@ -39,7 +36,7 @@ module Datadog
               render_without_datadog(*args, &block)
             else
               datadog_tracer.trace(
-                Datadog::RailsRendererPatcher::SPAN_NAME_RENDER_TEMPLATE,
+                Datadog::Contrib::Rails::Ext::SPAN_RENDER_TEMPLATE,
                 span_type: Datadog::Ext::HTTP::TEMPLATE
               ) do |span|
                 with_datadog_span(span) { render_without_datadog(*args, &block) }
@@ -64,14 +61,14 @@ module Datadog
                        end
               if template_name
                 active_datadog_span.set_tag(
-                  Datadog::RailsRendererPatcher::TAG_TEMPLATE_NAME,
+                  Datadog::Contrib::Rails::Ext::TAG_TEMPLATE_NAME,
                   template_name
                 )
               end
 
               if layout
                 active_datadog_span.set_tag(
-                  Datadog::RailsRendererPatcher::TAG_LAYOUT,
+                  Datadog::Contrib::Rails::Ext::TAG_LAYOUT,
                   layout
                 )
               end
@@ -119,7 +116,7 @@ module Datadog
         klass.class_eval do
           def render_with_datadog(*args, &block)
             datadog_tracer.trace(
-              Datadog::RailsRendererPatcher::SPAN_NAME_RENDER_PARTIAL,
+              Datadog::Contrib::Rails::Ext::SPAN_RENDER_PARTIAL,
               span_type: Datadog::Ext::HTTP::TEMPLATE
             ) do |span|
               with_datadog_span(span) { render_without_datadog(*args) }
@@ -131,7 +128,7 @@ module Datadog
               template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(@template.try('identifier'))
               if template_name
                 active_datadog_span.set_tag(
-                  Datadog::RailsRendererPatcher::TAG_TEMPLATE_NAME,
+                  Datadog::Contrib::Rails::Ext::TAG_TEMPLATE_NAME,
                   template_name
                 )
               end
@@ -228,7 +225,7 @@ module Datadog
 
           def read(*args, &block)
             payload = {
-              action: 'GET',
+              action: Datadog::Contrib::Rails::Ext::RESOURCE_CACHE_GET,
               key: args[0],
               tracing_context: {}
             }
@@ -256,7 +253,7 @@ module Datadog
 
           def fetch(*args, &block)
             payload = {
-              action: 'GET',
+              action: Datadog::Contrib::Rails::Ext::RESOURCE_CACHE_GET,
               key: args[0],
               tracing_context: {}
             }
@@ -284,7 +281,7 @@ module Datadog
 
           def write(*args, &block)
             payload = {
-              action: 'SET',
+              action: Datadog::Contrib::Rails::Ext::RESOURCE_CACHE_SET,
               key: args[0],
               tracing_context: {}
             }
@@ -312,7 +309,7 @@ module Datadog
 
           def delete(*args, &block)
             payload = {
-              action: 'DELETE',
+              action: Datadog::Contrib::Rails::Ext::RESOURCE_CACHE_DELETE,
               key: args[0],
               tracing_context: {}
             }
@@ -335,7 +332,7 @@ module Datadog
 
     def self.reload_cache_store
       redis = Datadog.registry[:redis]
-      return unless redis && redis.patched?
+      return unless redis && redis.patcher.patched?
 
       return unless defined?(::ActiveSupport::Cache::RedisStore) &&
                     defined?(::Rails.cache) &&

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

@@ -0,0 +1,30 @@
+module Datadog
+  module Contrib
+    module Rails
+      # Rails integration constants
+      module Ext
+        APP = 'rails'.freeze
+
+        QUANTIZE_CACHE_MAX_KEY_SIZE = 300
+
+        RESOURCE_CACHE_DELETE = 'DELETE'.freeze
+        RESOURCE_CACHE_GET = 'GET'.freeze
+        RESOURCE_CACHE_SET = 'SET'.freeze
+
+        SPAN_ACTION_CONTROLLER = 'rails.action_controller'.freeze
+        SPAN_CACHE = 'rails.cache'.freeze
+        SPAN_RENDER_PARTIAL = 'rails.render_partial'.freeze
+        SPAN_RENDER_TEMPLATE = 'rails.render_template'.freeze
+
+        SPAN_TYPE_CACHE = 'cache'.freeze
+
+        TAG_CACHE_BACKEND = 'rails.cache.backend'.freeze
+        TAG_CACHE_KEY = 'rails.cache.key'.freeze
+        TAG_LAYOUT = 'rails.layout'.freeze
+        TAG_ROUTE_ACTION = 'rails.route.action'.freeze
+        TAG_ROUTE_CONTROLLER = 'rails.route.controller'.freeze
+        TAG_TEMPLATE_NAME = 'rails.template_name'.freeze
+      end
+    end
+  end
+end

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

@@ -5,6 +5,7 @@ require 'ddtrace/contrib/active_record/patcher'
 require 'ddtrace/contrib/grape/endpoint'
 require 'ddtrace/contrib/rack/middlewares'
 
+require 'ddtrace/contrib/rails/ext'
 require 'ddtrace/contrib/rails/core_extensions'
 require 'ddtrace/contrib/rails/action_controller'
 require 'ddtrace/contrib/rails/action_view'
@@ -66,8 +67,8 @@ module Datadog
 
         def self.set_service_info!(config)
           tracer = config[:tracer]
-          tracer.set_service_info(config[:controller_service], 'rails', Ext::AppTypes::WEB)
-          tracer.set_service_info(config[:cache_service], 'rails', Ext::AppTypes::CACHE)
+          tracer.set_service_info(config[:controller_service], Ext::APP, Datadog::Ext::AppTypes::WEB)
+          tracer.set_service_info(config[:cache_service], Ext::APP, Datadog::Ext::AppTypes::CACHE)
         end
       end
     end

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

@@ -0,0 +1,37 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/rails/configuration/settings'
+require 'ddtrace/contrib/rails/patcher'
+
+module Datadog
+  module Contrib
+    module Rails
+      # Description of Rails integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :rails, auto_patch: false
+
+        def self.version
+          Gem.loaded_specs['rails'] && Gem.loaded_specs['rails'].version
+        end
+
+        def self.present?
+          defined?(::Rails)
+        end
+
+        def self.compatible?
+          return false if ENV['DISABLE_DATADOG_RAILS']
+          super && defined?(::Rails::VERSION) && ::Rails::VERSION::MAJOR.to_i >= 3
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -6,82 +6,75 @@ require 'ddtrace/contrib/rack/middlewares'
 module Datadog
   module Contrib
     module Rails
-      # Patcher
+      # Patcher enables patching of 'rails' module.
       module Patcher
-        include Base
-        register_as :rails, auto_patch: true
+        include Contrib::Patcher
 
-        option :service_name
-        option :controller_service
-        option :cache_service
-        option :database_service, depends_on: [:service_name] do |value|
-          value.tap do
-            # Update ActiveRecord service name too
-            Datadog.configuration[:active_record][:service_name] = value
-          end
-        end
-        option :middleware, default: true
-        option :middleware_names, default: false
-        option :distributed_tracing, default: false
-        option :template_base_path, default: 'views/'
-        option :exception_controller, default: nil
-        option :tracer, default: Datadog.tracer
+        module_function
 
-        @patched = false
+        def patched?
+          done?(:rails)
+        end
 
-        class << self
-          def patch
-            return @patched if patched? || !compatible?
+        def patch
+          do_once(:rails) do
+            patch_before_intialize
+            patch_after_intialize
+          end
+        rescue => e
+          Datadog::Tracer.log.error("Unable to apply Rails integration: #{e}")
+        end
 
-            # Add a callback hook to add the trace middleware before the application initializes.
-            # Otherwise the middleware stack will be frozen.
-            do_once(:rails_before_initialize_hook) do
-              ::ActiveSupport.on_load(:before_initialize) do
-                # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
-                if Datadog.configuration[:rails][:middleware]
-                  # Add trace middleware
-                  config.middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware)
+        def patch_before_intialize
+          ::ActiveSupport.on_load(:before_initialize) do
+            Datadog::Contrib::Rails::Patcher.before_intialize(self)
+          end
+        end
 
-                  # Insert right after Rails exception handling middleware, because if it's before,
-                  # it catches and swallows the error. If it's too far after, custom middleware can find itself
-                  # between, and raise exceptions that don't end up getting tagged on the request properly.
-                  # e.g lost stack trace.
-                  config.middleware.insert_after(
-                    ActionDispatch::ShowExceptions,
-                    Datadog::Contrib::Rails::ExceptionMiddleware
-                  )
-                end
-              end
-            end
+        def before_intialize(app)
+          # Middleware must be added before the application is initialized.
+          # Otherwise the middleware stack will be frozen.
+          # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
+          add_middleware(app) if Datadog.configuration[:rails][:middleware]
+        end
 
-            # Add a callback hook to finish configuring the tracer after the application is initialized.
-            # We need to wait for some things, like application name, middleware stack, etc.
-            do_once(:rails_after_initialize_hook) do
-              ::ActiveSupport.on_load(:after_initialize) do
-                Datadog::Contrib::Rails::Framework.setup
+        def add_middleware(app)
+          # Add trace middleware
+          app.middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware)
 
-                # Add instrumentation to Rails components
-                Datadog::Contrib::Rails::ActionController.instrument
-                Datadog::Contrib::Rails::ActionView.instrument
-                Datadog::Contrib::Rails::ActiveSupport.instrument
-              end
-            end
+          # Insert right after Rails exception handling middleware, because if it's before,
+          # it catches and swallows the error. If it's too far after, custom middleware can find itself
+          # between, and raise exceptions that don't end up getting tagged on the request properly.
+          # e.g lost stack trace.
+          app.middleware.insert_after(
+            ActionDispatch::ShowExceptions,
+            Datadog::Contrib::Rails::ExceptionMiddleware
+          )
+        end
 
-            @patched = true
-          rescue => e
-            Datadog::Tracer.log.error("Unable to apply Rails integration: #{e}")
-            @patched
+        def patch_after_intialize
+          ::ActiveSupport.on_load(:after_initialize) do
+            Datadog::Contrib::Rails::Patcher.after_intialize(self)
           end
+        end
 
-          def patched?
-            @patched
-          end
+        def after_intialize(app)
+          # Finish configuring the tracer after the application is initialized.
+          # We need to wait for some things, like application name, middleware stack, etc.
+          setup_tracer
+          instrument_rails
+        end
 
-          def compatible?
-            return if ENV['DISABLE_DATADOG_RAILS']
+        # Configure Rails tracing with settings
+        def setup_tracer
+          Datadog::Contrib::Rails::Framework.setup
+        end
 
-            defined?(::Rails::VERSION) && ::Rails::VERSION::MAJOR.to_i >= 3
-          end
+        # Add instrumentation to Rails components
+        def instrument_rails
+          Datadog::Contrib::Rails::ActionController.instrument
+          Datadog::Contrib::Rails::ActionView.instrument
+          Datadog::Contrib::Rails::ActiveSupport.instrument
         end
       end
     end