ddtrace 0.16.1 → 0.17.0

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

@@ -1,6 +1,7 @@
 require 'sidekiq/api'
 
 require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/sidekiq/ext'
 
 module Datadog
   module Contrib
@@ -8,9 +9,8 @@ module Datadog
       # Tracer is a Sidekiq server-side middleware which traces executed jobs
       class Tracer
         def initialize(options = {})
-          config = Datadog.configuration[:sidekiq].merge(options)
-          @tracer = config[:tracer]
-          @sidekiq_service = config[:service_name]
+          @tracer = options[:tracer] || Datadog.configuration[:sidekiq][:tracer]
+          @sidekiq_service = options[:service_name] || Datadog.configuration[:sidekiq][:service_name]
         end
 
         def call(worker, job, queue)
@@ -26,13 +26,13 @@ module Datadog
           service = sidekiq_service(resource_worker(resource))
           set_service_info(service)
 
-          @tracer.trace('sidekiq.job', service: service, span_type: Datadog::Ext::AppTypes::WORKER) do |span|
+          @tracer.trace(Ext::SPAN_JOB, service: service, span_type: Datadog::Ext::AppTypes::WORKER) do |span|
             span.resource = resource
-            span.set_tag('sidekiq.job.id', job['jid'])
-            span.set_tag('sidekiq.job.retry', job['retry'])
-            span.set_tag('sidekiq.job.queue', job['queue'])
-            span.set_tag('sidekiq.job.wrapper', job['class']) if job['wrapped']
-            span.set_tag('sidekiq.job.delay', 1000.0 * (Time.now.utc.to_f - job['enqueued_at'].to_f))
+            span.set_tag(Ext::TAG_JOB_ID, job['jid'])
+            span.set_tag(Ext::TAG_JOB_RETRY, job['retry'])
+            span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
+            span.set_tag(Ext::TAG_JOB_WRAPPER, job['class']) if job['wrapped']
+            span.set_tag(Ext::TAG_JOB_DELAY, 1000.0 * (Time.now.utc.to_f - job['enqueued_at'].to_f))
 
             yield
           end
@@ -62,7 +62,7 @@ module Datadog
           return if @tracer.services[service]
           @tracer.set_service_info(
             service,
-            'sidekiq',
+            Ext::APP,
             Datadog::Ext::AppTypes::WORKER
           )
         end

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

@@ -0,0 +1,27 @@
+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 :distributed_tracing, default: false
+          option :headers, default: DEFAULT_HEADERS
+          option :resource_script_names, default: false
+
+          option :service_name, default: Ext::SERVICE_NAME, depends_on: [:tracer] do |value|
+            get_option(:tracer).set_service_info(value, Ext::APP, Datadog::Ext::AppTypes::WEB)
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,20 +1,19 @@
 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
-        ENV_SPAN = 'datadog.sinatra_request_span'.freeze
-
         module_function
 
         def datadog_span(env)
-          env[ENV_SPAN]
+          env[Ext::RACK_ENV_REQUEST_SPAN]
         end
 
         def set_datadog_span(env, span)
-          env[ENV_SPAN] = span
+          env[Ext::RACK_ENV_REQUEST_SPAN] = span
         end
 
         def request_header_tags(env, headers)

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

@@ -0,0 +1,19 @@
+module Datadog
+  module Contrib
+    module Sinatra
+      # Sinatra integration constants
+      module Ext
+        APP = 'sinatra'.freeze
+        SERVICE_NAME = 'sinatra'.freeze
+
+        RACK_ENV_REQUEST_SPAN = 'datadog.sinatra_request_span'.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/integration.rb

@@ -0,0 +1,36 @@
+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
+
+        register_as :sinatra
+
+        def self.version
+          Gem.loaded_specs['sinatra'] && Gem.loaded_specs['sinatra'].version
+        end
+
+        def self.present?
+          super && defined?(::Sinatra)
+        end
+
+        def self.compatible?
+          super && version >= Gem::Version.new('1.4.0')
+        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,33 @@
+require 'ddtrace/contrib/patcher'
+
+module Datadog
+  module Contrib
+    module Sinatra
+      # Patcher enables patching of 'sinatra' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:sinatra)
+        end
+
+        def patch
+          do_once(:sinatra) do
+            begin
+              require 'ddtrace/contrib/sinatra/tracer'
+              register_tracer
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Sinatra integration: #{e}")
+            end
+          end
+        end
+
+        def register_tracer
+          ::Sinatra.send(:register, Datadog::Contrib::Sinatra::Tracer)
+        end
+      end
+    end
+  end
+end

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

