ddtrace 0.13.0 → 0.47.0

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

@@ -1,7 +1,11 @@
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/http'
 require 'ddtrace/propagation/http_propagator'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/rack/ext'
 require 'ddtrace/contrib/rack/request_queue'
+require 'ddtrace/environment'
+require 'date'
 
 module Datadog
   module Contrib
@@ -13,7 +17,10 @@ module Datadog
       # 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.
+      # 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)
@@ -21,49 +28,57 @@ module Datadog
         end
 
         def compute_queue_time(env, tracer)
-          return unless Datadog.configuration[:rack][:request_queuing]
+          return unless configuration[:request_queuing]
 
           # parse the request queue time
           request_start = Datadog::Contrib::Rack::QueueTime.get_request_start(env)
           return if request_start.nil?
 
           tracer.trace(
-            'http_server.queue',
+            Ext::SPAN_HTTP_SERVER_QUEUE,
+            span_type: Datadog::Ext::HTTP::TYPE_PROXY,
             start_time: request_start,
-            service: Datadog.configuration[:rack][:web_service_name]
+            service: configuration[:web_service_name]
           )
         end
 
         def call(env)
           # retrieve integration settings
-          tracer = Datadog.configuration[:rack][:tracer]
+          tracer = configuration[:tracer]
 
-          # [experimental] create a root Span to keep track of frontend web servers
+          # Extract distributed tracing context before creating any spans,
+          # so that all spans will be added to the distributed trace.
+          if configuration[:distributed_tracing]
+            context = HTTPPropagator.extract(env)
+            tracer.provider.context = context if context.trace_id
+          end
+
+          # Create a root Span to keep track of frontend web servers
           # (i.e. Apache, nginx) if the header is properly set
           frontend_span = compute_queue_time(env, tracer)
 
           trace_options = {
-            service: Datadog.configuration[:rack][:service_name],
+            service: configuration[:service_name],
             resource: nil,
-            span_type: Datadog::Ext::HTTP::TYPE
+            span_type: Datadog::Ext::HTTP::TYPE_INBOUND
           }
 
-          if Datadog.configuration[:rack][:distributed_tracing]
-            context = HTTPPropagator.extract(env)
-            tracer.provider.context = context if context.trace_id
-          end
-
           # 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
 
-          # TODO: For backwards compatibility; this attribute is deprecated.
+          # TODO: Add deprecation warnings back in
+          # DEV: Some third party Gems will loop over the rack env causing our deprecation
+          #      warnings to be shown even when the user is not accessing them directly
+          #
+          # add_deprecation_warnings(env)
+          # env.without_datadog_warnings do
+          #   # TODO: For backwards compatibility; this attribute is deprecated.
+          #   env[:datadog_rack_request_span] = env[RACK_REQUEST_SPAN]
+          # end
           env[:datadog_rack_request_span] = env[RACK_REQUEST_SPAN]
 
-          # Add deprecation warnings
-          add_deprecation_warnings(env)
-
           # Copy the original env, before the rest of the stack executes.
           # Values may change; we want values before that happens.
           original_env = env.dup
@@ -85,33 +100,39 @@ module Datadog
           request_span.set_error(e) unless request_span.nil?
           raise e
         ensure
-          # Rack is a really low level interface and it doesn't provide any
-          # advanced functionality like routers. Because of that, we assume that
-          # the underlying framework or application has more knowledge about
-          # the result for this request; `resource` and `tags` are expected to
-          # be set in another level but if they're missing, reasonable defaults
-          # are used.
-          set_request_tags!(request_span, env, status, headers, response, original_env)
-
-          # ensure the request_span is finished and the context reset;
-          # this assumes that the Rack middleware creates a root span
-          request_span.finish
+          if request_span
+            # Rack is a really low level interface and it doesn't provide any
+            # advanced functionality like routers. Because of that, we assume that
+            # the underlying framework or application has more knowledge about
+            # the result for this request; `resource` and `tags` are expected to
+            # be set in another level but if they're missing, reasonable defaults
+            # are used.
+            set_request_tags!(request_span, env, status, headers, response, original_env || env)
+
+            # ensure the request_span is finished and the context reset;
+            # this assumes that the Rack middleware creates a root span
+            request_span.finish
+          end
+
           frontend_span.finish unless frontend_span.nil?
 
           # TODO: Remove this once we change how context propagation works. This
           # ensures we clean thread-local variables on each HTTP request avoiding
           # memory leaks.
-          tracer.provider.context = Datadog::Context.new
+          tracer.provider.context = Datadog::Context.new if tracer
         end
 
         def resource_name_for(env, status)
-          if Datadog.configuration[:rack][:middleware_names] && env['RESPONSE_MIDDLEWARE']
+          if configuration[:middleware_names] && env['RESPONSE_MIDDLEWARE']
             "#{env['RESPONSE_MIDDLEWARE']}##{env['REQUEST_METHOD']}"
           else
             "#{env['REQUEST_METHOD']} #{status}".strip
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
         def set_request_tags!(request_span, env, status, headers, response, original_env)
           # http://www.rubydoc.info/github/rack/rack/file/SPEC
           # The source of truth in Rack is the PATH_INFO key that holds the
