ddtrace 0.34.1 → 1.23.1

data/lib/datadog/tracing/contrib/sidekiq/ext.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        # Sidekiq integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          CLIENT_SERVICE_NAME = 'sidekiq-client'
+          ENV_ENABLED = 'DD_TRACE_SIDEKIQ_ENABLED'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SIDEKIQ_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SIDEKIQ_ANALYTICS_SAMPLE_RATE'
+          ENV_TAG_JOB_ARGS = 'DD_SIDEKIQ_TAG_JOB_ARGS'
+          SERVICE_NAME = 'sidekiq'
+          SPAN_PUSH = 'sidekiq.push'
+          SPAN_JOB = 'sidekiq.job'
+          SPAN_JOB_FETCH = 'sidekiq.job_fetch'
+          SPAN_REDIS_INFO = 'sidekiq.redis_info'
+          SPAN_HEARTBEAT = 'sidekiq.heartbeat'
+          SPAN_SCHEDULED_PUSH = 'sidekiq.scheduled_push'
+          SPAN_SCHEDULED_WAIT = 'sidekiq.scheduled_poller_wait'
+          SPAN_STOP = 'sidekiq.stop'
+          TAG_JOB_DELAY = 'sidekiq.job.delay'
+          TAG_JOB_ID = 'sidekiq.job.id'
+          TAG_JOB_QUEUE = 'sidekiq.job.queue'
+          TAG_JOB_RETRY = 'sidekiq.job.retry'
+          TAG_JOB_RETRY_COUNT = 'sidekiq.job.retry_count'
+          TAG_JOB_WRAPPER = 'sidekiq.job.wrapper'
+          TAG_JOB_ARGS = 'sidekiq.job.args'
+          TAG_COMPONENT = 'sidekiq'
+          TAG_OPERATION_PUSH = 'push'
+          TAG_OPERATION_JOB = 'job'
+          TAG_OPERATION_JOB_FETCH = 'job_fetch'
+          TAG_OPERATION_REDIS_INFO = 'redis_info'
+          TAG_OPERATION_HEARTBEAT = 'heartbeat'
+          TAG_OPERATION_SCHEDULED_PUSH = 'scheduled_push'
+          TAG_OPERATION_SCHEDULED_WAIT = 'scheduled_poller_wait'
+          TAG_OPERATION_STOP = 'stop'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        # Description of Sidekiq integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('3.5.4')
+          MINIMUM_SERVER_INTERNAL_TRACING_VERSION = Gem::Version.new('5.2.4')
+          MINIMUM_CAPSULE_VERSION = Gem::Version.new('7.0.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :sidekiq
+
+          def self.version
+            Gem.loaded_specs['sidekiq'] && Gem.loaded_specs['sidekiq'].version
+          end
+
+          def self.loaded?
+            !defined?(::Sidekiq).nil?
+          end
+
+          def self.compatible?
+            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
+
+          # Capsules are a new way of configuring Sidekiq that was introduced in version 7
+          # that change the way some of the configuration data is exposed. Certain patches
+          # are applied differently for versions of Sidekiq that support capsules.
+          def self.supports_capsules?
+            version >= MINIMUM_CAPSULE_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        # Patcher enables patching of 'sidekiq' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'client_tracer'
+            require_relative 'server_tracer'
+
+            ::Sidekiq.configure_client do |config|
+              config.client_middleware do |chain|
+                chain.add(Sidekiq::ClientTracer)
+              end
+            end
+
+            ::Sidekiq.configure_server do |config|
+              # If a job enqueues another job, make sure it has the same client
+              # middleware.
+              config.client_middleware do |chain|
+                chain.add(Sidekiq::ClientTracer)
+              end
+
+              config.server_middleware do |chain|
+                chain.add(Sidekiq::ServerTracer)
+              end
+
+              patch_server_internals if Integration.compatible_with_server_internal_tracing?
+            end
+          end
+
+          def patch_server_internals
+            patch_server_heartbeat
+            patch_server_job_fetch
+            patch_server_scheduled_push
+            patch_redis_info
+          end
+
+          def patch_server_heartbeat
+            require_relative 'server_internal_tracer/stop'
+            require_relative 'server_internal_tracer/heartbeat'
+
+            ::Sidekiq::Launcher.prepend(ServerInternalTracer::Stop)
+
+            # Sidekiq 7 changed method `heartbeat` to `beat`
+            if ::Sidekiq::Launcher.private_method_defined? :heartbeat
+              ::Sidekiq::Launcher.prepend(ServerInternalTracer::Heartbeat)
+            end
+
+            ::Sidekiq::Launcher.prepend(ServerInternalTracer::Beat) if ::Sidekiq::Launcher.private_method_defined? :beat
+          end
+
+          def patch_server_job_fetch
+            require_relative 'server_internal_tracer/job_fetch'
+
+            ::Sidekiq::Processor.prepend(ServerInternalTracer::JobFetch)
+          end
+
+          def patch_server_scheduled_push
+            require_relative 'server_internal_tracer/scheduled_poller'
+
+            ::Sidekiq::Scheduled::Poller.prepend(ServerInternalTracer::ScheduledPoller)
+          end
+
+          def patch_redis_info
+            require_relative 'server_internal_tracer/redis_info'
+
+            if Integration.supports_capsules?
+              ::Sidekiq::Config.prepend(ServerInternalTracer::RedisInfo)
+            else
+              ::Sidekiq.singleton_class.prepend(ServerInternalTracer::RedisInfo)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/heartbeat.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module ServerInternalTracer
+          # Trace when a Sidekiq process has a heartbeat
+          module Heartbeat
+            private
+
+            def heartbeat
+              configuration = Datadog.configuration.tracing[:sidekiq]
+
+              Datadog::Tracing.trace(Ext::SPAN_HEARTBEAT, service: configuration[:service_name]) do |span|
+                span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HEARTBEAT)
+
+                # Set analytics sample rate
+                if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                  Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+                end
+
+                super
+              end
+            end
+          end
+
+          # This implementation is identical to `Heartbeat`, but patching `beat` method instead.
+          module Beat
+            private
+
+            def beat
+              configuration = Datadog.configuration.tracing[:sidekiq]
+
+              Datadog::Tracing.trace(Ext::SPAN_HEARTBEAT, service: configuration[:service_name]) do |span|
+                span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_HEARTBEAT)
+
+                # Set analytics sample rate
+                if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                  Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+                end
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/job_fetch.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module ServerInternalTracer
+          # Trace when Sidekiq looks for another job to work
+          module JobFetch
+            private
+
+            def fetch
+              configuration = Datadog.configuration.tracing[:sidekiq]
+
+              Datadog::Tracing.trace(Ext::SPAN_JOB_FETCH, service: configuration[:service_name]) do |span|
+                span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB_FETCH)
+
+                # Set analytics sample rate
+                if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                  Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+                end
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/redis_info.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module ServerInternalTracer
+          # Trace when Sidekiq gets Redis info on startup
+          module RedisInfo
+            def redis_info
+              configuration = Datadog.configuration.tracing[:sidekiq]
+
+              Datadog::Tracing.trace(Ext::SPAN_REDIS_INFO, service: configuration[:service_name]) do |span|
+                span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REDIS_INFO)
+
+                # Set analytics sample rate
+                if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                  Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+                end
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/scheduled_poller.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module ServerInternalTracer
+          # Trace when Sidekiq checks to see if there are scheduled jobs that need to be worked
+          # https://github.com/mperham/sidekiq/wiki/Scheduled-Jobs
+          module ScheduledPoller
+            def enqueue
+              configuration = Datadog.configuration.tracing[:sidekiq]
+
+              Datadog::Tracing.trace(Ext::SPAN_SCHEDULED_PUSH, service: configuration[:service_name]) do |span|
+                span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SCHEDULED_PUSH)
+
+                # Set analytics sample rate
+                if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                  Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+                end
+
+                super
+              end
+            end
+
+            private
+
+            def wait
+              configuration = Datadog.configuration.tracing[:sidekiq]
+
+              Datadog::Tracing.trace(Ext::SPAN_SCHEDULED_WAIT, service: configuration[:service_name]) do |span|
+                span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SCHEDULED_WAIT)
+
+                # Set analytics sample rate
+                if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                  Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+                end
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/server_internal_tracer/stop.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module ServerInternalTracer
+          # Trace when Sidekiq stops
+          module Stop
+            def stop
+              configuration = Datadog.configuration.tracing[:sidekiq]
+
+              Datadog::Tracing.trace(Ext::SPAN_STOP, service: configuration[:service_name]) do |span|
+                span.span_type = Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER
+
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_STOP)
+
+                # Set analytics sample rate
+                if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                  Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+                end
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/server_tracer.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative 'utils'
+require_relative '../utils/quantization/hash'
+require_relative 'distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        # Tracer is a Sidekiq server-side middleware which traces executed jobs
+        class ServerTracer
+          include Utils
+
+          QUANTIZE_SHOW_ALL = { args: { show: :all } }.freeze
+
+          def initialize(options = {})
+            @sidekiq_service = options[:service_name] || configuration[:service_name]
+            @error_handler = options[:error_handler] || configuration[:error_handler]
+          end
+
+          # rubocop:disable Metrics/MethodLength
+          # rubocop:disable Metrics/AbcSize
+          def call(worker, job, queue)
+            resource = job_resource(job)
+
+            if configuration[:distributed_tracing]
+              trace_digest = propagation.extract(job)
+              Datadog::Tracing.continue_trace!(trace_digest)
+            end
+
+            service = worker_config(resource, :service_name) || @sidekiq_service
+            # DEV-2.0: Remove `tag_args`, as `quantize` can fulfill the same contract
+            tag_args = worker_config(resource, :tag_args) || configuration[:tag_args]
+            quantize = worker_config(resource, :quantize) || configuration[:quantize]
+
+            Datadog::Tracing.trace(
+              Ext::SPAN_JOB,
+              service: service,
+              span_type: Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER,
+              on_error: @error_handler
+            ) do |span|
+              span.resource = resource
+
+              span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_COMPONENT)
+
+              span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB)
+
+              span.set_tag(
+                Datadog::Tracing::Metadata::Ext::TAG_KIND,
+                Datadog::Tracing::Metadata::Ext::SpanKind::TAG_CONSUMER
+              )
+
+              # Set analytics sample rate
+              if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+                Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+              end
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(span)
+
+              span.set_tag(Ext::TAG_JOB_ID, job['jid'])
+              span.set_tag(Ext::TAG_JOB_RETRY, job['retry'])
+              span.set_tag(Ext::TAG_JOB_RETRY_COUNT, job['retry_count'])
+              span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
+              span.set_tag(Ext::TAG_JOB_WRAPPER, job['class']) if job['wrapped']
+              span.set_tag(Ext::TAG_JOB_DELAY, 1000.0 * (Time.now.utc.to_f - job['enqueued_at'].to_f))
+
+              args = job['args']
+              if args && !args.empty?
+                quantize = tag_args ? QUANTIZE_SHOW_ALL : quantize
+                span.set_tag(Ext::TAG_JOB_ARGS, quantize_args(quantize, args))
+              end
+
+              yield
+            end
+            # rubocop:enable Metrics/MethodLength
+            # rubocop:enable Metrics/AbcSize
+          end
+
+          private
+
+          def propagation
+            @propagation ||= Contrib::Sidekiq::Distributed::Propagation.new
+          end
+
+          def quantize_args(quantize, args)
+            quantize_options = quantize && quantize[:args]
+            quantize_options ||= {}
+
+            Contrib::Utils::Quantization::Hash.format(args, quantize_options)
+          end
+
+          def configuration
+            Datadog.configuration.tracing[:sidekiq]
+          end
+
+          # DEV-2.0: Is this still being used? If not, we should remove it
+          # as this adds brittleness and complexity to this integration.
+          def worker_config(resource, key)
+            # Try to get the Ruby class from the resource name.
+            worker_klass = begin
+              Object.const_get(resource)
+            rescue NameError
+              nil
+            end
+
+            worker_klass.datadog_tracer_config[key] if worker_klass.respond_to?(:datadog_tracer_config)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sidekiq/utils.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+require_relative '../../../core'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        # Common functionality used by both client-side and server-side tracers.
+        module Utils
+          protected
+
+          # If class is wrapping something else, the interesting resource info
+          # is the underlying, wrapped class, and not the wrapper. This is
+          # primarily to support `ActiveJob`.
+          def job_resource(job)
+            if job['wrapped']
+              job['wrapped'].to_s
+            elsif job['class'] == 'Sidekiq::Extensions::DelayedClass'
+              delay_extension_class(job).to_s
+            else
+              job['class'].to_s
+            end
+          rescue => e
+            Datadog.logger.debug { "Error retrieving Sidekiq job class name (jid:#{job['jid']}): #{e}" }
+
+            job['class'].to_s
+          end
+
+          def delay_extension_class(job)
+            clazz, method = YAML.parse(job['args'].first).children.first.children
+
+            method = method.value[1..-1] # Remove leading `:` from method symbol
+
+            "#{clazz.value}.#{method}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sinatra/configuration/settings.rb

