ddtrace 0.52.0 → 1.8.0

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

@@ -0,0 +1,119 @@
+# 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
+
+          def patch_successful
+            MiddlewarePatcher.patch_successful || MiddlewareNamePatcher.patch_successful
+          end
+
+          def patch_error_result
+            MiddlewarePatcher.patch_error_result || MiddlewareNamePatcher.patch_error_result
+          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_relative '../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,74 @@
+# typed: false
+
+require_relative '../../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 :request_queuing, default: false
+
+            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,148 @@
+# typed: false
+
+require_relative '../action_cable/integration'
+require_relative '../action_mailer/integration'
+require_relative '../action_pack/integration'
+require_relative '../action_view/integration'
+require_relative '../active_record/integration'
+require_relative '../active_support/integration'
+require_relative '../grape/endpoint'
+require_relative '../lograge/integration'
+require_relative 'ext'
+require_relative 'utils'
+require_relative '../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|
+              rails_config = datadog_config.tracing[:rails]
+
+              # 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.
+              if datadog_config.service_without_fallback.nil?
+                datadog_config.service = rails_config[:service_name] || Utils.app_name
+              end
+
+              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],
+              request_queuing: rails_config[:request_queuing]
+            )
+          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

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

@@ -0,0 +1,49 @@
+# typed: false
+
+require_relative '../integration'
+
+require_relative 'ext'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rails
+        # Description of Rails integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('3.2')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :rails, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['railties'] && Gem.loaded_specs['railties'].version
+          end
+
+          def self.loaded?
+            !defined?(::Rails).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def self.patchable?
+            super && !ENV.key?(Ext::ENV_DISABLE)
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: false
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Instrument Rails.
+      module Rails
+        # Rails log injection helper methods
+        module LogInjection
+          module_function
+
+          def add_as_tagged_logging_logger(app)
+            # we want to check if the current logger is a tagger logger instance
+            # log_tags defaults to nil so we have to set as an array if nothing exists yet
+            if (log_tags = app.config.log_tags).nil?
+              app.config.log_tags = [proc { Tracing.log_correlation }]
+            # if existing log_tags configuration exists, append to the end of the array
+            elsif log_tags.is_a?(Array)
+              app.config.log_tags << proc { Tracing.log_correlation }
+            end
+          rescue StandardError => e
+            # TODO: can we use Datadog.logger at this point?
+            Datadog.logger.warn(
+              "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class.name} #{e.message}"
+            )
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# typed: true
+
+require_relative '../action_pack/utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Rails module includes middlewares that are required for Rails to be properly instrumented.
+      module Rails
+        # This is only here to catch errors, the Rack module does something very similar, however,
+        # since it's not in the same place in the stack, when the Rack middleware is called,
+        # error is already swallowed and handled by Rails so we miss the call stack, for instance.
+        class ExceptionMiddleware
+          def initialize(app)
+            @app = app
+          end
+
+          def call(env)
+            @app.call(env)
+          # 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
+            span = Tracing.active_span
+            if !span.nil? && ActionPack::Utils.exception_is_error?(e)
+              # Only set error if it's supposed to be flagged as such
+              # e.g. we don't want to flag 404s.
+              # You can add custom errors via `config.action_dispatch.rescue_responses`
+              span.set_error(e)
+
+              # Some exception gets handled by Rails middleware before it can be set on Rack middleware
+              # The rack span is the root span of the request and should make sure it has the full exception
+              # set on it.
+              env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN].set_error(e) if env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]
+            end
+            raise e
+          end
+          # rubocop:enable Lint/RescueException
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# typed: ignore
+
+require_relative '../../../core/utils/only_once'
+require_relative '../rack/middlewares'
+require_relative 'framework'
+require_relative 'log_injection'
+require_relative 'middlewares'
+require_relative 'utils'
+require_relative '../semantic_logger/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rails
+        # Patcher enables patching of 'rails' module.
+        module Patcher
+          include Contrib::Patcher
+
+          BEFORE_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Core::Utils::OnlyOnce.new }
+          AFTER_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Core::Utils::OnlyOnce.new }
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            patch_before_intialize
+            patch_after_intialize
+          end
+
+          def patch_before_intialize
+            ::ActiveSupport.on_load(:before_initialize) do
+              Contrib::Rails::Patcher.before_intialize(self)
+            end
+          end
+
+          def before_intialize(app)
+            BEFORE_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
+              # 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.tracing[:rails][:middleware]
+              add_logger(app) if Datadog.configuration.tracing.log_injection
+            end
+          end
+
+          def add_middleware(app)
+            # Add trace middleware at the top of the middleware stack,
+            # to ensure we capture the complete execution time.
+            app.middleware.insert_before(0, Contrib::Rack::TraceMiddleware)
+
+            # Some Rails middleware can swallow an application error, preventing
+            # the error propagation to the encompassing Rack span.
+            #
+            # We insert our own middleware right before these Rails middleware
+            # have a chance to swallow the error.
+            #
+            # Note: because the middleware stack is push/pop, "before" and "after" are reversed
+            # for our use case: we insert ourselves with "after" a middleware to ensure we are
+            # able to pop the request "before" it.
+            app.middleware.insert_after(::ActionDispatch::DebugExceptions, Contrib::Rails::ExceptionMiddleware)
+          end
+
+          def add_logger(app)
+            should_warn = true
+            # check if lograge key exists
+            # Note: Rails executes initializers sequentially based on alphabetical order,
+            # and lograge config could occur after datadog config.
+            # So checking for `app.config.lograge.enabled` may yield a false negative,
+            # and adding custom options naively if `config.lograge` exists from the lograge Railtie,
+            # is inconsistent since a lograge initializer would override it.
+            # Instead, we patch Lograge `custom_options` internals directly
+            # as part of Rails framework patching
+            # and just flag off the warning log here.
+            # SemanticLogger we similarly patch in the after_initiaize block, and should flag
+            # off the warning log here if we know we'll patch this gem later.
+            should_warn = false if app.config.respond_to?(:lograge) || defined?(::SemanticLogger)
+
+            # if lograge isn't set, check if tagged logged is enabled.
+            # if so, add proc that injects trace identifiers for tagged logging.
+            logger = app.config.logger || ::Rails.logger
+
+            if logger \
+                && defined?(::ActiveSupport::TaggedLogging) \
+                && logger.is_a?(::ActiveSupport::TaggedLogging)
+
+              Contrib::Rails::LogInjection.add_as_tagged_logging_logger(app)
+              should_warn = false
+            end
+
+            if should_warn
+              Datadog.logger.warn("Unable to enable Datadog Trace context, Logger #{logger.class} is not supported")
+            end
+          end
+
+          def patch_after_intialize
+            ::ActiveSupport.on_load(:after_initialize) do
+              Contrib::Rails::Patcher.after_intialize(self)
+            end
+          end
+
+          def after_intialize(app)
+            AFTER_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
+              # Finish configuring the tracer after the application is initialized.
+              # We need to wait for some things, like application name, middleware stack, etc.
+              setup_tracer
+            end
+          end
+
+          # Configure Rails tracing with settings
+          def setup_tracer
+            Contrib::Rails::Framework.setup
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# typed: ignore
+
+require_relative 'framework'
+require_relative 'middlewares'
+require_relative '../rack/middlewares'
+
+module Datadog
+  # Railtie class initializes
+  class Railtie < Rails::Railtie
+    # Add the trace middleware to the application stack
+    initializer 'datadog.before_intialize' do |app|
+      Tracing::Contrib::Rails::Patcher.before_intialize(app)
+    end
+
+    config.after_initialize do
+      Tracing::Contrib::Rails::Patcher.after_intialize(self)
+    end
+  end
+end