datadog 2.0.0.beta1

data/lib/datadog/tracing/contrib/sidekiq/distributed/propagation.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../../../distributed/fetcher'
+require_relative '../../../distributed/propagation'
+require_relative '../../../distributed/b3_multi'
+require_relative '../../../distributed/b3_single'
+require_relative '../../../distributed/datadog'
+require_relative '../../../distributed/none'
+require_relative '../../../distributed/trace_context'
+require_relative '../../../configuration/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sidekiq
+        module Distributed
+          # Extracts and injects propagation through HTTP headers.
+          class Propagation < Tracing::Distributed::Propagation
+            def initialize(
+              propagation_style_inject:,
+              propagation_style_extract:,
+              propagation_extract_first:
+            )
+              super(
+                propagation_styles: {
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER =>
+                    Tracing::Distributed::B3Multi.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER =>
+                    Tracing::Distributed::B3Single.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG =>
+                    Tracing::Distributed::Datadog.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
+                    Tracing::Distributed::TraceContext.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
+                },
+                propagation_style_inject: propagation_style_inject,
+                propagation_style_extract: propagation_style_extract,
+                propagation_extract_first: propagation_extract_first
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# 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'
+          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,61 @@
+# frozen_string_literal: true
+
+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.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.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.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.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.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.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.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,88 @@
+# 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
+
+          def initialize(options = {})
+            @sidekiq_service = options[:service_name] || configuration[:service_name]
+            @on_error = options[:on_error] || configuration[:on_error]
+            @distributed_tracing = options[:distributed_tracing] || configuration[:distributed_tracing]
+            @quantize = options[:quantize] || configuration[:quantize]
+          end
+
+          def call(worker, job, queue)
+            resource = job_resource(job)
+
+            if @distributed_tracing
+              trace_digest = Sidekiq.extract(job)
+              Datadog::Tracing.continue_trace!(trace_digest)
+            end
+
+            Datadog::Tracing.trace(
+              Ext::SPAN_JOB,
+              service: @sidekiq_service,
+              type: Datadog::Tracing::Metadata::Ext::AppTypes::TYPE_WORKER,
+              on_error: @on_error
+            ) 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?
+                span.set_tag(Ext::TAG_JOB_ARGS, Contrib::Utils::Quantization::Hash.format(args, (@quantize[:args] || {})))
+              end
+
+              yield
+            end
+          end
+
+          private
+
+          def propagation
+            @propagation ||= Contrib::Sidekiq::Distributed::Propagation.new
+          end
+
+          def configuration
+            Datadog.configuration.tracing[:sidekiq]
+          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/sidekiq.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'component'
+require_relative 'sidekiq/integration'
+require_relative 'sidekiq/distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # `Sidekiq` integration public API
+      module Sidekiq
+        def self.inject(digest, data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.inject!(digest, data)
+        end
+
+        def self.extract(data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.extract(data)
+        end
+
+        Contrib::Component.register('sidekiq') do |config|
+          tracing = config.tracing
+          tracing.propagation_style # TODO: do we still need this?
+
+          @propagation = Sidekiq::Distributed::Propagation.new(
+            propagation_style_inject: tracing.propagation_style_inject,
+            propagation_style_extract: tracing.propagation_style_extract,
+            propagation_extract_first: tracing.propagation_extract_first
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+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