@@ -5,41 +5,16 @@ 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'
 
-sinatra_vs = Gem::Version.new(Sinatra::VERSION)
-sinatra_min_vs = Gem::Version.new('1.4.0')
-if sinatra_vs < sinatra_min_vs
-  raise "sinatra version #{sinatra_vs} is not supported yet " \
-          + "(supporting versions >=#{sinatra_min_vs})"
-end
-
-Datadog::Tracer.log.info("activating instrumentation for sinatra #{sinatra_vs}")
-
 module Datadog
   module Contrib
     module Sinatra
       # Datadog::Contrib::Sinatra::Tracer is a Sinatra extension which traces
       # requests.
       module Tracer
-        DEFAULT_HEADERS = {
-          response: %w[Content-Type X-Request-ID]
-        }.freeze
-
-        include Base
-        register_as :sinatra
-
-        option :service_name, default: 'sinatra', depends_on: [:tracer] do |value|
-          get_option(:tracer).set_service_info(value, 'sinatra', Ext::AppTypes::WEB)
-          value
-        end
-
-        option :tracer, default: Datadog.tracer
-        option :resource_script_names, default: false
-        option :distributed_tracing, default: false
-        option :headers, default: DEFAULT_HEADERS
-
         def route(verb, action, *)
           # Keep track of the route name when the app is instantiated for an
           # incoming request.
@@ -62,10 +37,10 @@ module Datadog
               output = ''
               tracer = Datadog.configuration[:sinatra][:tracer]
               if tracer.enabled
-                tracer.trace('sinatra.render_template', span_type: Datadog::Ext::HTTP::TEMPLATE) do |span|
+                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('sinatra.template_name', data) if data.is_a? Symbol
+                  span.set_tag(Ext::TAG_TEMPLATE_NAME, data) if data.is_a? Symbol
                   output = super
                 end
               else
@@ -97,7 +72,7 @@ module Datadog
             end
 
             span.resource = "#{request.request_method} #{@datadog_route}"
