ddtrace 0.52.0 → 0.53.0

data/lib/ddtrace/contrib/active_job/event.rb

@@ -0,0 +1,54 @@
+# typed: true
+require 'ddtrace/contrib/active_support/notifications/event'
+require 'ddtrace/contrib/active_job/ext'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      # Defines basic behaviors for an ActiveJob event.
+      module Event
+        def self.included(base)
+          base.include(ActiveSupport::Notifications::Event)
+          base.extend(ClassMethods)
+        end
+
+        # Class methods for ActiveJob events.
+        module ClassMethods
+          def span_options
+            { service: configuration[:service_name] }
+          end
+
+          def tracer
+            -> { configuration[:tracer] }
+          end
+
+          def configuration
+            Datadog.configuration[:active_job]
+          end
+
+          def set_common_tags(span, payload)
+            adapter_name = if payload[:adapter].is_a?(Class)
+                             payload[:adapter].name
+                           else
+                             payload[:adapter].class.name
+                           end
+            span.set_tag(Ext::TAG_ADAPTER, adapter_name)
+
+            job = payload[:job]
+            span.set_tag(Ext::TAG_JOB_ID, job.job_id)
+            span.set_tag(Ext::TAG_JOB_QUEUE, job.queue_name)
+            span.set_tag(Ext::TAG_JOB_PRIORITY, job.priority) if job.respond_to?(:priority)
+            span.set_tag(Ext::TAG_JOB_EXECUTIONS, job.executions) if job.respond_to?(:executions)
+
+            job_scheduled_at = if job.respond_to?(:scheduled_at)
+                                 job.scheduled_at
+                               elsif job.respond_to?(:enqueued_at)
+                                 job.enqueued_at
+                               end
+            span.set_tag(Ext::TAG_JOB_SCHEDULED_AT, Time.at(job_scheduled_at)) if job_scheduled_at
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_job/events/discard.rb

@@ -0,0 +1,46 @@
+# typed: false
+require 'ddtrace/ext/integration'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_job/ext'
+require 'ddtrace/contrib/active_job/event'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      module Events
+        # Defines instrumentation for enqueue.active_job event
+        module Discard
+          include ActiveJob::Event
+
+          EVENT_NAME = 'discard.active_job'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_DISCARD
+          end
+
+          def process(span, event, _id, payload)
+            span.name = span_name
+            span.service = configuration[:service_name]
+            span.resource = payload[:job].class.name
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            set_common_tags(span, payload)
+            span.set_tag(Ext::TAG_JOB_ERROR, payload[:error])
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_job/events/enqueue.rb

@@ -0,0 +1,45 @@
+# typed: false
+require 'ddtrace/ext/integration'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_job/ext'
+require 'ddtrace/contrib/active_job/event'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      module Events
+        # Defines instrumentation for enqueue.active_job event
+        module Enqueue
+          include ActiveJob::Event
+
+          EVENT_NAME = 'enqueue.active_job'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_ENQUEUE
+          end
+
+          def process(span, event, _id, payload)
+            span.name = span_name
+            span.service = configuration[:service_name]
+            span.resource = payload[:job].class.name
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            set_common_tags(span, payload)
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_job/events/enqueue_at.rb

@@ -0,0 +1,45 @@
+# typed: false
+require 'ddtrace/ext/integration'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_job/ext'
+require 'ddtrace/contrib/active_job/event'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      module Events
+        # Defines instrumentation for enqueue.active_job event
+        module EnqueueAt
+          include ActiveJob::Event
+
+          EVENT_NAME = 'enqueue_at.active_job'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_ENQUEUE
+          end
+
+          def process(span, event, _id, payload)
+            span.name = span_name
+            span.service = configuration[:service_name]
+            span.resource = payload[:job].class.name
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            set_common_tags(span, payload)
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_job/events/enqueue_retry.rb

@@ -0,0 +1,47 @@
+# typed: false
+require 'ddtrace/ext/integration'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_job/ext'
+require 'ddtrace/contrib/active_job/event'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      module Events
+        # Defines instrumentation for enqueue.active_job event
+        module EnqueueRetry
+          include ActiveJob::Event
+
+          EVENT_NAME = 'enqueue_retry.active_job'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_ENQUEUE_RETRY
+          end
+
+          def process(span, event, _id, payload)
+            span.name = span_name
+            span.service = configuration[:service_name]
+            span.resource = payload[:job].class.name
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            set_common_tags(span, payload)
+            span.set_tag(Ext::TAG_JOB_ERROR, payload[:error])
+            span.set_tag(Ext::TAG_JOB_RETRY_WAIT, payload[:wait])
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_job/events/perform.rb