@@ -129,13 +150,27 @@ module Datadog
           response_headers = parse_response_headers(headers || {})
 
           request_span.resource ||= resource_name_for(env, status)
+
+          # Associate with runtime metrics
+          Datadog.runtime_metrics.associate_with_span(request_span)
+
+          # Set analytics sample rate
+          if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+            Contrib::Analytics.set_sample_rate(request_span, configuration[:analytics_sample_rate])
+          end
+
+          # Measure service stats
+          Contrib::Analytics.set_measured(request_span)
+
           if request_span.get_tag(Datadog::Ext::HTTP::METHOD).nil?
             request_span.set_tag(Datadog::Ext::HTTP::METHOD, env['REQUEST_METHOD'])
           end
+
           if request_span.get_tag(Datadog::Ext::HTTP::URL).nil?
-            options = Datadog.configuration[:rack][:quantize]
+            options = configuration[:quantize]
             request_span.set_tag(Datadog::Ext::HTTP::URL, Datadog::Quantization::HTTP.url(url, options))
           end
+
           if request_span.get_tag(Datadog::Ext::HTTP::BASE_URL).nil?
             request_obj = ::Rack::Request.new(env)
 
@@ -148,6 +183,7 @@ module Datadog
 
             request_span.set_tag(Datadog::Ext::HTTP::BASE_URL, base_url)
           end
+
           if request_span.get_tag(Datadog::Ext::HTTP::STATUS_CODE).nil? && status
             request_span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, status)
           end
@@ -164,9 +200,7 @@ module Datadog
 
           # detect if the status code is a 5xx and flag the request span as an error
           # unless it has been already set by the underlying framework
-          if status.to_s.start_with?('5') && request_span.status.zero?
-            request_span.status = 1
-          end
+          request_span.status = 1 if status.to_s.start_with?('5') && request_span.status.zero?
         end
 
         private
@@ -175,43 +209,62 @@ module Datadog
           :datadog_rack_request_span is considered an internal symbol in the Rack env,
           and has been been DEPRECATED. Public support for its usage is discontinued.
           If you need the Rack request span, try using `Datadog.tracer.active_span`.
-          This key will be removed in version 0.14.0).freeze
+          This key will be removed in version 1.0).freeze
+
+        def configuration
+          Datadog.configuration[:rack]
+        end
 
         def add_deprecation_warnings(env)
           env.instance_eval do
-            def [](key)
-              if key == :datadog_rack_request_span && !@request_span_warning_issued
-                Datadog::Tracer.log.warn(REQUEST_SPAN_DEPRECATION_WARNING)
-                @request_span_warning_issued = true
+            unless instance_variable_defined?(:@patched_with_datadog_warnings)
+              @patched_with_datadog_warnings = true
+              @datadog_deprecation_warnings = true
+              @datadog_span_warning = true
+
+              def [](key)
+                if key == :datadog_rack_request_span \
+                  && @datadog_span_warning \
+                  && @datadog_deprecation_warnings
+                  Datadog.logger.warn(REQUEST_SPAN_DEPRECATION_WARNING)
+                  @datadog_span_warning = true
+                end
+                super
               end
-              super
-            end
 
-            def []=(key, value)
-              if key == :datadog_rack_request_span && !@request_span_warning_issued
-                Datadog::Tracer.log.warn(REQUEST_SPAN_DEPRECATION_WARNING)
-                @request_span_warning_issued = true
+              def []=(key, value)
+                if key == :datadog_rack_request_span \
+                  && @datadog_span_warning \
+                  && @datadog_deprecation_warnings
+                  Datadog.logger.warn(REQUEST_SPAN_DEPRECATION_WARNING)
+                  @datadog_span_warning = true
+                end
+                super
+              end
+
+              def without_datadog_warnings
+                @datadog_deprecation_warnings = false
+                yield
+              ensure
+                @datadog_deprecation_warnings = true
               end
-              super
             end
           end
         end
 
         def parse_request_headers(env)
           {}.tap do |result|
-            whitelist = Datadog.configuration[:rack][:headers][:request] || []
+            whitelist = configuration[:headers][:request] || []
             whitelist.each do |header|
               rack_header = header_to_rack_header(header)
-              if env.key?(rack_header)
-                result[Datadog::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header]
-              end
+              result[Datadog::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header] if env.key?(rack_header)
             end
           end
         end
 
         def parse_response_headers(headers)
           {}.tap do |result|
-            whitelist = Datadog.configuration[:rack][:headers][:response] || []
+            whitelist = configuration[:headers][:response] || []
             whitelist.each do |header|
               if headers.key?(header)
                 result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[header]
@@ -219,9 +272,7 @@ module Datadog
                 # Try a case-insensitive lookup
                 uppercased_header = header.to_s.upcase
                 matching_header = headers.keys.find { |h| h.upcase == uppercased_header }
-                if matching_header
-                  result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header]
-                end
+                result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header] if matching_header
               end
             end
           end

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

