ddtrace 0.54.2 → 1.4.0

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

@@ -0,0 +1,116 @@
+# typed: false
+
+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

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

@@ -0,0 +1,35 @@
+# typed: true
+
+require_relative '../../metadata/ext'
+
+module Datadog
+  module Tracing
+    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[Tracing::Metadata::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 }
+                  if matching_header
+                    result[Tracing::Metadata::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header]
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# typed: false
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sinatra
+        # Description of Sinatra integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('1.4')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          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 new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# typed: true
+
+require_relative '../../../core/utils/only_once'
+require_relative '../patcher'
+require_relative '../rack/middlewares'
+require_relative 'framework'
+
+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_relative '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,158 @@
+# typed: false
+
+require 'sinatra/base'
+
+require_relative '../../../core/utils/only_once'
+require_relative '../../metadata/ext'
+require_relative '../../propagation/http'
+require_relative '../analytics'
+require_relative 'env'
+require_relative 'ext'
+require_relative '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,122 @@
+# typed: false
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative '../rack/ext'
+require_relative 'env'
+require_relative 'ext'
+require_relative '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_relative '../../../span_operation'
+require_relative '../../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_relative '../integration'
+require_relative 'ext'
+require_relative 'configuration/settings'
+require_relative '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,29 @@
+# frozen_string_literal: true
+
+# typed: false
+
+require_relative '../patcher'
+require_relative '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