ddtrace 0.13.0 → 0.47.0

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

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

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

@@ -0,0 +1,17 @@
+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,14 +1,14 @@
 require 'ddtrace/pin'
 require 'ddtrace/ext/app_types'
 
-require 'ddtrace/contrib/active_record/patcher'
+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/rack/middlewares'
 
-require 'ddtrace/contrib/rails/core_extensions'
-require 'ddtrace/contrib/rails/action_controller'
-require 'ddtrace/contrib/rails/action_view'
-require 'ddtrace/contrib/rails/active_support'
+require 'ddtrace/contrib/rails/ext'
 require 'ddtrace/contrib/rails/utils'
 
 module Datadog
@@ -19,55 +19,104 @@ module Datadog
       # - handle configuration entries which are specific to Datadog tracing
       # - instrument parts of the framework when needed
       module Framework
-        # configure Datadog settings
+        # 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
-          config = config_with_defaults
+          # 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)
 
-          activate_rack!(config)
-          activate_active_record!(config)
-          set_service_info!(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]
 
-          # By default, default service would be guessed from the script
-          # being executed, but here we know better, get it from Rails config.
-          config[:tracer].default_service = 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
+        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.configuration[:rails].tap do |config|
-            config[:service_name] ||= Utils.app_name
+          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!(config)
-          Datadog.configuration.use(
+        def self.activate_rack!(datadog_config, rails_config)
+          datadog_config.use(
             :rack,
-            tracer: config[:tracer],
             application: ::Rails.application,
-            service_name: config[:service_name],
-            middleware_names: config[:middleware_names],
-            distributed_tracing: config[:distributed_tracing]
+            service_name: rails_config[:service_name],
+            middleware_names: rails_config[:middleware_names],
+            distributed_tracing: rails_config[:distributed_tracing]
           )
         end
 
-        def self.activate_active_record!(config)
-          return unless defined?(::ActiveRecord)
+        def self.activate_active_support!(datadog_config, rails_config)
+          return unless defined?(::ActiveSupport)
 
-          Datadog.configuration.use(
-            :active_record,
-            service_name: config[:database_service],
-            tracer: config[:tracer]
+          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.set_service_info!(config)
-          tracer = config[:tracer]
-          tracer.set_service_info(config[:controller_service], 'rails', Ext::AppTypes::WEB)
-          tracer.set_service_info(config[:cache_service], 'rails', Ext::AppTypes::CACHE)
+        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

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/log_injection.rb

@@ -0,0 +1,81 @@
+module Datadog
+  module Contrib
+    # Instrument Rails.
+    module Rails
+      # Rails log injection helper methods
+      module LogInjection
+        module_function
+
+        def add_lograge_logger(app)
+          # custom_options defaults to nil and can be either a hash or a lambda which returns a hash
+          # https://github.com/roidrage/lograge/blob/1729eab7956bb95c5992e4adab251e4f93ff9280/lib/lograge.rb#L28
+          if (custom_options = app.config.lograge.custom_options).nil?
+            # if it's not set, we set to a lambda that returns DD tracing context
+            app.config.lograge.custom_options = lambda do |_event|
+              # Retrieves trace information for current thread
+              correlation = Datadog.tracer.active_correlation
+
+              datadog_trace_log_hash(correlation)
+            end
+          # check if lambda, if so then define a new lambda which invokes the original lambda and
+          # merges the returned hash with the the DD tracing context hash.
+          elsif custom_options.respond_to?(:call)
+            app.config.lograge.custom_options = lambda do |event|
+              # invoke original lambda
+              result = custom_options.call(event)
+              # Retrieves trace information for current thread
+              correlation = Datadog.tracer.active_correlation
+              # merge original lambda with datadog context
+              result.merge(datadog_trace_log_hash(correlation))
+            end
+          # otherwise if it's just a static hash, we have to wrap that hash in a lambda to retrieve
+          # the DD tracing context, then merge the tracing context with the original static hash.
+          # don't modify if custom_options is not an accepted format.
+          elsif custom_options.is_a?(Hash)
+            app.config.lograge.custom_options = lambda do |_event|
+              # Retrieves trace information for current thread
+              correlation = Datadog.tracer.active_correlation
+
+              # merge original lambda with datadog context
+              custom_options.merge(datadog_trace_log_hash(correlation))
+            end
+          end
+        rescue StandardError => e
+          # TODO: can we use Datadog.logger at this point?
+          Datadog.logger.warn("Unable to add Datadog Trace context to Lograge: #{e.message}")
+          false
+        end
+
+        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 { Datadog.tracer.active_correlation.to_s }]
+          # if existing log_tags configuration exists, append to the end of the array
+          elsif log_tags.is_a?(Array)
+            app.config.log_tags << proc { Datadog.tracer.active_correlation.to_s }
+          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.message}")
+          false
+        end
+
+        def datadog_trace_log_hash(correlation)
+          {
+            # Adds IDs as tags to log output
+            dd: {
+              # To preserve precision during JSON serialization, use strings for large numbers
+              trace_id: correlation.trace_id.to_s,
+              span_id: correlation.span_id.to_s,
+              env: correlation.env.to_s,
+              service: correlation.service.to_s,
+              version: correlation.version.to_s
+            },
+            ddsource: ['ruby']
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 require 'ddtrace/ext/http'
+require 'ddtrace/contrib/action_pack/utils'
 
 module Datadog
   module Contrib
@@ -23,11 +24,16 @@ module Datadog
         rescue Exception => e
           tracer = Datadog.configuration[:rails][:tracer]
           span = tracer.active_span
-          unless span.nil?
+          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) if Utils.exception_is_error?(e)
+            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[:datadog_rack_request_span].set_error(e) if env[:datadog_rack_request_span]
           end
           raise e
         end

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