@@ -2,70 +2,43 @@ module Datadog
   module Contrib
     module Rack
       # Provides instrumentation for `rack`
-      module Patcher
-        include Base
-
-        DEFAULT_HEADERS = {
-          response: [
-            'Content-Type',
-            'X-Request-ID'
-          ]
-        }.freeze
-
-        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
-        end
-        option :headers, default: DEFAULT_HEADERS
+      module MiddlewarePatcher
+        include Contrib::Patcher
 
         module_function
 
+        def target_version
+          Integration.version
+        end
+
         def patch
-          unless patched?
-            require_relative 'middlewares'
-            @patched = true
-          end
+          # Patch middleware
+          require_relative 'middlewares'
+        end
+      end
 
-          if !@middleware_patched && get_option(:middleware_names)
-            if get_option(:application)
-              enable_middleware_names
-              @middleware_patched = true
-            else
-              Datadog::Tracer.log.warn(%(
-              Rack :middleware_names requires you to also pass :application.
-              Middleware names have NOT been patched; please provide :application.
-              e.g. use: :rack, middleware_names: true, application: my_rack_app).freeze)
-            end
-          end
+      # Provides instrumentation for Rack middleware names
+      module MiddlewareNamePatcher
+        include Contrib::Patcher
+
+        module_function
 
-          @patched || @middleware_patched
+        def target_version
+          Integration.version
         end
 
-        def patched?
-          @patched ||= false
+        def patch
+          patch_middleware_names
         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
           # context of middleware patching outside a Rails server process (eg. a
           # process that doesn't serve HTTP requests but has Rails environment
           # loaded such as a Resque master process)
-          Tracer.log.debug("Error patching middleware stack: #{e}")
+          Datadog.logger.debug("Error patching middleware stack: #{e}")
         end
 
         def retain_middleware_name(middleware)
@@ -80,9 +53,52 @@ module Datadog
             end
           end
 
-          following = middleware.instance_variable_get('@app')
+          following = (middleware.instance_variable_get('@app') if middleware.instance_variable_defined?('@app'))
+
           retain_middleware_name(following)
         end
+
+        def get_option(option)
+          Datadog.configuration[:rack].get_option(option)
+        end
+      end
+
+      # Applies multiple patches
+      module Patcher
+        PATCHERS = [
+          MiddlewarePatcher,
+          MiddlewareNamePatcher
+        ].freeze
+
+        module_function
+
+        def patched?
+          PATCHERS.all?(&:patched?)
+        end
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          MiddlewarePatcher.patch unless MiddlewarePatcher.patched?
+
+          # Patch middleware names
+          if !MiddlewareNamePatcher.patched? && get_option(:middleware_names)
+            if get_option(:application)
+              MiddlewareNamePatcher.patch
+            else
+              Datadog.logger.warn(%(
+              Rack :middleware_names requires you to also pass :application.
+              Middleware names have NOT been patched; please provide :application.
+              e.g. use: :rack, middleware_names: true, application: my_rack_app).freeze)
+            end
+          end
+        end
+
+        def get_option(option)
+          Datadog.configuration[:rack].get_option(option)
+        end
       end
     end
   end

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

@@ -1,10 +1,16 @@
 module Datadog
   module Contrib
     module Rack
-      # QueueTime simply...
+      # Retrieves the time spent in an upstream proxy
+      # for the current Rack request.
+      #
+      # This time captures the request delay introduced but
+      # such proxy before the request made it to the Ruby
+      # process.
       module QueueTime
         REQUEST_START = 'HTTP_X_REQUEST_START'.freeze
         QUEUE_START = 'HTTP_X_QUEUE_START'.freeze
+        MINIMUM_ACCEPTABLE_TIME_VALUE = 1_000_000_000
 
         module_function
 
@@ -12,20 +18,24 @@ module Datadog
           header = env[REQUEST_START] || env[QUEUE_START]
           return unless header
 
-          # nginx header is in the format "t=1512379167.574"
-          # TODO: this should be generic enough to work with any
-          # frontend web server or load balancer
-          time_string = header.split('t=')[1]
+          # nginx header is seconds in the format "t=1512379167.574"
+          # apache header is microseconds in the format "t=1570633834463123"
+          # heroku header is milliseconds in the format "1570634024294"
+          time_string = header.to_s.delete('^0-9')
           return if time_string.nil?
 
+          # Return nil if the time is clearly invalid
+          time_value = "#{time_string[0, 10]}.#{time_string[10, 6]}".to_f
+          return if time_value.zero? || time_value < MINIMUM_ACCEPTABLE_TIME_VALUE
+
           # return the request_start only if it's lesser than
           # current time, to avoid significant clock skew
-          request_start = Time.at(time_string.to_f)
+          request_start = Time.at(time_value)
           request_start.utc > now ? nil : request_start
         rescue StandardError => e
           # in case of an Exception we don't create a
           # `request.queuing` span
-          Datadog::Tracer.log.debug("[rack] unable to parse request queue headers: #{e}")
+          Datadog.logger.debug("[rack] unable to parse request queue headers: #{e}")
           nil
         end
       end