ddtrace 0.34.1 → 1.23.1

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.log.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,38 +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
-      end
-    end
-  end
-end

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

@@ -1,18 +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
-        SERVICE_NAME = 'sinatra'.freeze
-        SPAN_RENDER_TEMPLATE = 'sinatra.render_template'.freeze
-        SPAN_REQUEST = 'sinatra.request'.freeze
-        TAG_ROUTE_PATH = 'sinatra.route.path'.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,27 +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)
-        end
-      end
-    end
-  end
-end

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

@@ -1,87 +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.
-            @datadog_route = if Datadog.configuration[:sinatra][:resource_script_names]
-                               "#{request.script_name}#{action}"
-                             else
-                               action
-                             end
-          end
-
-          super
-        end
-
-        def self.registered(app)
-          ::Sinatra::Base.module_eval do
-            def render(engine, data, *)
-              output = ''
-              tracer = Datadog.configuration[:sinatra][:tracer]
-              if tracer.enabled
-                tracer.trace(Ext::SPAN_RENDER_TEMPLATE, span_type: Datadog::Ext::HTTP::TEMPLATE) do |span|
-                  # 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)
-
-                  output = super
-                end
-              else
-                output = super
-              end
-
-              output
-            end
-          end
-
-          app.use TracerMiddleware
-
-          app.before do
-            return unless Datadog.configuration[:sinatra][:tracer].enabled
-
-            span = Sinatra::Env.datadog_span(env)
-            span.set_tag(Datadog::Ext::HTTP::URL, request.path)
-            span.set_tag(Datadog::Ext::HTTP::METHOD, request.request_method)
-          end
-
-          app.after do
-            return unless Datadog.configuration[:sinatra][:tracer].enabled
-
-            span = Sinatra::Env.datadog_span(env)
-
-            unless span
-              Datadog::Logger.log.error('missing request span in :after hook')
-              return
-            end
-
-            span.resource = "#{request.request_method} #{@datadog_route}"
-            span.set_tag(Ext::TAG_ROUTE_PATH, @datadog_route)
-            span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.status)
-            span.set_error(env['sinatra.error']) if response.server_error?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +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
-
-          # Begin the trace
-          tracer.trace(
-            Ext::SPAN_REQUEST,
-            service: configuration[:service_name],
-            span_type: Datadog::Ext::HTTP::TYPE_INBOUND
-          ) do |span|
-            Sinatra::Env.set_datadog_span(env, 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
-
-            # Run application stack
-            status, headers, response_body = @app.call(env)
-
-            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
-
-            # Set analytics sample rate
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
-
-            # Measure service stats
-            Contrib::Analytics.set_measured(span)
-
-            [status, headers, response_body]
-          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

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

@@ -1,42 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/sucker_punch/ext'
-
-module Datadog
-  module Contrib
-    module SuckerPunch
-      # Patcher enables patching of 'sucker_punch' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          require 'ddtrace/contrib/sucker_punch/exception_handler'
-          require 'ddtrace/contrib/sucker_punch/instrumentation'
-
-          add_pin!
-          ExceptionHandler.patch!
-          Instrumentation.patch!
-        end
-
-        def add_pin!
-          Pin.new(
-            get_option(:service_name),
-            app: Ext::APP,
-            app_type: Datadog::Ext::AppTypes::WORKER,
-            tracer: get_option(:tracer)
-          ).onto(::SuckerPunch)
-        end
-
-        def get_option(option)
-          Datadog.configuration[:sucker_punch].get_option(option)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/correlation.rb

@@ -1,35 +0,0 @@
-require 'ddtrace/ext/correlation'
-require 'ddtrace/environment'
-
-module Datadog
-  # Contains behavior for managing correlations with tracing
-  # e.g. Retrieve a correlation to the current trace for logging, etc.
-  module Correlation
-    # Struct representing correlation
-    Identifier = Struct.new(:trace_id, :span_id, :env, :version) do
-      def initialize(*args)
-        super
-        self.trace_id = trace_id || 0
-        self.span_id = span_id || 0
-        self.env = env || Datadog.configuration.env
-        self.version = version || Datadog.configuration.version
-      end
-
-      def to_s
-        str =  "#{Ext::Correlation::ATTR_TRACE_ID}=#{trace_id}"
-        str += " #{Ext::Correlation::ATTR_SPAN_ID}=#{span_id}"
-        str += " #{Ext::Correlation::ATTR_ENV}=#{env}"
-        str += " #{Ext::Correlation::ATTR_VERSION}=#{version}"
-        str
-      end
-    end.freeze
-
-    module_function
-
-    # Produces a CorrelationIdentifier from the Context provided
-    def identifier_from_context(context)
-      return Identifier.new.freeze if context.nil?
-      Identifier.new(context.trace_id, context.span_id).freeze
-    end
-  end
-end