-            span.set_tag('sinatra.route.path', @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
@@ -106,8 +81,3 @@ module Datadog
     end
   end
 end
-
-# rubocop:disable Style/Documentation
-module Sinatra
-  register Datadog::Contrib::Sinatra::Tracer
-end

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

@@ -1,3 +1,4 @@
+require 'ddtrace/contrib/sinatra/ext'
 require 'ddtrace/contrib/sinatra/env'
 require 'ddtrace/contrib/sinatra/headers'
 
@@ -6,8 +7,6 @@ module Datadog
     module Sinatra
       # Middleware used for automatically tagging configured headers and handle request span
       class TracerMiddleware
-        REQUEST_TRACE_NAME = 'sinatra.request'.freeze
-
         def initialize(app)
           @app = app
         end
@@ -21,7 +20,7 @@ module Datadog
 
           # Begin the trace
           tracer.trace(
-            REQUEST_TRACE_NAME,
+            Ext::SPAN_REQUEST,
             service: configuration[:service_name],
             span_type: Datadog::Ext::HTTP::TYPE
           ) do |span|

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

@@ -0,0 +1,15 @@
+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 :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module SuckerPunch
+      # SuckerPunch integration constants
+      module Ext
+        APP = 'sucker_punch'.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,4 +1,5 @@
 require 'sucker_punch'
+require 'ddtrace/contrib/sucker_punch/ext'
 
 module Datadog
   module Contrib
@@ -15,7 +16,7 @@ module Datadog
               pin = Datadog::Pin.get_from(::SuckerPunch)
               pin.tracer.provider.context = Datadog::Context.new
 
-              __with_instrumentation('sucker_punch.perform') do |span|
+              __with_instrumentation(Ext::SPAN_PERFORM) do |span|
                 span.resource = "PROCESS #{self}"
                 __run_perform_without_datadog(*args)
               end
@@ -25,7 +26,7 @@ module Datadog
 
             alias_method :__perform_async, :perform_async
             def perform_async(*args)
-              __with_instrumentation('sucker_punch.perform_async') do |span|
+              __with_instrumentation(Ext::SPAN_PERFORM_ASYNC) do |span|
                 span.resource = "ENQUEUE #{self}"
                 __perform_async(*args)
               end
@@ -33,9 +34,9 @@ module Datadog
 
             alias_method :__perform_in, :perform_in
             def perform_in(interval, *args)
-              __with_instrumentation('sucker_punch.perform_in') do |span|
+              __with_instrumentation(Ext::SPAN_PERFORM_IN) do |span|
                 span.resource = "ENQUEUE #{self}"
-                span.set_tag('sucker_punch.perform_in', interval)
+                span.set_tag(Ext::TAG_PERFORM_IN, interval)
                 __perform_in(interval, *args)
               end
             end
@@ -48,7 +49,7 @@ module Datadog
               pin.tracer.trace(name) do |span|
                 span.service = pin.service
                 span.span_type = pin.app_type
-                span.set_tag('sucker_punch.queue', to_s)
+                span.set_tag(Ext::TAG_QUEUE, to_s)
                 yield span
               end
             end

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

@@ -0,0 +1,36 @@
+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
+
+        register_as :sucker_punch, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['sucker_punch'] && Gem.loaded_specs['sucker_punch'].version
+        end
+
+        def self.present?
+          super && defined?(::SuckerPunch)
+        end
+
+        def self.compatible?
+          super && Gem::Version.new(::SuckerPunch::VERSION) >= Gem::Version.new('2.0.0')
+        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,53 +1,47 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/sucker_punch/ext'
+
 module Datadog
   module Contrib
     module SuckerPunch
-      SERVICE = 'sucker_punch'.freeze
-      COMPATIBLE_WITH = Gem::Version.new('2.0.0')
-
-      # Responsible for hooking the instrumentation into `sucker_punch`
+      # Patcher enables patching of 'sucker_punch' module.
       module Patcher
-        include Base
-        register_as :sucker_punch, auto_patch: true
-        option :service_name, default: SERVICE
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
-        def patch
-          return @patched if patched? || !compatible?
-
-          require 'ddtrace/ext/app_types'
-          require_relative 'exception_handler'
-          require_relative 'instrumentation'
-
-          add_pin!
-          ExceptionHandler.patch!
-          Instrumentation.patch!
-
-          @patched = true
-        rescue => e
-          Datadog::Tracer.log.error("Unable to apply SuckerPunch integration: #{e}")
-          @patched
-        end
-
         def patched?
-          @patched
+          done?(:sucker_punch)
         end
 
-        def compatible?
-          return unless defined?(::SuckerPunch::VERSION)
-
-          Gem::Version.new(::SuckerPunch::VERSION) >= COMPATIBLE_WITH
+        def patch
+          do_once(:sucker_punch) do
+            begin
+              require 'ddtrace/contrib/sucker_punch/exception_handler'
+              require 'ddtrace/contrib/sucker_punch/instrumentation'
+
+              add_pin!
+              ExceptionHandler.patch!
+              Instrumentation.patch!
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply SuckerPunch integration: #{e}")
+            end
+          end
         end
 
         def add_pin!
-          Pin.new(get_option(:service_name), app: 'sucker_punch', app_type: Ext::AppTypes::WORKER).tap do |pin|
-            pin.onto(::SuckerPunch)
-          end
+          Pin.new(
+            get_option(:service_name),
+            app: Ext::APP,
+            app_type: Datadog::Ext::AppTypes::WORKER,
+            tracer: get_option(:tracer)
+          ).onto(::SuckerPunch)
         end
 
-        private_class_method :compatible?, :add_pin!
+        def get_option(option)
+          Datadog.configuration[:sucker_punch].get_option(option)
+        end
       end
     end
   end