datadog 2.0.0.beta1

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require_relative '../../metadata/ext'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Sinatra
+        # Gets and sets trace information from a Rack Env
+        module Env
+          module_function
+
+          def datadog_span(env)
+            env[Ext::RACK_ENV_SINATRA_REQUEST_SPAN]
+          end
+
+          def set_datadog_span(env, span)
+            env[Ext::RACK_ENV_SINATRA_REQUEST_SPAN] = span
+          end
+
+          def route_path(env, use_script_names: Datadog.configuration.tracing[:sinatra][:resource_script_names])
+            return unless env['sinatra.route']
+
+            _, path = env['sinatra.route'].split(' ', 2)
+            if use_script_names
+              env['SCRIPT_NAME'].to_s + path
+            else
+              path
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+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/integration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+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,75 @@
+# frozen_string_literal: 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 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::Base.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,86 @@
+# frozen_string_literal: true
+
+require 'sinatra/base'
+
+require_relative '../../../core/utils/only_once'
+require_relative '../../metadata/ext'
+require_relative '../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 self.registered(app)
+            app.use TracerMiddleware, app_instance: app
+          end
+
+          # Method overrides for Sinatra::Base
+          module Base
+            def render(engine, data, *)
+              return super unless Tracing.enabled?
+
+              Tracing.trace(Ext::SPAN_RENDER_TEMPLATE, 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.
+            def route_eval
+              configuration = Datadog.configuration.tracing[:sinatra]
+              return super unless Tracing.enabled?
+
+              datadog_route = Sinatra::Env.route_path(env)
+
+              Tracing.trace(
+                Ext::SPAN_ROUTE,
+                service: configuration[:service_name],
+                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 = Sinatra::Env.datadog_span(env)
+
+                sinatra_request_span.resource = span.resource
+
+                Contrib::Analytics.set_measured(span)
+
+                super
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative '../rack/ext'
+require_relative '../rack/header_tagging'
+require_relative 'env'
+require_relative 'ext'
+
+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/MethodLength
+          def call(env)
+            # Find out if this is Sinatra within Sinatra
+            return @app.call(env) if Sinatra::Env.datadog_span(env)
+
+            Tracing.trace(
+              Ext::SPAN_REQUEST,
+              service: configuration[:service_name],
+              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, span)
+
+                response = @app.call(env)
+              ensure
+                Contrib::Rack::HeaderTagging.tag_request_headers(span, env, configuration)
+
+                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)
+
+                datadog_route = Sinatra::Env.route_path(env)
+
+                span.set_tag(Ext::TAG_ROUTE_PATH, datadog_route) if datadog_route
+
+                if request.script_name && !request.script_name.empty?
+                  span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name)
+                end
+
+                # 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])
+                    Contrib::Rack::HeaderTagging.tag_response_headers(span, headers, configuration)
+                  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/MethodLength
+
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+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.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :service_name
+
+            option :on_error do |o|
+              o.type :proc, nilable: true
+            end
+
+            option :tag_body, default: false, type: :bool
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+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'
+          # @!visibility private
+          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'
+          TAG_MESSAGING_SYSTEM = 'rabbitmq'
+          TAG_RABBITMQ_ROUTING_KEY = 'messaging.rabbitmq.routing_key'
+        end
+      end
+    end
+  end
+end

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

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