ddtrace 0.38.0

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

@@ -0,0 +1,39 @@
+module Datadog
+  module Contrib
+    module Rack
+      # QueueTime simply...
+      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/configuration/settings.rb

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

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

@@ -0,0 +1,13 @@
+module Datadog
+  module Contrib
+    module Rails
+      # Rails integration constants
+      module Ext
+        APP = 'rails'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_RAILS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_RAILS_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_DISABLE = 'DISABLE_DATADOG_RAILS'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+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

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

@@ -0,0 +1,44 @@
+require 'ddtrace/contrib/integration'
+
+require 'ddtrace/contrib/rails/ext'
+require 'ddtrace/contrib/rails/configuration/settings'
+require 'ddtrace/contrib/rails/patcher'
+
+module Datadog
+  module Contrib
+    module Rails
+      # Description of Rails integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('3.0')
+
+        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 default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'ddtrace/ext/http'
+require 'ddtrace/contrib/action_pack/utils'
+
+module Datadog
+  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
+          tracer = Datadog.configuration[:rails][:tracer]
+          span = tracer.active_span
+          unless span.nil?
+            # 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) if ActionPack::Utils.exception_is_error?(e)
+          end
+          raise e
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require 'ddtrace/contrib/rails/utils'
+require 'ddtrace/contrib/rails/framework'
+require 'ddtrace/contrib/rails/middlewares'
+require 'ddtrace/contrib/rack/middlewares'
+
+module Datadog
+  module Contrib
+    module Rails
+      # Patcher enables patching of 'rails' module.
+      module Patcher
+        include Contrib::Patcher
+
+        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
+            Datadog::Contrib::Rails::Patcher.before_intialize(self)
+          end
+        end
+
+        def before_intialize(app)
+          do_once(:rails_before_initialize, for: app) 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[:rails][:middleware]
+          end
+        end
+
+        def add_middleware(app)
+          # Add trace middleware
+          app.middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware)
+
+          # Insert right after Rails exception handling middleware, because if it's before,
+          # it catches and swallows the error. If it's too far after, custom middleware can find itself
+          # between, and raise exceptions that don't end up getting tagged on the request properly.
+          # e.g lost stack trace.
+          app.middleware.insert_after(
+            ActionDispatch::ShowExceptions,
+            Datadog::Contrib::Rails::ExceptionMiddleware
+          )
+        end
+
+        def patch_after_intialize
+          ::ActiveSupport.on_load(:after_initialize) do
+            Datadog::Contrib::Rails::Patcher.after_intialize(self)
+          end
+        end
+
+        def after_intialize(app)
+          do_once(:rails_after_initialize, for: app) 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
+          Datadog::Contrib::Rails::Framework.setup
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'ddtrace/contrib/rails/framework'
+require 'ddtrace/contrib/rails/middlewares'
+require 'ddtrace/contrib/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|
+      Datadog::Contrib::Rails::Patcher.before_intialize(app)
+    end
+
+    config.after_initialize do
+      Datadog::Contrib::Rails::Patcher.after_intialize(self)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module Rails
+      # common utilities for Rails
+      module Utils
+        def self.app_name
+          if ::Rails::VERSION::MAJOR >= 6
+            ::Rails.application.class.module_parent_name.underscore
+          elsif ::Rails::VERSION::MAJOR >= 4
+            ::Rails.application.class.parent_name.underscore
+          else
+            ::Rails.application.class.to_s.underscore
+          end
+        end
+      end
+    end
+  end
+end