@@ -0,0 +1,45 @@
+# typed: false
+require 'ddtrace/ext/integration'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_job/ext'
+require 'ddtrace/contrib/active_job/event'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      module Events
+        # Defines instrumentation for perform.active_job event
+        module Perform
+          include ActiveJob::Event
+
+          EVENT_NAME = 'perform.active_job'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_PERFORM
+          end
+
+          def process(span, event, _id, payload)
+            span.name = span_name
+            span.service = configuration[:service_name]
+            span.resource = payload[:job].class.name
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            set_common_tags(span, payload)
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_job/events/retry_stopped.rb

@@ -0,0 +1,46 @@
+# typed: false
+require 'ddtrace/ext/integration'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_job/ext'
+require 'ddtrace/contrib/active_job/event'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      module Events
+        # Defines instrumentation for enqueue.active_job event
+        module RetryStopped
+          include ActiveJob::Event
+
+          EVENT_NAME = 'retry_stopped.active_job'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_RETRY_STOPPED
+          end
+
+          def process(span, event, _id, payload)
+            span.name = span_name
+            span.service = configuration[:service_name]
+            span.resource = payload[:job].class.name
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            set_common_tags(span, payload)
+            span.set_tag(Ext::TAG_JOB_ERROR, payload[:error])
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_job/events.rb

@@ -0,0 +1,39 @@
+# typed: false
+require 'ddtrace/contrib/active_job/events/discard'
+require 'ddtrace/contrib/active_job/events/enqueue'
+require 'ddtrace/contrib/active_job/events/enqueue_at'
+require 'ddtrace/contrib/active_job/events/enqueue_retry'
+require 'ddtrace/contrib/active_job/events/perform'
+require 'ddtrace/contrib/active_job/events/retry_stopped'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      # Defines collection of instrumented ActiveJob events
+      module Events
+        ALL = [
+          Events::Discard,
+          Events::Enqueue,
+          Events::EnqueueAt,
+          Events::EnqueueRetry,
+          Events::Perform,
+          Events::RetryStopped,
+        ].freeze
+
+        module_function
+
+        def all
+          self::ALL
+        end
+
+        def subscriptions
+          all.collect(&:subscriptions).collect(&:to_a).flatten
+        end
+
+        def subscribe!
+          all.each(&:subscribe!)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+module Datadog
+  module Contrib
+    module ActiveJob
+      module Ext
+        APP = 'active_job'.freeze
+        SERVICE_NAME = 'active_job'.freeze
+
+        ENV_ENABLED = 'DD_TRACE_ACTIVE_JOB_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_JOB_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_ACTIVE_JOB_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTIVE_JOB_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_ACTIVE_JOB_ANALYTICS_SAMPLE_RATE'.freeze
+
+        SPAN_DISCARD = 'active_job.discard'.freeze
+        SPAN_ENQUEUE = 'active_job.enqueue'.freeze
+        SPAN_ENQUEUE_RETRY = 'active_job.enqueue_retry'.freeze
+        SPAN_PERFORM = 'active_job.perform'.freeze
+        SPAN_RETRY_STOPPED = 'active_job.retry_stopped'.freeze
+
+        TAG_ADAPTER = 'active_job.adapter'.freeze
+        TAG_JOB_ERROR = 'active_job.job.error'.freeze
+        TAG_JOB_EXECUTIONS = 'active_job.job.executions'.freeze
+        TAG_JOB_ID = 'active_job.job.id'.freeze
+        TAG_JOB_PRIORITY = 'active_job.job.priority'.freeze
+        TAG_JOB_QUEUE = 'active_job.job.queue'.freeze
+        TAG_JOB_RETRY_WAIT = 'active_job.job.retry_wait'.freeze
+        TAG_JOB_SCHEDULED_AT = 'active_job.job.scheduled_at'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# typed: false
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/active_job/configuration/settings'
+require 'ddtrace/contrib/active_job/patcher'
+require 'ddtrace/contrib/rails/utils'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      # Describes the ActiveJob integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('4.2')
+
+        register_as :active_job, auto_patch: false
+
+        def self.version
+          Gem.loaded_specs['activejob'] && Gem.loaded_specs['activejob'].version
+        end
+
+        def self.loaded?
+          !defined?(::ActiveJob).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        # enabled by rails integration so should only auto instrument
+        # if detected that it is being used without rails
+        def auto_instrument?
+          !Datadog::Contrib::Rails::Utils.railtie_supported?
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          ActiveJob::Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_job/log_injection.rb

@@ -0,0 +1,21 @@
+# typed: false
+module Datadog
+  module Contrib
+    module ActiveJob
+      # Active Job log injection wrapped around job execution
+      module LogInjection
+        def self.included(base)
+          base.class_eval do
+            around_perform do |_, block|
+              if logger.respond_to?(:tagged)
+                logger.tagged(Datadog.tracer.active_correlation.to_s, &block)
+              else
+                block.call
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# typed: false
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/active_job/ext'
+require 'ddtrace/contrib/active_job/events'
+require 'ddtrace/contrib/active_job/log_injection'
+
+module Datadog
+  module Contrib
+    module ActiveJob
+      # Patcher enables patching of 'active_job' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          Events.subscribe!
+          inject_log_correlation if Datadog.configuration[:active_job][:log_injection]
+        end
+
+        def inject_log_correlation
+          ::ActiveSupport.on_load(:active_job) do
+            include LogInjection
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/auto_instrument.rb

