ddtrace 0.54.2 → 1.2.0

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

@@ -0,0 +1,38 @@
+# typed: 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'.freeze
+          ENV_ENABLED = 'DD_TRACE_SIDEKIQ_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SIDEKIQ_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SIDEKIQ_ANALYTICS_SAMPLE_RATE'.freeze
+          ENV_TAG_JOB_ARGS = 'DD_SIDEKIQ_TAG_JOB_ARGS'.freeze
+          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
+          TAG_JOB_RETRY = 'sidekiq.job.retry'.freeze
+          TAG_JOB_RETRY_COUNT = 'sidekiq.job.retry_count'.freeze
+          TAG_JOB_WRAPPER = 'sidekiq.job.wrapper'.freeze
+          TAG_JOB_ARGS = 'sidekiq.job.args'.freeze
+          TAG_COMPONENT = 'sidekiq'.freeze
+          TAG_OPERATION_PUSH = 'push'.freeze
+          TAG_OPERATION_JOB = 'job'.freeze
+          TAG_OPERATION_JOB_FETCH = 'job_fetch'.freeze
+          TAG_OPERATION_HEARTBEAT = 'heartbeat'.freeze
+          TAG_OPERATION_SCHEDULED_PUSH = 'scheduled_push'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# typed: false
+
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/sidekiq/configuration/settings'
+require 'datadog/tracing/contrib/sidekiq/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')
+
+          # @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
+
+          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,71 @@
+# typed: false
+
+require 'datadog/tracing/contrib/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 'datadog/tracing/contrib/sidekiq/client_tracer'
+            require 'datadog/tracing/contrib/sidekiq/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
+          end
+
+          def patch_server_heartbeat
+            require 'datadog/tracing/contrib/sidekiq/server_internal_tracer/heartbeat'
+
+            ::Sidekiq::Launcher.prepend(ServerInternalTracer::Heartbeat)
+          end
+
+          def patch_server_job_fetch
+            require 'datadog/tracing/contrib/sidekiq/server_internal_tracer/job_fetch'
+
+            ::Sidekiq::Processor.prepend(ServerInternalTracer::JobFetch)
+          end
+
+          def patch_server_scheduled_push
+            require 'datadog/tracing/contrib/sidekiq/server_internal_tracer/scheduled_push'
+
+            ::Sidekiq::Scheduled::Poller.prepend(ServerInternalTracer::ScheduledPush)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module ServerInternalTracer
+          # Trace when a Sidekiq process has a heartbeat
+          module Heartbeat
+            private
+
+            def ❤ # rubocop:disable Naming/AsciiIdentifiers, Naming/MethodName
+              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(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,34 @@
+# typed: 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(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/scheduled_push.rb

@@ -0,0 +1,33 @@
+# typed: 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 ScheduledPush
+            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(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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# typed: true
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/sidekiq/ext'
+require 'datadog/tracing/contrib/sidekiq/tracing'
+require 'datadog/tracing/contrib/utils/quantization/hash'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        # Tracer is a Sidekiq server-side middleware which traces executed jobs
+        class ServerTracer
+          include Tracing
+
+          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
+
+          def call(worker, job, queue)
+            resource = job_resource(job)
+
+            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(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_JOB)
+
+              # 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
+          end
+
+          private
+
+          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/tracing.rb

@@ -0,0 +1,44 @@
+# typed: true
+
+require 'yaml'
+
+require 'datadog/core'
+require 'datadog/tracing/contrib/sidekiq/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        # Common functionality used by both client-side and server-side tracers.
+        module Tracing
+          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,43 @@
+# typed: false
+
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/sinatra/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.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
+            end
+
+            option :analytics_sample_rate do |o|
+              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+              o.lazy
+            end
+
+            option :distributed_tracing, default: true
+            option :headers, default: DEFAULT_HEADERS
+            option :resource_script_names, default: false
+
+            option :service_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# typed: true
+
+require 'time'
+
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/sinatra/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, app)
+            request_span = env[Ext::RACK_ENV_REQUEST_SPAN]
+            request_span && request_span[app]
+          end
+
+          def set_datadog_span(env, app, span)
+            hash = (env[Ext::RACK_ENV_REQUEST_SPAN] ||= {})
+            hash[app] = span
+          end
+
+          def request_header_tags(env, headers)
+            headers ||= []
+
+            {}.tap do |result|
+              headers.each do |header|
+                rack_header = header_to_rack_header(header)
+                if env.key?(rack_header)
+                  result[Tracing::Metadata::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header]
+                end
+              end
+            end
+          end
+
+          def header_to_rack_header(name)
+            "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+          end
+
+          # Was a Sinatra already traced in this request?
+          # We don't want to create spans for intermediate Sinatra
+          # middlewares that don't match the request at hand.
+          def middleware_traced?(env)
+            env[Ext::RACK_ENV_MIDDLEWARE_TRACED]
+          end
+
+          def set_middleware_traced(env, bool)
+            env[Ext::RACK_ENV_MIDDLEWARE_TRACED] = bool
+          end
+
+          # The start time of the top-most Sinatra middleware.
+          def middleware_start_time(env)
+            env[Ext::RACK_ENV_MIDDLEWARE_START_TIME]
+          end
+
+          def set_middleware_start_time(env, time = Time.now.utc)
+            env[Ext::RACK_ENV_MIDDLEWARE_START_TIME] = time
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sinatra
+        # Sinatra integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_SINATRA_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SINATRA_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SINATRA_ANALYTICS_SAMPLE_RATE'.freeze
+          RACK_ENV_REQUEST_SPAN = 'datadog.sinatra_request_span'.freeze
+          RACK_ENV_MIDDLEWARE_START_TIME = 'datadog.sinatra_middleware_start_time'.freeze
+          RACK_ENV_MIDDLEWARE_TRACED = 'datadog.sinatra_middleware_traced'.freeze
+          SPAN_RENDER_TEMPLATE = 'sinatra.render_template'.freeze
+          SPAN_REQUEST = 'sinatra.request'.freeze
+          SPAN_ROUTE = 'sinatra.route'.freeze
+          TAG_APP_NAME = 'sinatra.app.name'.freeze
+          TAG_COMPONENT = 'sinatra'.freeze
+          TAG_OPERATION_RENDER_TEMPLATE = 'render_template'.freeze
+          TAG_OPERATION_REQUEST = 'request'.freeze
+          TAG_OPERATION_ROUTE = 'route'.freeze
+          TAG_ROUTE_PATH = 'sinatra.route.path'.freeze
+          TAG_SCRIPT_NAME = 'sinatra.script_name'.freeze
+          TAG_TEMPLATE_ENGINE = 'sinatra.template_engine'.freeze
+          TAG_TEMPLATE_NAME = 'sinatra.template_name'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# typed: false
+
+require 'datadog/tracing'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Instrument Sinatra.
+      module Sinatra
+        # Sinatra framework code, used to essentially:
+        # - handle configuration entries which are specific to Datadog tracing
+        # - instrument parts of the framework when needed
+        module Framework
+          # Configure Rack from Sinatra, but only if Rack has not been configured manually beforehand
+          def self.setup
+            Datadog.configure do |datadog_config|
+              sinatra_config = config_with_defaults(datadog_config)
+              activate_rack!(datadog_config, sinatra_config)
+            end
+          end
+
+          def self.config_with_defaults(datadog_config)
+            datadog_config.tracing[:sinatra]
+          end
+
+          # Apply relevant configuration from Sinatra to Rack
+          def self.activate_rack!(datadog_config, sinatra_config)
+            datadog_config.tracing.instrument(
+              :rack,
+              service_name: sinatra_config[:service_name],
+              distributed_tracing: sinatra_config[:distributed_tracing],
+            )
+          end
+
+          # Add Rack middleware at the top of the stack
+          def self.add_middleware(middleware, builder, *args, &block)
+            insert_middleware(builder, middleware, args, block) do |proc_, use|
+              use.insert(0, proc_)
+            end
+          end
+
+          class << self
+            alias_method :unshift_middleare, :add_middleware
+          end
+
+          # Add Rack middleware at the top of the stack
+          def self.append_middleware(middleware, builder, *args, &block)
+            insert_middleware(builder, middleware, args, block) do |proc_, use|
+              use.append(proc_)
+            end
+          end
+
+          # Add Rack middleware before another in the stack
+          def self.add_middleware_before(before, middleware, builder, *args, &block)
+            index = middlewares(builder).index(before)
+
+            raise "middleware #{before} not found" unless index
+
+            insert_middleware(builder, middleware, args, block) do |proc_, use|
+              use.insert(index, proc_)
+            end
+          end
+
+          # Add Rack middleware after another in the the stack
+          def self.add_middleware_after(after, middleware, builder, *args, &block)
+            index = middlewares(builder).index(after)
+
+            raise "middleware #{after} not found" unless index
+
+            insert_middleware(builder, middleware, args, block) do |proc_, use|
+              use.insert(index + 1, proc_)
+            end
+          end
+
+          # Wrap the middleware class instantiation in a proc, like Sinatra does internally
+          # The `middleware` local variable name in the proc is important for introspection
+          # (see Framework#middlewares)
+          def self.wrap_middleware(middleware, *args, &block)
+            proc { |app| middleware.new(app, *args, &block) }
+          end
+
+          # Insert a middleware class in the builder as it expects it internally.
+          # The block gets passed prepared arguments for the caller to decide
+          # how to insert.
+          def self.insert_middleware(builder, middleware, args, block)
+            use = builder.instance_variable_get('@use')
+            wrapped = wrap_middleware(middleware, *args, &block)
+
+            # Makes the insert idempotent
+            # The block can also throw :skip with its own logic
+            catch(:skip) do
+              throw(:skip) if middlewares(builder).include?(middleware)
+
+              yield(wrapped, use)
+            end
+          end
+
+          def self.include_middleware?(middleware, builder)
+            middlewares(builder).include?(middleware)
+          end
+
+          # Introspect middlewares from a builder
+          def self.middlewares(builder)
+            builder.instance_variable_get(:@use).map do |proc_|
+              next :unknown unless proc_.respond_to?(:binding) && proc_.binding.local_variable_defined?(:middleware)
+
+              proc_.binding.local_variable_get(:middleware)
+            end
+          end
+
+          def self.inspect_middlewares(builder)
+            Datadog.logger.debug { 'Sinatra middlewares: ' << middlewares(builder).map(&:inspect).inspect }
+          end
+        end
+      end
+    end
+  end
+end