ddtrace 0.50.0 → 1.0.0

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

@@ -1,287 +0,0 @@
-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
-    # 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.
-      # 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)
-          @app = app
-        end
-
-        def compute_queue_time(env, tracer)
-          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(
-            Ext::SPAN_HTTP_SERVER_QUEUE,
-            span_type: Datadog::Ext::HTTP::TYPE_PROXY,
-            start_time: request_start,
-            service: configuration[:web_service_name]
-          )
-        end
-
-        def call(env)
-          # retrieve integration settings
-          tracer = configuration[:tracer]
-
-          # 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: configuration[:service_name],
-            resource: nil,
-            span_type: Datadog::Ext::HTTP::TYPE_INBOUND
-          }
-
-          # 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(Ext::SPAN_REQUEST, trace_options)
-          env[RACK_REQUEST_SPAN] = request_span
-
-          # 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]
-
-          # 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
-          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 if tracer
-        end
-
-        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
-        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
-          # 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)
-
-          # 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 = 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)
-
-            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(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
-
-          # 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
-
-        private
-
-        REQUEST_SPAN_DEPRECATION_WARNING = %(
-          :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 1.0).freeze
-
-        def configuration
-          Datadog.configuration[:rack]
-        end
-
-        def add_deprecation_warnings(env)
-          env.instance_eval do
-            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
-
-              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
-            end
-          end
-        end
-
-        def parse_request_headers(env)
-          {}.tap do |result|
-            whitelist = configuration[:headers][:request] || []
-            whitelist.each do |header|
-              rack_header = header_to_rack_header(header)
-              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 = configuration[:headers][:response] || []
-            whitelist.each do |header|
-              if headers.key?(header)
-                result[Datadog::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 }
-                result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header] if matching_header
-              end
-            end
-          end
-        end
-
-        def header_to_rack_header(name)
-          "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-module Datadog
-  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[: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
-end

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

@@ -1,44 +0,0 @@
-module Datadog
-  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

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

@@ -1,10 +0,0 @@
-require 'ddtrace'
-
-# 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::Contrib::AutoInstrument.patch_all
-  end
-end

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

@@ -1,93 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-
-module Datadog
-  module Contrib
-    module Rails
-      module Configuration
-        # Custom settings for the Rails integration
-        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, Ext::ENV_ANALYTICS_ENABLED_OLD], nil) }
-            o.lazy
-            o.on_set do |value|
-              # Update ActionPack analytics too
-              Datadog.configuration[:action_pack][:analytics_enabled] = value
-            end
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-            o.on_set do |value|
-              # Update ActionPack analytics too
-              Datadog.configuration[:action_pack][:analytics_sample_rate] = value
-            end
-          end
-
-          option :cache_service do |o|
-            o.on_set do |value|
-              # Update ActiveSupport service name too
-              Datadog.configuration[:active_support][:cache_service] = value
-            end
-          end
-
-          option :controller_service do |o|
-            o.on_set do |value|
-              # Update ActionPack service name too
-              Datadog.configuration[:action_pack][:controller_service] = value
-            end
-          end
-
-          option :database_service do |o|
-            o.depends_on :service_name
-            o.on_set do |value|
-              # Update ActiveRecord service name too
-              Datadog.configuration[:active_record][:service_name] = 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[: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[:action_view][:template_base_path] = value
-            end
-          end
-
-          option :log_injection do |o|
-            o.default { env_to_bool(Ext::ENV_LOGS_INJECTION_ENABLED, false) }
-            o.lazy
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-module Datadog
-  module Contrib
-    module Rails
-      # Rails integration constants
-      module Ext
-        APP = 'rails'.freeze
-        ENV_ENABLED = 'DD_TRACE_RAILS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAILS_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_RAILS_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAILS_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_RAILS_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_DISABLE = 'DISABLE_DATADOG_RAILS'.freeze
-        ENV_LOGS_INJECTION_ENABLED = 'DD_LOGS_INJECTION'.freeze
-      end
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-require 'ddtrace/pin'
-require 'ddtrace/ext/app_types'
-
-require 'ddtrace/contrib/active_record/integration'
-require 'ddtrace/contrib/active_support/integration'
-require 'ddtrace/contrib/action_cable/integration'
-require 'ddtrace/contrib/action_pack/integration'
-require 'ddtrace/contrib/action_view/integration'
-require 'ddtrace/contrib/grape/endpoint'
-
-require 'ddtrace/contrib/rails/ext'
-require 'ddtrace/contrib/rails/utils'
-
-module Datadog
-  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|
-            rails_config = config_with_defaults(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.
-            datadog_config.service ||= rails_config[:service_name]
-
-            activate_rack!(datadog_config, rails_config)
-            activate_action_cable!(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_record!(datadog_config, rails_config)
-          end
-        end
-
-        def self.config_with_defaults(datadog_config)
-          # We set defaults here instead of in the patcher because we need to wait
-          # for the Rails application to be fully initialized.
-          datadog_config[:rails].tap do |config|
-            config[:service_name] ||= (Datadog.configuration.service || Utils.app_name)
-            config[:database_service] ||= "#{config[:service_name]}-#{Contrib::ActiveRecord::Utils.adapter_name}"
-            config[:controller_service] ||= config[:service_name]
-            config[:cache_service] ||= "#{config[:service_name]}-cache"
-          end
-        end
-
-        def self.activate_rack!(datadog_config, rails_config)
-          datadog_config.use(
-            :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.use(
-            :active_support,
-            cache_service: rails_config[:cache_service]
-          )
-        end
-
-        def self.activate_action_cable!(datadog_config, rails_config)
-          return unless defined?(::ActionCable)
-
-          datadog_config.use(
-            :action_cable,
-            service_name: "#{rails_config[:service_name]}-#{Contrib::ActionCable::Ext::SERVICE_NAME}"
-          )
-        end
-
-        def self.activate_action_pack!(datadog_config, rails_config)
-          return unless defined?(::ActionPack)
-
-          # TODO: This is configuring ActionPack but not patching. It will queue ActionPack
-          #       for patching, but patching won't take place until Datadog.configure completes.
-          #       Should we manually patch here?
-
-          datadog_config.use(
-            :action_pack,
-            service_name: rails_config[:service_name]
-          )
-        end
-
-        def self.activate_action_view!(datadog_config, rails_config)
-          return unless defined?(::ActionView)
-
-          datadog_config.use(
-            :action_view,
-            service_name: rails_config[:service_name]
-          )
-        end
-
-        def self.activate_active_record!(datadog_config, rails_config)
-          return unless defined?(::ActiveRecord)
-
-          datadog_config.use(
-            :active_record,
-            service_name: rails_config[:database_service]
-          )
-        end
-      end
-    end
-  end
-end