ddtrace 0.54.0 → 1.1.0

data/lib/datadog/tracing/contrib/rack/middlewares.rb

@@ -0,0 +1,255 @@
+# typed: false
+
+require 'date'
+
+require 'datadog/core/environment/variable_helpers'
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/propagation/http'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/rack/ext'
+require 'datadog/tracing/contrib/rack/request_queue'
+require 'datadog/tracing/contrib/utils/quantization/http'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Rack module includes middlewares that are required to trace any framework
+      # and application built on top of Rack.
+      module Rack
+        # 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
+          def initialize(app)
+            @app = app
+          end
+
+          def compute_queue_time(env)
+            return unless configuration[:request_queuing]
+
+            # parse the request queue time
+            request_start = Contrib::Rack::QueueTime.get_request_start(env)
+            return if request_start.nil?
+
+            frontend_span = Tracing.trace(
+              Ext::SPAN_HTTP_SERVER_QUEUE,
+              span_type: Tracing::Metadata::Ext::HTTP::TYPE_PROXY,
+              start_time: request_start,
+              service: configuration[:web_service_name]
+            )
+
+            # Tag this span as belonging to Rack
+            frontend_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+            frontend_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HTTP_SERVER_QUEUE)
+
+            # Set peer service (so its not believed to belong to this app)
+            frontend_span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, configuration[:web_service_name])
+
+            frontend_span
+          end
+
+          def call(env)
+            # Find out if this is rack within rack
+            previous_request_span = env[Ext::RACK_ENV_REQUEST_SPAN]
+
+            # Extract distributed tracing context before creating any spans,
+            # so that all spans will be added to the distributed trace.
+            if configuration[:distributed_tracing] && previous_request_span.nil?
+              trace_digest = Tracing::Propagation::HTTP.extract(env)
+              Tracing.continue_trace!(trace_digest)
+            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) if previous_request_span.nil?
+
+            trace_options = { span_type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND }
+            trace_options[:service] = configuration[:service_name] if configuration[:service_name]
+
+            # 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 = Tracing.trace(Ext::SPAN_REQUEST, **trace_options)
+            request_span.resource = nil
+            request_trace = Tracing.active_trace
+            env[Ext::RACK_ENV_REQUEST_SPAN] = request_span
+
+            # Copy the original env, before the rest of the stack executes.
+            # Values may change; we want values before that happens.
+            original_env = env.dup
+
+            # call the rest of the stack
+            status, headers, response = @app.call(env)
+            [status, headers, response]
+
+          # rubocop:disable Lint/RescueException
+          # Here we really want to catch *any* exception, not only StandardError,
+          # as we really have no clue of what is in the block,
+          # and it is user code which should be executed no matter what.
+          # It's not a problem since we re-raise it afterwards so for example a
+          # SignalException::Interrupt would still bubble up.
+          rescue Exception => e
+            # catch exceptions that may be raised in the middleware chain
+            # Note: if a middleware catches an Exception without re raising,
+            # the Exception cannot be recorded here.
+            request_span.set_error(e) unless request_span.nil?
+            raise e
+          ensure
+            env[Ext::RACK_ENV_REQUEST_SPAN] = previous_request_span if previous_request_span
+
+            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_trace, 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?
+          end
+          # rubocop:enable Lint/RescueException
+
+          def resource_name_for(env, status)
+            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
+          # rubocop:disable Metrics/MethodLength
+          def set_request_tags!(trace, 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
+            # URL for the current request; but some frameworks may override that
+            # value, especially during exception handling.
+            #
+            # Because of this, we prefer to use REQUEST_URI, if available, which is the
+            # relative path + query string, and doesn't mutate.
+            #
+            # REQUEST_URI is only available depending on what web server is running though.
+            # So when its not available, we want the original, unmutated PATH_INFO, which
+            # is just the relative path without query strings.
+            url = env['REQUEST_URI'] || original_env['PATH_INFO']
+            request_headers = parse_request_headers(env)
+            response_headers = parse_response_headers(headers || {})
+
+            request_span.resource ||= resource_name_for(env, status)
+
+            # Set trace name if it hasn't been set yet (name == resource)
+            trace.resource = request_span.resource if trace.resource == trace.name
+
+            request_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+            request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
+
+            # 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(Tracing::Metadata::Ext::HTTP::TAG_METHOD).nil?
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, env['REQUEST_METHOD'])
+            end
+
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_URL).nil?
+              options = configuration[:quantize]
+              request_span.set_tag(
+                Tracing::Metadata::Ext::HTTP::TAG_URL,
+                Contrib::Utils::Quantization::HTTP.url(url, options)
+              )
+            end
+
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_BASE_URL).nil?
+              request_obj = ::Rack::Request.new(env)
+
+              base_url = if request_obj.respond_to?(:base_url)
+                           request_obj.base_url
+                         else
+                           # Compatibility for older Rack versions
+                           request_obj.url.chomp(request_obj.fullpath)
+                         end
+
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_BASE_URL, base_url)
+            end
+
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE).nil? && status
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, status)
+            end
+
+            # Request headers
+            request_headers.each do |name, value|
+              request_span.set_tag(name, value) if request_span.get_tag(name).nil?
+            end
+
+            # Response headers
+            response_headers.each do |name, value|
+              request_span.set_tag(name, value) if request_span.get_tag(name).nil?
+            end
+
+            # 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
+            request_span.status = 1 if status.to_s.start_with?('5') && request_span.status.zero?
+          end
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/CyclomaticComplexity
+          # rubocop:enable Metrics/PerceivedComplexity
+          # rubocop:enable Metrics/MethodLength
+
+          private
+
+          def configuration
+            Datadog.configuration.tracing[:rack]
+          end
+
+          def parse_request_headers(env)
+            {}.tap do |result|
+              whitelist = configuration[:headers][:request] || []
+              whitelist.each do |header|
+                rack_header = header_to_rack_header(header)
+                if env.key?(rack_header)
+                  result[Tracing::Metadata::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header]
+                end
+              end
+            end
+          end
+
+          def parse_response_headers(headers)
+            {}.tap do |result|
+              whitelist = configuration[:headers][:response] || []
+              whitelist.each do |header|
+                if headers.key?(header)
+                  result[Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[header]
+                else
+                  # 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[Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header]
+                  end
+                end
+              end
+            end
+          end
+
+          def header_to_rack_header(name)
+            "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rack/patcher.rb

@@ -0,0 +1,109 @@
+# typed: false
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rack
+        # Provides instrumentation for `rack`
+        module MiddlewarePatcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            # Patch middleware
+            require_relative 'middlewares'
+          end
+        end
+
+        # Provides instrumentation for Rack middleware names
+        module MiddlewareNamePatcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            patch_middleware_names
+          end
+
+          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)
+            Datadog.logger.debug("Error patching middleware stack: #{e}")
+          end
+
+          def retain_middleware_name(middleware)
+            return unless middleware && middleware.respond_to?(:call)
+
+            middleware.singleton_class.class_eval do
+              alias_method :__call, :call
+
+              def call(env)
+                env['RESPONSE_MIDDLEWARE'] = self.class.to_s
+                __call(env)
+              end
+            end
+
+            following = (middleware.instance_variable_get('@app') if middleware.instance_variable_defined?('@app'))
+
+            retain_middleware_name(following)
+          end
+
+          def get_option(option)
+            Datadog.configuration.tracing[: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.tracing[:rack].get_option(option)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rack/request_queue.rb

@@ -0,0 +1,48 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rack
+        # 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
+
+          def get_request_start(env, now = Time.now.utc)
+            header = env[REQUEST_START] || env[QUEUE_START]
+            return unless header
+
+            # 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_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.logger.debug("[rack] unable to parse request queue headers: #{e}")
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rails/auto_instrument_railtie.rb

@@ -0,0 +1,12 @@
+# typed: ignore
+
+require 'datadog/tracing/contrib/auto_instrument'
+
+# Railtie to include AutoInstrumentation in rails loading
+class DatadogAutoInstrumentRailtie < Rails::Railtie
+  # we want to load before config initializers so that any user supplied config
+  # in config/initializers/datadog.rb will take precedence
+  initializer 'datadog.start_tracer', before: :load_config_initializers do
+    Datadog::Tracing::Contrib::AutoInstrument.patch_all!
+  end
+end

data/lib/datadog/tracing/contrib/rails/configuration/settings.rb

@@ -0,0 +1,71 @@
+# typed: false
+
+require 'datadog/tracing/contrib/configuration/settings'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rails
+        module Configuration
+          # Custom settings for the Rails integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            def initialize(options = {})
+              super(options)
+
+              # NOTE: Eager load these
+              #       Rails integration is responsible for orchestrating other integrations.
+              #       When using environment variables, settings will not be automatically
+              #       filled because nothing explicitly calls them. They must though, so
+              #       integrations like ActionPack can receive the value as it should.
+              #       Trigger these manually to force an eager load and propagate them.
+              analytics_enabled
+              analytics_sample_rate
+            end
+
+            option :enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+              o.lazy
+            end
+
+            option :analytics_enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
+              o.lazy
+              o.on_set do |value|
+                # Update ActionPack analytics too
+                Datadog.configuration.tracing[:action_pack][:analytics_enabled] = value
+              end
+            end
+
+            option :analytics_sample_rate do |o|
+              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+              o.lazy
+              o.on_set do |value|
+                # Update ActionPack analytics too
+                Datadog.configuration.tracing[:action_pack][:analytics_sample_rate] = value
+              end
+            end
+
+            option :distributed_tracing, default: true
+            option :exception_controller do |o|
+              o.on_set do |value|
+                # Update ActionPack exception controller too
+                Datadog.configuration.tracing[:action_pack][:exception_controller] = value
+              end
+            end
+
+            option :middleware, default: true
+            option :middleware_names, default: false
+            option :template_base_path do |o|
+              o.default 'views/'
+              o.on_set do |value|
+                # Update ActionView template base path too
+                Datadog.configuration.tracing[:action_view][:template_base_path] = value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rails/ext.rb

@@ -0,0 +1,19 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rails
+        # Rails integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          APP = 'rails'.freeze
+          ENV_ENABLED = 'DD_TRACE_RAILS_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAILS_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAILS_ANALYTICS_SAMPLE_RATE'.freeze
+          ENV_DISABLE = 'DISABLE_DATADOG_RAILS'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rails/framework.rb

@@ -0,0 +1,152 @@
+# typed: false
+
+require 'datadog/tracing'
+require 'datadog/tracing/contrib/action_cable/integration'
+require 'datadog/tracing/contrib/action_mailer/integration'
+require 'datadog/tracing/contrib/action_pack/integration'
+require 'datadog/tracing/contrib/action_view/integration'
+require 'datadog/tracing/contrib/active_record/integration'
+require 'datadog/tracing/contrib/active_support/integration'
+require 'datadog/tracing/contrib/grape/endpoint'
+require 'datadog/tracing/contrib/lograge/integration'
+require 'datadog/tracing/contrib/rails/ext'
+require 'datadog/tracing/contrib/rails/utils'
+require 'datadog/tracing/contrib/semantic_logger/integration'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Instrument Rails.
+      module Rails
+        # Rails framework code, used to essentially:
+        # - handle configuration entries which are specific to Datadog tracing
+        # - instrument parts of the framework when needed
+        module Framework
+          # After the Rails application finishes initializing, we configure the Rails
+          # integration and all its sub-components with the application information
+          # available.
+          # We do this after the initialization because not all the information we
+          # require is available before then.
+          def self.setup
+            # NOTE: #configure has the side effect of rebuilding trace components.
+            #       During a typical Rails application lifecycle, we will see trace
+            #       components initialized twice because of this. This is necessary
+            #       because key configuration is not available until after the Rails
+            #       application has fully loaded, and some of this configuration is
+            #       used to reconfigure tracer components with Rails-sourced defaults.
+            #       This is a trade-off we take to get nice defaults.
+            Datadog.configure do |datadog_config|
+              # By default, default service would be guessed from the script
+              # being executed, but here we know better, get it from Rails config.
+              # Don't set this if service has been explicitly provided by the user.
+              rails_service_name = Datadog.configuration.tracing[:rails][:service_name] \
+                                    || Datadog.configuration.service_without_fallback \
+                                    || Utils.app_name
+
+              datadog_config.service ||= rails_service_name
+            end
+
+            Datadog.configure do |datadog_config|
+              rails_config = datadog_config.tracing[:rails]
+
+              activate_rack!(datadog_config, rails_config)
+              activate_action_cable!(datadog_config, rails_config)
+              activate_action_mailer!(datadog_config, rails_config)
+              activate_active_support!(datadog_config, rails_config)
+              activate_action_pack!(datadog_config, rails_config)
+              activate_action_view!(datadog_config, rails_config)
+              activate_active_job!(datadog_config, rails_config)
+              activate_active_record!(datadog_config, rails_config)
+              activate_lograge!(datadog_config, rails_config)
+              activate_semantic_logger!(datadog_config, rails_config)
+            end
+          end
+
+          def self.activate_rack!(datadog_config, rails_config)
+            datadog_config.tracing.instrument(
+              :rack,
+              application: ::Rails.application,
+              service_name: rails_config[:service_name],
+              middleware_names: rails_config[:middleware_names],
+              distributed_tracing: rails_config[:distributed_tracing]
+            )
+          end
+
+          def self.activate_active_support!(datadog_config, rails_config)
+            return unless defined?(::ActiveSupport)
+
+            datadog_config.tracing.instrument(:active_support)
+          end
+
+          def self.activate_action_cable!(datadog_config, rails_config)
+            return unless defined?(::ActionCable)
+
+            datadog_config.tracing.instrument(:action_cable)
+          end
+
+          def self.activate_action_mailer!(datadog_config, rails_config)
+            return unless defined?(::ActionMailer)
+
+            datadog_config.tracing.instrument(
+              :action_mailer,
+              service_name: rails_config[:service_name]
+            )
+          end
+
+          def self.activate_action_pack!(datadog_config, rails_config)
+            return unless defined?(::ActionPack)
+
+            datadog_config.tracing.instrument(
+              :action_pack,
+              service_name: rails_config[:service_name]
+            )
+          end
+
+          def self.activate_action_view!(datadog_config, rails_config)
+            return unless defined?(::ActionView)
+
+            datadog_config.tracing.instrument(
+              :action_view,
+              service_name: rails_config[:service_name]
+            )
+          end
+
+          def self.activate_active_job!(datadog_config, rails_config)
+            return unless defined?(::ActiveJob)
+
+            datadog_config.tracing.instrument(
+              :active_job,
+              service_name: rails_config[:service_name]
+            )
+          end
+
+          def self.activate_active_record!(datadog_config, rails_config)
+            return unless defined?(::ActiveRecord)
+
+            datadog_config.tracing.instrument(:active_record)
+          end
+
+          def self.activate_lograge!(datadog_config, rails_config)
+            return unless defined?(::Lograge)
+
+            if datadog_config.tracing.log_injection
+              datadog_config.tracing.instrument(
+                :lograge
+              )
+            end
+          end
+
+          def self.activate_semantic_logger!(datadog_config, rails_config)
+            return unless defined?(::SemanticLogger)
+
+            if datadog_config.tracing.log_injection
+              datadog_config.tracing.instrument(
+                :semantic_logger
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end