ddtrace 0.35.2 → 1.1.0

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

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

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

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

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

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

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

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

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

@@ -1,25 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/sucker_punch/ext'
-
-module Datadog
-  module Contrib
-    module SuckerPunch
-      module Configuration
-        # Custom settings for the SuckerPunch integration
-        class Settings < Contrib::Configuration::Settings
-          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, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/sucker_punch/exception_handler.rb

@@ -1,26 +0,0 @@
-require 'sucker_punch'
-
-module Datadog
-  module Contrib
-    module SuckerPunch
-      # Patches `sucker_punch` exception handling
-      module ExceptionHandler
-        METHOD = ->(e, *) { raise(e) }
-
-        module_function
-
-        def patch!
-          ::SuckerPunch.class_eval do
-            class << self
-              alias_method :__exception_handler, :exception_handler
-
-              def exception_handler
-                ::Datadog::Contrib::SuckerPunch::ExceptionHandler::METHOD
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-module Datadog
-  module Contrib
-    module SuckerPunch
-      # SuckerPunch integration constants
-      module Ext
-        APP = 'sucker_punch'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_SUCKER_PUNCH_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_SUCKER_PUNCH_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'sucker_punch'.freeze
-        SPAN_PERFORM = 'sucker_punch.perform'.freeze
-        SPAN_PERFORM_ASYNC = 'sucker_punch.perform_async'.freeze
-        SPAN_PERFORM_IN = 'sucker_punch.perform_in'.freeze
-        TAG_PERFORM_IN = 'sucker_punch.perform_in'.freeze
-        TAG_QUEUE = 'sucker_punch.queue'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/sucker_punch/instrumentation.rb

@@ -1,84 +0,0 @@
-require 'sucker_punch'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/sucker_punch/ext'
-
-module Datadog
-  module Contrib
-    module SuckerPunch
-      # Defines instrumentation patches for the `sucker_punch` gem
-      module Instrumentation
-        module_function
-
-        # rubocop:disable Metrics/MethodLength
-        def patch!
-          # rubocop:disable Metrics/BlockLength
-          ::SuckerPunch::Job::ClassMethods.class_eval do
-            alias_method :__run_perform_without_datadog, :__run_perform
-            def __run_perform(*args)
-              pin = Datadog::Pin.get_from(::SuckerPunch)
-              pin.tracer.provider.context = Datadog::Context.new
-
-              __with_instrumentation(Ext::SPAN_PERFORM) do |span|
-                span.resource = "PROCESS #{self}"
-
-                # Set analytics sample rate
-                if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
-                  Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
-                end
-
-                # Measure service stats
-                Contrib::Analytics.set_measured(span)
-
-                __run_perform_without_datadog(*args)
-              end
-            rescue => e
-              ::SuckerPunch.__exception_handler.call(e, self, args)
-            end
-
-            alias_method :__perform_async, :perform_async
-            def perform_async(*args)
-              __with_instrumentation(Ext::SPAN_PERFORM_ASYNC) do |span|
-                span.resource = "ENQUEUE #{self}"
-
-                # Measure service stats
-                Contrib::Analytics.set_measured(span)
-
-                __perform_async(*args)
-              end
-            end
-
-            alias_method :__perform_in, :perform_in
-            def perform_in(interval, *args)
-              __with_instrumentation(Ext::SPAN_PERFORM_IN) do |span|
-                span.resource = "ENQUEUE #{self}"
-                span.set_tag(Ext::TAG_PERFORM_IN, interval)
-
-                # Measure service stats
-                Contrib::Analytics.set_measured(span)
-
-                __perform_in(interval, *args)
-              end
-            end
-
-            private
-
-            def datadog_configuration
-              Datadog.configuration[:sucker_punch]
-            end
-
-            def __with_instrumentation(name)
-              pin = Datadog::Pin.get_from(::SuckerPunch)
-
-              pin.tracer.trace(name) do |span|
-                span.service = pin.service
-                span.span_type = pin.app_type
-                span.set_tag(Ext::TAG_QUEUE, to_s)
-                yield span
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/sucker_punch/configuration/settings'
-require 'ddtrace/contrib/sucker_punch/patcher'
-
-module Datadog
-  module Contrib
-    module SuckerPunch
-      # Description of SuckerPunch integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('2.0.0')
-
-        register_as :sucker_punch, auto_patch: true
-
-        def self.version
-          Gem.loaded_specs['sucker_punch'] && Gem.loaded_specs['sucker_punch'].version
-        end
-
-        def self.loaded?
-          !defined?(::SuckerPunch).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