@@ -1,53 +1,107 @@
 require 'ddtrace/contrib/rails/utils'
+require 'ddtrace/contrib/rails/framework'
+require 'ddtrace/contrib/rails/middlewares'
+require 'ddtrace/contrib/rails/log_injection'
+require 'ddtrace/contrib/rack/middlewares'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   module Contrib
     module Rails
-      # Patcher
+      # Patcher enables patching of 'rails' module.
       module Patcher
-        include Base
-        register_as :rails, auto_patch: true
-
-        option :service_name
-        option :controller_service
-        option :cache_service
-        option :database_service, depends_on: [:service_name] do |value|
-          value.tap do
-            # Update ActiveRecord service name too
-            Datadog.configuration[:active_record][:service_name] = value
+        include Contrib::Patcher
+
+        BEFORE_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Datadog::Utils::OnlyOnce.new }
+        AFTER_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Datadog::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
+            Datadog::Contrib::Rails::Patcher.before_intialize(self)
           end
         end
-        option :middleware_names, default: false
-        option :distributed_tracing, default: false
-        option :template_base_path, default: 'views/'
-        option :exception_controller, default: nil
-        option :tracer, default: Datadog.tracer
-
-        @patched = false
-
-        class << self
-          def patch
-            return @patched if patched? || !compatible?
-            require_relative 'framework'
-            @patched = true
-          rescue => e
-            Datadog::Tracer.log.error("Unable to apply Rails integration: #{e}")
-            @patched
+
+        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[:rails][:middleware]
+            add_logger(app) if Datadog.configuration[:rails][:log_injection]
+          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 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 dd config.
+          # Checking for `app.config.lograge.enabled` may yield a false negative.
+          # Instead we should naively add custom options if `config.lograge` exists from the lograge Railtie,
+          # since the custom options get ignored without lograge explicitly being enabled.
+          # See: https://github.com/roidrage/lograge/blob/1729eab7956bb95c5992e4adab251e4f93ff9280/lib/lograge/railtie.rb#L7-L12
+          if app.config.respond_to?(:lograge)
+            Datadog::Contrib::Rails::LogInjection.add_lograge_logger(app)
+            should_warn = false
           end
 
-          def patched?
-            @patched
+          # if lograge isn't set, check if tagged logged is enabled.
+          # if so, add proc that injects trace identifiers for tagged logging.
+          if (logger = app.config.logger) &&
+             defined?(::ActiveSupport::TaggedLogging) &&
+             logger.is_a?(::ActiveSupport::TaggedLogging)
+
+            Datadog::Contrib::Rails::LogInjection.add_as_tagged_logging_logger(app)
+            should_warn = false
           end
 
-          def compatible?
-            return if ENV['DISABLE_DATADOG_RAILS']
+          Datadog.logger.warn("Unable to enable Datadog Trace context, Logger #{logger} is not supported") if should_warn
+        end
 
-            defined?(::Rails::VERSION) && ::Rails::VERSION::MAJOR.to_i >= 3
+        def patch_after_intialize
+          ::ActiveSupport.on_load(:after_initialize) do
+            Datadog::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
+          Datadog::Contrib::Rails::Framework.setup
+        end
       end
     end
   end
 end
-
-require 'ddtrace/contrib/rails/railtie' if Datadog.registry[:rails].compatible?