ddtrace 0.54.2 → 1.0.0

data/lib/ddtrace/contrib/sidekiq/server_internal_tracer/job_fetch.rb

@@ -1,30 +0,0 @@
-# typed: true
-
-module Datadog
-  module Contrib
-    module Sidekiq
-      module ServerInternalTracer
-        # Trace when Sidekiq looks for another job to work
-        module JobFetch
-          private
-
-          def fetch
-            configuration = Datadog.configuration[:sidekiq]
-
-            configuration[:tracer].trace(Ext::SPAN_JOB_FETCH) do |span|
-              span.service = configuration[:service_name]
-              span.span_type = Datadog::Ext::AppTypes::WORKER
-
-              # 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

data/lib/ddtrace/contrib/sidekiq/server_internal_tracer/scheduled_push.rb

@@ -1,29 +0,0 @@
-# typed: true
-
-module Datadog
-  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[:sidekiq]
-
-            configuration[:tracer].trace(Ext::SPAN_SCHEDULED_PUSH) do |span|
-              span.service = configuration[:service_name]
-              span.span_type = Datadog::Ext::AppTypes::WORKER
-
-              # 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

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

@@ -1,66 +0,0 @@
-# typed: true
-require 'ddtrace/contrib/sidekiq/tracing'
-require 'ddtrace/contrib/analytics'
-
-module Datadog
-  module Contrib
-    module Sidekiq
-      # Tracer is a Sidekiq server-side middleware which traces executed jobs
-      class ServerTracer
-        include Tracing
-
-        def initialize(options = {})
-          super
-          @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
-          tag_args = worker_config(resource, :tag_args) || configuration[:tag_args]
-
-          @tracer.trace(Ext::SPAN_JOB, service: service, span_type: Datadog::Ext::AppTypes::WORKER,
-                                       on_error: @error_handler) do |span|
-            span.resource = resource
-            # 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))
-            span.set_tag(Ext::TAG_JOB_ARGS, job['args']) if tag_args && !job['args'].nil? && !job['args'].empty?
-
-            yield
-          end
-        end
-
-        private
-
-        def configuration
-          Datadog.configuration[:sidekiq]
-        end
-
-        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

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

@@ -1,45 +0,0 @@
-# typed: true
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/sidekiq/ext'
-
-require 'yaml'
-
-module Datadog
-  module Contrib
-    module Sidekiq
-      # Common functionality used by both client-side and server-side tracers.
-      module Tracing
-        def initialize(options = {})
-          @tracer = options[:tracer] || Datadog.configuration[:sidekiq][:tracer]
-        end
-
-        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

data/lib/ddtrace/contrib/sinatra/configuration/settings.rb

@@ -1,40 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/sinatra/ext'
-
-module Datadog
-  module Contrib
-    module Sinatra
-      module Configuration
-        # Custom settings for the Sinatra integration
-        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, Ext::ENV_ANALYTICS_ENABLED_OLD], nil) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-
-          option :distributed_tracing, default: true
-          option :headers, default: DEFAULT_HEADERS
-          option :resource_script_names, default: false
-
-          option :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/sinatra/env.rb

@@ -1,59 +0,0 @@
-# typed: true
-require 'ddtrace/ext/http'
-require 'ddtrace/contrib/sinatra/ext'
-
-module Datadog
-  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)
-              result[Datadog::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header] if env.key?(rack_header)
-            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

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

@@ -1,28 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module Sinatra
-      # Sinatra integration constants
-      module Ext
-        APP = 'sinatra'.freeze
-        ENV_ENABLED = 'DD_TRACE_SINATRA_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_SINATRA_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_SINATRA_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SINATRA_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_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
-        SERVICE_NAME = 'sinatra'.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_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

data/lib/ddtrace/contrib/sinatra/headers.rb

@@ -1,30 +0,0 @@
-# typed: true
-require 'ddtrace/ext/http'
-
-module Datadog
-  module Contrib
-    module Sinatra
-      # Gets and sets trace information from a Rack headers Hash
-      module Headers
-        module_function
-
-        def response_header_tags(headers, target_headers)
-          target_headers ||= []
-
-          {}.tap do |result|
-            target_headers.each do |header|
-              if headers.key?(header)
-                result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[header]
-              else
-                # Try a case-insensitive lookup
-                uppercased_header = header.to_s.upcase
-                matching_header = headers.keys.find { |h| h.upcase == uppercased_header }
-                result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header] if matching_header
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/sinatra/configuration/settings'
-require 'ddtrace/contrib/sinatra/patcher'
-
-module Datadog
-  module Contrib
-    module Sinatra
-      # Description of Sinatra integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('1.4')
-
-        register_as :sinatra
-
-        def self.version
-          Gem.loaded_specs['sinatra'] && Gem.loaded_specs['sinatra'].version
-        end
-
-        def self.loaded?
-          !defined?(::Sinatra).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# typed: true
-require 'ddtrace/contrib/patcher'
-
-module Datadog
-  module Contrib
-    module Sinatra
-      # Patcher enables patching of 'sinatra' module.
-      module Patcher
-        include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          require 'ddtrace/contrib/sinatra/tracer'
-          register_tracer
-        end
-
-        def register_tracer
-          ::Sinatra.send(:register, Datadog::Contrib::Sinatra::Tracer)
-          ::Sinatra::Base.prepend(Sinatra::Tracer::Base)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/sinatra/tracer.rb