@@ -1,5 +1,4 @@
 # typed: false
-require 'ddtrace'
 
 module Datadog
   module Contrib

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

@@ -1,5 +1,4 @@
 # typed: ignore
-require 'ddtrace'
 
 # Railtie to include AutoInstrumentation in rails loading
 class DatadogAutoInstrumentRailtie < Rails::Railtie

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

@@ -5,6 +5,7 @@ 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_mailer/integration'
 require 'ddtrace/contrib/action_pack/integration'
 require 'ddtrace/contrib/action_view/integration'
 require 'ddtrace/contrib/grape/endpoint'
@@ -45,9 +46,11 @@ module Datadog
 
             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)
@@ -93,6 +96,15 @@ module Datadog
           )
         end
 
+        def self.activate_action_mailer!(datadog_config, rails_config)
+          return unless defined?(::ActionMailer)
+
+          datadog_config.use(
+            :action_mailer,
+            service_name: "#{rails_config[:service_name]}-#{Contrib::ActionMailer::Ext::SERVICE_NAME}"
+          )
+        end
+
         def self.activate_action_pack!(datadog_config, rails_config)
           return unless defined?(::ActionPack)
 
@@ -115,6 +127,16 @@ module Datadog
           )
         end
 
+        def self.activate_active_job!(datadog_config, rails_config)
+          return unless defined?(::ActiveJob)
+
+          datadog_config.use(
+            :active_job,
+            service_name: "#{rails_config[:service_name]}-#{Contrib::ActiveJob::Ext::SERVICE_NAME}",
+            log_injection: rails_config[:log_injection]
+          )
+        end
+
         def self.activate_active_record!(datadog_config, rails_config)
           return unless defined?(::ActiveRecord)
 

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

@@ -1,4 +1,4 @@
-# typed: false
+# typed: ignore
 require 'ddtrace/contrib/rails/utils'
 require 'ddtrace/contrib/rails/framework'
 require 'ddtrace/contrib/rails/middlewares'
@@ -45,17 +45,26 @@ module Datadog
         end
 
         def add_middleware(app)
-          # Add trace middleware
+          # Add trace middleware at the top of the middleware stack,
+          # to ensure we capture the complete execution time.
           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
-          )
+          # 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.
+          if defined?(::ActionDispatch::DebugExceptions)
+            # Rails >= 3.2
+            app.middleware.insert_after(::ActionDispatch::DebugExceptions, Datadog::Contrib::Rails::ExceptionMiddleware)
+          else
+            # Rails < 3.2
+            app.middleware.insert_after(::ActionDispatch::ShowExceptions, Datadog::Contrib::Rails::ExceptionMiddleware)
+          end
         end
 
         def add_logger(app)

data/lib/ddtrace/contrib/registerable.rb

@@ -1,5 +1,4 @@
 # typed: false
-require 'datadog/contrib'
 
 module Datadog
   module Contrib

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

@@ -15,6 +15,9 @@ module Datadog
         SERVICE_NAME = 'sidekiq'.freeze
         SPAN_PUSH = 'sidekiq.push'.freeze
         SPAN_JOB = 'sidekiq.job'.freeze
+        SPAN_JOB_FETCH = 'sidekiq.job_fetch'.freeze
+        SPAN_HEARTBEAT = 'sidekiq.heartbeat'.freeze
+        SPAN_SCHEDULED_PUSH = 'sidekiq.scheduled_push'.freeze
         TAG_JOB_DELAY = 'sidekiq.job.delay'.freeze
         TAG_JOB_ID = 'sidekiq.job.id'.freeze
         TAG_JOB_QUEUE = 'sidekiq.job.queue'.freeze

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

@@ -11,6 +11,7 @@ module Datadog
         include Contrib::Integration
 
         MINIMUM_VERSION = Gem::Version.new('3.5.4')
+        MINIMUM_SERVER_INTERNAL_TRACING_VERSION = Gem::Version.new('5.2.4')
 
         register_as :sidekiq
 
@@ -26,6 +27,15 @@ module Datadog
           super && version >= MINIMUM_VERSION
         end
 
+        # Only patch server internals on v5.2.4+ because that's when loading of
+        # `Sidekiq::Launcher` stabilized. Sidekiq 4+ technically can support our
+        # patches (with minor adjustments), but in order to avoid explicitly
+        # requiring `sidekiq/launcher` ourselves (which could affect gem
+        # initialization order), we are limiting this tracing to v5.2.4+.
+        def self.compatible_with_server_internal_tracing?
+          version >= MINIMUM_SERVER_INTERNAL_TRACING_VERSION
+        end
+
         def default_configuration
           Configuration::Settings.new
         end