@@ -0,0 +1,44 @@
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sinatra
+        module Configuration
+          # Custom settings for the Sinatra integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            DEFAULT_HEADERS = {
+              response: %w[Content-Type X-Request-ID]
+            }.freeze
+
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool, nilable: true
+              o.env Ext::ENV_ANALYTICS_ENABLED
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :distributed_tracing, default: true, type: :bool
+            option :headers, default: DEFAULT_HEADERS, type: :hash
+            option :resource_script_names, default: false, type: :bool
+
+            option :service_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sinatra/env.rb

@@ -0,0 +1,36 @@
+require 'time'
+
+require_relative '../../metadata/ext'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sinatra
+        # Gets and sets trace information from a Rack Env
+        module Env
+          module_function
+
+          def datadog_span(env)
+            env[Ext::RACK_ENV_SINATRA_REQUEST_SPAN]
+          end
+
+          def set_datadog_span(env, span)
+            env[Ext::RACK_ENV_SINATRA_REQUEST_SPAN] = span
+          end
+
+          def route_path(env, use_script_names: Datadog.configuration.tracing[:sinatra][:resource_script_names])
+            return unless env['sinatra.route']
+
+            _, path = env['sinatra.route'].split(' ', 2)
+            if use_script_names
+              env['SCRIPT_NAME'].to_s + path
+            else
+              path
+            end
+          end
+        end
+      end
+    end
+  end
+end