@@ -1,150 +0,0 @@
-# typed: false
-require 'sinatra/base'
-
-require 'ddtrace/ext/app_types'
-require 'ddtrace/ext/errors'
-require 'ddtrace/ext/http'
-require 'ddtrace/propagation/http_propagator'
-require 'ddtrace/utils/only_once'
-require 'ddtrace/contrib/sinatra/ext'
-require 'ddtrace/contrib/sinatra/tracer_middleware'
-require 'ddtrace/contrib/sinatra/env'
-
-module Datadog
-  module Contrib
-    module Sinatra
-      # Datadog::Contrib::Sinatra::Tracer is a Sinatra extension which traces
-      # requests.
-      module Tracer
-        def route(verb, action, *)
-          # Keep track of the route name when the app is instantiated for an
-          # incoming request.
-          condition do
-            # If the option to prepend script names is enabled, then
-            # prepend the script name from the request onto the action.
-            #
-            # DEV: env['sinatra.route'] already exists with very similar information,
-            # DEV: but doesn't account for our `resource_script_names` logic.
-            #
-            @datadog_route = if Datadog.configuration[:sinatra][:resource_script_names]
-                               "#{request.script_name}#{action}"
-                             else
-                               action
-                             end
-          end
-
-          super
-        end
-
-        def self.registered(app)
-          app.use TracerMiddleware, app_instance: app
-
-          app.after do
-            configuration = Datadog.configuration[:sinatra]
-            next unless configuration[:tracer].enabled
-
-            span = Sinatra::Env.datadog_span(env, app)
-
-            # TODO: `route` should *only* be populated if @datadog_route is defined.
-            # TODO: If @datadog_route is not defined, then this Sinatra app is not responsible
-            # TODO: for handling this request.
-            # TODO:
-            # TODO: This change would be BREAKING for any Sinatra app (classic or modular),
-            # TODO: as it affects the `resource` value for requests not handled by the Sinatra app.
-            # TODO: Currently we use "#{method} #{path}" in such aces, but `path` is the raw,
-            # TODO: high-cardinality HTTP path, and can contain PII.
-            # TODO:
-            # TODO: The value we should use as the `resource` when the Sinatra app is not
-            # TODO: responsible for the request is a tricky subject.
-            # TODO: The best option is a value that clearly communicates that this app did not
-            # TODO: handle this request. It's important to keep in mind that an unhandled request
-            # TODO: by this Sinatra app might still be handled by another Rack middleware (which can
-            # TODO: be a Sinatra app itself) or it might just 404 if not handled at all.
-            # TODO:
-            # TODO: A possible value for `resource` could set a high level description, e.g.
-            # TODO: `request.request_method`, given we don't have the response object available yet.
-            route = if defined?(@datadog_route)
-                      @datadog_route
-                    else
-                      # Fallback in case no routes have matched
-                      request.path
-                    end
-
-            span.resource = "#{request.request_method} #{route}"
-            span.set_tag(Ext::TAG_ROUTE_PATH, route)
-          end
-        end
-
-        # Method overrides for Sinatra::Base
-        module Base
-          MISSING_REQUEST_SPAN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
-          private_constant :MISSING_REQUEST_SPAN_ONLY_ONCE
-
-          def render(engine, data, *)
-            tracer = Datadog.configuration[:sinatra][:tracer]
-            return super unless tracer.enabled
-
-            tracer.trace(Ext::SPAN_RENDER_TEMPLATE, span_type: Datadog::Ext::HTTP::TEMPLATE) do |span|
-              span.set_tag(Ext::TAG_TEMPLATE_ENGINE, engine)
-
-              # If data is a string, it is a literal template and we don't
-              # want to record it.
-              span.set_tag(Ext::TAG_TEMPLATE_NAME, data) if data.is_a? Symbol
-
-              # Measure service stats
-              Contrib::Analytics.set_measured(span)
-
-              super
-            end
-          end
-
-          # Invoked when a matching route is found.
-          # This method yields directly to user code.
-          def route_eval
-            configuration = Datadog.configuration[:sinatra]
-            tracer = configuration[:tracer]
-            return super unless tracer.enabled
-
-            tracer.trace(
-              Ext::SPAN_ROUTE,
-              service: configuration[:service_name],
-              span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
-              resource: "#{request.request_method} #{@datadog_route}",
-            ) do |span|
-              span.set_tag(Ext::TAG_APP_NAME, settings.name || settings.superclass.name)
-              span.set_tag(Ext::TAG_ROUTE_PATH, @datadog_route)
-              span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name) if request.script_name && !request.script_name.empty?
-
-              rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
-              rack_request_span.resource = span.resource if rack_request_span
-
-              sinatra_request_span =
-                if self.class <= ::Sinatra::Application # Classic style (top-level) application
-                  Sinatra::Env.datadog_span(env, ::Sinatra::Application)
-                else
-                  Sinatra::Env.datadog_span(env, self.class)
-                end
-              if sinatra_request_span
-                sinatra_request_span.resource = span.resource
-              else
-                MISSING_REQUEST_SPAN_ONLY_ONCE.run do
-                  Datadog.logger.warn do
-                    'Sinatra integration is misconfigured, reported traces will be missing request metadata ' \
-                    'such as path and HTTP status code. ' \
-                    'Did you forget to add `register Datadog::Contrib::Sinatra::Tracer` to your ' \
-                    '`Sinatra::Base` subclass? ' \
-                    'See <https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#sinatra> for more details.'
-                  end
-                end
-              end
-
-              Contrib::Analytics.set_measured(span)
-
-              super
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/sinatra/tracer_middleware.rb

