ddtrace 0.38.0

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

@@ -0,0 +1,34 @@
+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 :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
+            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 :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

@@ -0,0 +1,58 @@
+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)
+          env[Ext::RACK_ENV_REQUEST_SPAN]
+        end
+
+        def set_datadog_span(env, span)
+          env[Ext::RACK_ENV_REQUEST_SPAN] = span
+        end
+
+        def request_header_tags(env, headers)
+          headers ||= []
+
+          {}.tap do |result|
+            headers.each do |header|
+              rack_header = header_to_rack_header(header)
+              if env.key?(rack_header)
+                result[Datadog::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header]
+              end
+            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

@@ -0,0 +1,24 @@
+module Datadog
+  module Contrib
+    module Sinatra
+      # Sinatra integration constants
+      module Ext
+        APP = 'sinatra'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_SINATRA_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = '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

@@ -0,0 +1,31 @@
+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 }
+                if matching_header
+                  result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,28 @@
+require 'ddtrace/contrib/patcher'
+
+module Datadog
+  module Contrib
+    module Sinatra
+      # Patcher enables patching of 'sinatra' module.
+      module Patcher
+        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.send(:prepend, Sinatra::Tracer::Base)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+require 'sinatra/base'
+
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/errors'
+require 'ddtrace/ext/http'
+require 'ddtrace/propagation/http_propagator'
+
+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.after do
+            configuration = Datadog.configuration[:sinatra]
+            next unless configuration[:tracer].enabled
+
+            # Ensures we only create a span for the top-most Sinatra middleware.
+            #
+            # If we traced all Sinatra middleware apps, we would have a chain
+            # of nested spans that were not responsible for handling this request,
+            # adding little value to users.
+            next if Sinatra::Env.middleware_traced?(env)
+
+            span = Sinatra::Env.datadog_span(env) || Sinatra::Tracer.create_middleware_span(env, configuration)
+
+            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(Datadog::Ext::HTTP::URL, request.path)
+            span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
+            span.set_tag(Ext::TAG_APP_NAME, app.settings.name)
+            span.set_tag(Ext::TAG_ROUTE_PATH, route)
+            if request.script_name && !request.script_name.empty?
+              span.set_tag(Ext::TAG_SCRIPT_NAME, request.script_name)
+            end
+
+            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
+            span.set_error(env['sinatra.error']) if response.server_error?
+
+            Sinatra::Env.set_middleware_traced(env, true)
+          end
+        end
+
+        # Initializes a span for the top-most Sinatra middleware.
+        def self.create_middleware_span(env, configuration)
+          tracer = configuration[:tracer]
+          span = tracer.trace(
+            Ext::SPAN_REQUEST,
+            service: configuration[:service_name],
+            span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
+            start_time: Sinatra::Env.middleware_start_time(env)
+          )
+
+          Sinatra::Env.set_datadog_span(env, span)
+          span
+        end
+
+        # Method overrides for Sinatra::Base
+        module Base
+          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
+
+            # For initialization of Sinatra middleware span in order
+            # guarantee that the Ext::SPAN_ROUTE span being created below
+            # has the middleware span as its parent.
+            Sinatra::Tracer.create_middleware_span(env, configuration) unless Sinatra::Env.datadog_span(env)
+
+            tracer.trace(
+              Ext::SPAN_ROUTE,
+              service: configuration[:service_name],
+              span_type: Datadog::Ext::HTTP::TYPE_INBOUND
+            ) do |span|
+              span.resource = "#{request.request_method} #{@datadog_route}"
+
+              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
+
+              rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
+              rack_request_span.resource = span.resource if rack_request_span
+
+              Contrib::Analytics.set_measured(span)
+
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+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)
+          @app = app
+        end
+
+        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
+
+          Sinatra::Env.set_middleware_start_time(env)
+
+          # Run application stack
+          response = @app.call(env)
+        ensure
+          # Augment current Sinatra middleware span if we are the top-most Sinatra app on the Rack stack.
+          span = Sinatra::Env.datadog_span(env)
+          if span
+            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
+
+            if response && (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
+
+            # Set analytics sample rate
+            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
+            span.finish
+
+            # Remove span from env, so other Sinatra apps mounted on this same
+            # Rack stack do not modify it with their own information.
+            Sinatra::Env.set_datadog_span(env, nil)
+          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