ddtrace 0.54.2 → 1.0.0

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

@@ -0,0 +1,77 @@
+# typed: true
+
+require 'datadog/core/utils/only_once'
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/rack/middlewares'
+require 'datadog/tracing/contrib/sinatra/framework'
+require 'datadog/tracing/contrib/sinatra/integration'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sinatra
+        # Set tracer configuration at a late enough time
+        module TracerSetupPatch
+          ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Core::Utils::OnlyOnce.new }
+
+          def setup_middleware(*args, &block)
+            super.tap do
+              ONLY_ONCE_PER_APP[self].run do
+                Contrib::Sinatra::Framework.setup
+              end
+            end
+          end
+        end
+
+        # Hook into builder before the middleware list gets frozen
+        module DefaultMiddlewarePatch
+          ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Core::Utils::OnlyOnce.new }
+
+          def setup_middleware(*args, &block)
+            builder = args.first
+
+            super.tap do
+              ONLY_ONCE_PER_APP[self].run do
+                Contrib::Sinatra::Framework.add_middleware(Contrib::Rack::TraceMiddleware, builder)
+                Contrib::Sinatra::Framework.inspect_middlewares(builder)
+              end
+            end
+          end
+        end
+
+        # 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 'datadog/tracing/contrib/sinatra/tracer'
+            register_tracer
+
+            patch_default_middlewares
+            setup_tracer
+          end
+
+          def register_tracer
+            ::Sinatra.send(:register, Contrib::Sinatra::Tracer)
+            ::Sinatra::Base.prepend(Sinatra::Tracer::Base)
+          end
+
+          def setup_tracer
+            ::Sinatra::Base.singleton_class.prepend(TracerSetupPatch)
+          end
+
+          def patch_default_middlewares
+            ::Sinatra::Base.singleton_class.prepend(DefaultMiddlewarePatch)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+# typed: false
+
+require 'sinatra/base'
+
+require 'datadog/core/utils/only_once'
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/propagation/http'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/sinatra/env'
+require 'datadog/tracing/contrib/sinatra/ext'
+require 'datadog/tracing/contrib/sinatra/tracer_middleware'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sinatra
+        # Datadog::Tracing::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.tracing[: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
+              next unless Tracing.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 = Core::Utils::OnlyOnce.new
+            private_constant :MISSING_REQUEST_SPAN_ONLY_ONCE
+
+            def render(engine, data, *)
+              return super unless Tracing.enabled?
+
+              Tracing.trace(Ext::SPAN_RENDER_TEMPLATE, span_type: Tracing::Metadata::Ext::HTTP::TYPE_TEMPLATE) do |span|
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_RENDER_TEMPLATE)
+
+                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.
+            # rubocop:disable Metrics/MethodLength
+            def route_eval
+              configuration = Datadog.configuration.tracing[:sinatra]
+              return super unless Tracing.enabled?
+
+              Tracing.trace(
+                Ext::SPAN_ROUTE,
+                service: configuration[:service_name],
+                span_type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND,
+                resource: "#{request.request_method} #{@datadog_route}",
+              ) do |span, trace|
+                span.set_tag(Ext::TAG_APP_NAME, settings.name || settings.superclass.name)
+                span.set_tag(Ext::TAG_ROUTE_PATH, @datadog_route)
+                if request.script_name && !request.script_name.empty?
+                  span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name)
+                end
+
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ROUTE)
+
+                trace.resource = span.resource
+
+                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::Tracing::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
+            # rubocop:enable Metrics/MethodLength
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# typed: false
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/rack/ext'
+require 'datadog/tracing/contrib/sinatra/env'
+require 'datadog/tracing/contrib/sinatra/ext'
+require 'datadog/tracing/contrib/sinatra/headers'
+
+module Datadog
+  module Tracing
+    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] && Tracing.active_trace.nil?
+              original_trace = Propagation::HTTP.extract(env)
+              Tracing.continue_trace!(original_trace)
+            end
+
+            Tracing.trace(
+              Ext::SPAN_REQUEST,
+              service: configuration[:service_name],
+              span_type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND
+            ) do |span|
+              begin
+                # 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
+                span.resource = nil
+
+                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
+
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
+
+                request = ::Sinatra::Request.new(env)
+                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, request.path)
+                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, request.request_method)
+                if request.script_name && !request.script_name.empty?
+                  span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name)
+                end
+
+                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?
+
+                rack_request_span = env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]
+
+                # This propagates the Sinatra resource to the Rack span,
+                # since the latter is unaware of what the resource might be
+                # and would fallback to a generic resource name when unset
+                rack_request_span.resource ||= span.resource if rack_request_span
+
+                if response
+                  if (status = response[0])
+                    sinatra_response = ::Sinatra::Response.new([], status) # Build object to use status code helpers
+
+                    span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_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
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/MethodLength
+          # rubocop:enable Metrics/CyclomaticComplexity
+          # rubocop:enable Metrics/PerceivedComplexity
+
+          private
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            configuration[:analytics_sample_rate]
+          end
+
+          def configuration
+            Datadog.configuration.tracing[:sinatra]
+          end
+
+          def header_to_rack_header(name)
+            "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# typed: false
+
+require 'datadog/tracing/span_operation'
+require 'datadog/tracing/contrib/configuration/settings'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sneakers
+        module Configuration
+          # Default settings for the Shoryuken integration
+          class Settings < Contrib::Configuration::Settings
+            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, false) }
+              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 :service_name
+            option :error_handler, default: Tracing::SpanOperation::Events::DEFAULT_ON_ERROR
+            option :tag_body, default: false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sneakers
+        # Sneakers integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_SNEAKERS_ENABLED'
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_SNEAKERS_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_SNEAKERS_ANALYTICS_SAMPLE_RATE'
+          SERVICE_NAME = 'sneakers'
+          SPAN_JOB = 'sneakers.job'
+          TAG_JOB_ROUTING_KEY = 'sneakers.routing_key'
+          TAG_JOB_QUEUE = 'sneakers.queue'
+          TAG_JOB_BODY = 'sneakers.body'
+          TAG_COMPONENT = 'sneakers'
+          TAG_OPERATION_JOB = 'job'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# typed: false
+
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/sneakers/ext'
+require 'datadog/tracing/contrib/sneakers/configuration/settings'
+require 'datadog/tracing/contrib/sneakers/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sneakers
+        # Description of Sneakers integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('2.12.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :sneakers, auto_patch: true
+
+          def self.version
+            Gem.loaded_specs['sneakers'] && Gem.loaded_specs['sneakers'].version
+          end
+
+          def self.loaded?
+            !defined?(::Sneakers).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# typed: false
+
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/sneakers/integration'
+require 'datadog/tracing/contrib/sneakers/tracer'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sneakers
+        # Patcher enables patching of 'sneakers' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            ::Sneakers.middleware.use(Sneakers::Tracer, nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/sneakers/tracer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# typed: true
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sneakers
+        # Tracer is a Sneakers server-side middleware which traces executed jobs
+        class Tracer
+          def initialize(app, *args)
+            @app = app
+            @args = args
+          end
+
+          def call(deserialized_msg, delivery_info, metadata, handler)
+            trace_options = {
+              service: configuration[:service_name],
+              span_type: Tracing::Metadata::Ext::AppTypes::TYPE_WORKER,
+              on_error: configuration[:error_handler]
+            }
+
+            Tracing.trace(Ext::SPAN_JOB, **trace_options) do |request_span|
+              request_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              request_span.set_tag(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(request_span, configuration[:analytics_sample_rate])
+              end
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(request_span)
+
+              request_span.resource = @app.to_proc.binding.eval('self.class').to_s
+              request_span.set_tag(Ext::TAG_JOB_ROUTING_KEY, delivery_info.routing_key)
+              request_span.set_tag(Ext::TAG_JOB_QUEUE, delivery_info.consumer.queue.name)
+
+              request_span.set_tag(Ext::TAG_JOB_BODY, deserialized_msg) if configuration[:tag_body]
+
+              @app.call(deserialized_msg, delivery_info, metadata, handler)
+            end
+          end
+
+          private
+
+          def configuration
+            Datadog.configuration.tracing[:sneakers]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/status_code_matcher.rb

@@ -0,0 +1,75 @@
+# typed: true
+
+require 'set'
+
+require 'datadog/core'
+require 'datadog/tracing/metadata/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Contains methods helpful for tracing/annotating HTTP request libraries
+      class StatusCodeMatcher
+        REGEX_PARSER = /^\d{3}(?:-\d{3})?(?:,\d{3}(?:-\d{3})?)*$/.freeze
+
+        def initialize(range)
+          @error_response_range = range
+          set_range
+        end
+
+        def include?(exception_status)
+          set_range.include?(exception_status)
+        end
+
+        def to_s
+          @error_response_range.to_s
+        end
+
+        private
+
+        def set_range
+          @datadog_set ||= begin
+            set = Set.new
+            handle_statuses.each do |statuses|
+              status = statuses.to_s.split('-')
+              case status.length
+              when 1
+                set.add(Integer(status[0]))
+              when 2
+                min, max = status.minmax
+                Array(min..max).each do |i|
+                  set.add(Integer(i))
+                end
+              end
+            end
+            set
+          end
+          @datadog_set
+        end
+
+        def error_responses
+          return @error_response_range if @error_response_range.is_a?(String) && !@error_response_range.nil?
+
+          @error_response_range.join(',') if @error_response_range.is_a?(Array) && !@error_response_range.empty?
+        end
+
+        def handle_statuses
+          if error_responses
+            filter_error_responses = error_responses.gsub(/\s+/, '').split(',').select do |code|
+              if !code.to_s.match(REGEX_PARSER)
+                Datadog.logger.debug("Invalid config provided: #{code}. Must be formatted like '400-403,405,410-499'.")
+                next
+              else
+                true
+              end
+            end
+            filter_error_responses.empty? ? Tracing::Metadata::Ext::HTTP::ERROR_RANGE.to_a : filter_error_responses
+          else
+            Datadog.logger.debug('No valid config was provided for :error_statuses - falling back to default.')
+            Tracing::Metadata::Ext::HTTP::ERROR_RANGE.to_a
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# typed: false
+
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/sucker_punch/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module SuckerPunch
+        module Configuration
+          # Custom settings for the SuckerPunch integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            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, false) }
+              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 :service_name
+          end
+        end
+      end
+    end
+  end
+end