@@ -1,112 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/sinatra/ext'
-require 'ddtrace/contrib/sinatra/env'
-require 'ddtrace/contrib/sinatra/headers'
-
-module Datadog
-  module Contrib
-    module Sinatra
-      # Middleware used for automatically tagging configured headers and handle request span
-      class TracerMiddleware
-        def initialize(app, opt = {})
-          @app = app
-          @app_instance = opt[:app_instance]
-        end
-
-        # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/MethodLength
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/PerceivedComplexity
-        def call(env)
-          # Set the trace context (e.g. distributed tracing)
-          if configuration[:distributed_tracing] && tracer.provider.context.trace_id.nil?
-            context = HTTPPropagator.extract(env)
-            tracer.provider.context = context if context.trace_id
-          end
-
-          tracer.trace(
-            Ext::SPAN_REQUEST,
-            service: configuration[:service_name],
-            span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
-            # this is kept nil until we set a correct one (either in the route or with a fallback in the ensure below)
-            # the nil signals that there's no good one yet and is also seen by profiler, when sampling the resource
-            resource: nil,
-          ) do |span|
-            begin
-              Sinatra::Env.set_datadog_span(env, @app_instance, span)
-
-              response = @app.call(env)
-            ensure
-              Sinatra::Env.request_header_tags(env, configuration[:headers][:request]).each do |name, value|
-                span.set_tag(name, value) if span.get_tag(name).nil?
-              end
-
-              request = ::Sinatra::Request.new(env)
-              span.set_tag(Datadog::Ext::HTTP::URL, request.path)
-              span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
-              span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name) if request.script_name && !request.script_name.empty?
-
-              span.set_tag(Ext::TAG_APP_NAME, @app_instance.settings.name)
-
-              # If this app handled the request, then Contrib::Sinatra::Tracer OR Contrib::Sinatra::Base set the
-              # resource; if no resource was set, let's use a fallback
-              span.resource = env['REQUEST_METHOD'] if span.resource.nil?
-
-              # TODO: This backfills the non-matching Sinatra app with a "#{method} #{path}"
-              # TODO: resource name. This shouldn't be the case, as that app has never handled
-              # TODO: the response with that resource.
-              # TODO: We should replace this backfill code with a clear `resource` that signals
-              # TODO: that this Sinatra span was *not* responsible for processing the current request.
-              rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
-              span.resource = rack_request_span.resource if rack_request_span && rack_request_span.resource
-
-              if response
-                if (status = response[0])
-                  sinatra_response = ::Sinatra::Response.new([], status) # Build object to use status code helpers
-
-                  span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, sinatra_response.status)
-                  span.set_error(env['sinatra.error']) if sinatra_response.server_error?
-                end
-
-                if (headers = response[1])
-                  Sinatra::Headers.response_header_tags(headers, configuration[:headers][:response]).each do |name, value|
-                    span.set_tag(name, value) if span.get_tag(name).nil?
-                  end
-                end
-              end
-
-              # Set analytics sample rate
-              Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
-
-              # Measure service stats
-              Contrib::Analytics.set_measured(span)
-            end
-          end
-        end
-
-        private
-
-        def tracer
-          configuration[:tracer]
-        end
-
-        def analytics_enabled?
-          Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-        end
-
-        def analytics_sample_rate
-          configuration[:analytics_sample_rate]
-        end
-
-        def configuration
-          Datadog.configuration[:sinatra]
-        end
-
-        def header_to_rack_header(name)
-          "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
-        end
-      end
-    end
-  end
-end