ddtrace 0.16.1 → 0.17.0

data/lib/ddtrace/contrib/http/circuit_breaker.rb

@@ -0,0 +1,39 @@
+
+module Datadog
+  module Contrib
+    module HTTP
+      # HTTP integration circuit breaker behavior
+      # For avoiding recursive traces.
+      module CircuitBreaker
+        def should_skip_tracing?(req, address, port, transport, pin)
+          # we don't want to trace our own call to the API (they use net/http)
+          # when we know the host & port (from the URI) we use it, else (most-likely
+          # called with a block) rely on the URL at the end.
+          if req.respond_to?(:uri) && req.uri
+            if req.uri.host.to_s == transport.hostname.to_s &&
+               req.uri.port.to_i == transport.port.to_i
+              return true
+            end
+          elsif address && port &&
+                address.to_s == transport.hostname.to_s &&
+                port.to_i == transport.port.to_i
+            return true
+          end
+          # we don't want a "shotgun" effect with two nested traces for one
+          # logical get, and request is likely to call itself recursively
+          active = pin.tracer.active_span
+          return true if active && (active.name == Ext::SPAN_REQUEST)
+          false
+        end
+
+        def should_skip_distributed_tracing?(pin)
+          if pin.config && pin.config.key?(:distributed_tracing)
+            return !pin.config[:distributed_tracing]
+          end
+
+          !Datadog.configuration[:http][:distributed_tracing]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/http/ext'
+
+module Datadog
+  module Contrib
+    module HTTP
+      module Configuration
+        # Custom settings for the HTTP integration
+        class Settings < Contrib::Configuration::Settings
+          option :distributed_tracing, default: false
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Datadog
+  module Contrib
+    module HTTP
+      # HTTP integration constants
+      module Ext
+        APP = 'net/http'.freeze
+        SERVICE_NAME = 'net/http'.freeze
+
+        SPAN_REQUEST = 'http.request'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/http/configuration/settings'
+require 'ddtrace/contrib/http/patcher'
+require 'ddtrace/contrib/http/circuit_breaker'
+
+module Datadog
+  module Contrib
+    # HTTP integration
+    module HTTP
+      extend CircuitBreaker
+
+      # Description of HTTP integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :http, auto_patch: true
+
+        def self.version
+          Gem::Version.new(RUBY_VERSION)
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -1,63 +1,23 @@
-# requirements should be kept minimal as Patcher is a shared requirement.
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/http/ext'
 
 module Datadog
   module Contrib
     # Datadog Net/HTTP integration.
     module HTTP
-      URL = 'http.url'.freeze
-      METHOD = 'http.method'.freeze
-      BODY = 'http.body'.freeze
-
-      NAME = 'http.request'.freeze
-      APP = 'net/http'.freeze
-      SERVICE = 'net/http'.freeze
-
-      module_function
-
-      def should_skip_tracing?(req, address, port, transport, pin)
-        # we don't want to trace our own call to the API (they use net/http)
-        # when we know the host & port (from the URI) we use it, else (most-likely
-        # called with a block) rely on the URL at the end.
-        if req.respond_to?(:uri) && req.uri
-          if req.uri.host.to_s == transport.hostname.to_s &&
-             req.uri.port.to_i == transport.port.to_i
-            return true
-          end
-        elsif address && port &&
-              address.to_s == transport.hostname.to_s &&
-              port.to_i == transport.port.to_i
-          return true
-        end
-        # we don't want a "shotgun" effect with two nested traces for one
-        # logical get, and request is likely to call itself recursively
-        active = pin.tracer.active_span()
-        return true if active && (active.name == NAME)
-        false
-      end
-
-      def should_skip_distributed_tracing?(pin)
-        if pin.config && pin.config.key?(:distributed_tracing)
-          return !pin.config[:distributed_tracing]
-        end
-
-        !Datadog.configuration[:http][:distributed_tracing]
-      end
-
       # Patcher enables patching of 'net/http' module.
       module Patcher
-        include Base
-        register_as :http, auto_patch: true
-        option :distributed_tracing, default: false
-        option :service_name, default: SERVICE
-        option :tracer, default: Datadog.tracer
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
+        def patched?
+          done?(:http)
+        end
+
         # patch applies our patch if needed
         def patch
-          unless @patched
+          do_once(:http) do
             begin
               require 'uri'
               require 'ddtrace/pin'
@@ -67,18 +27,10 @@ module Datadog
               require 'ddtrace/ext/distributed'
 
               patch_http
-
-              @patched = true
             rescue StandardError => e
               Datadog::Tracer.log.error("Unable to apply net/http integration: #{e}")
             end
           end
-          @patched
-        end
-
-        # patched? tells whether patch has been successfully applied
-        def patched?
-          @patched
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -94,7 +46,7 @@ module Datadog
                 service = Datadog.configuration[:http][:service_name]
                 tracer = Datadog.configuration[:http][:tracer]
 
-                Datadog::Pin.new(service, app: APP, app_type: Datadog::Ext::AppTypes::WEB, tracer: tracer)
+                Datadog::Pin.new(service, app: Ext::APP, app_type: Datadog::Ext::AppTypes::WEB, tracer: tracer)
               end
             end
 
@@ -108,7 +60,7 @@ module Datadog
                 return request_without_datadog(req, body, &block)
               end
 
-              pin.tracer.trace(NAME) do |span|
+              pin.tracer.trace(Ext::SPAN_REQUEST) do |span|
                 begin
                   span.service = pin.service
                   span.span_type = Datadog::Ext::HTTP::TYPE

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

@@ -0,0 +1,18 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/mongodb/ext'
+
+module Datadog
+  module Contrib
+    module MongoDB
+      module Configuration
+        # Custom settings for the MongoDB integration
+        class Settings < Contrib::Configuration::Settings
+          DEFAULT_QUANTIZE = { show: [:collection, :database, :operation] }.freeze
+
+          option :quantize, default: DEFAULT_QUANTIZE
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Datadog
+  module Contrib
+    module MongoDB
+      # MongoDB integration constants
+      module Ext
+        APP = 'mongodb'.freeze
+        SERVICE_NAME = 'mongodb'.freeze
+
+        SPAN_COMMAND = 'mongo.cmd'.freeze
+        SPAN_TYPE_COMMAND = 'mongodb'.freeze
+
+        TAG_COLLECTION = 'mongodb.collection'.freeze
+        TAG_DB = 'mongodb.db'.freeze
+        TAG_OPERATION = 'mongodb.operation'.freeze
+        TAG_QUERY = 'mongodb.query'.freeze
+        TAG_ROWS = 'mongodb.rows'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/mongodb/configuration/settings'
+require 'ddtrace/contrib/mongodb/patcher'
+
+module Datadog
+  module Contrib
+    module MongoDB
+      # Description of MongoDB integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :mongo, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['mongo'] && Gem.loaded_specs['mongo'].version
+        end
+
+        def self.present?
+          super && defined?(::Mongo::Monitoring::Global)
+        end
+
+        def self.compatible?
+          super && version >= Gem::Version.new('2.1.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -1,56 +1,40 @@
-# requirements should be kept minimal as Patcher is a shared requirement.
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/mongodb/ext'
 
 module Datadog
   module Contrib
-    # MongoDB module includes classes and functions to instrument MongoDB clients
     module MongoDB
-      APP = 'mongodb'.freeze
-      SERVICE = 'mongodb'.freeze
-
-      # Patcher adds subscribers to the MongoDB driver so that each command is traced.
+      # Patcher enables patching of 'mongo' module.
       module Patcher
-        include Base
-        register_as :mongo, auto_patch: true
-        option :service_name, default: SERVICE
-        option :quantize, default: { show: [:collection, :database, :operation] }
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
         def patched?
-          @patched
+          done?(:mongo)
         end
 
         def patch
-          # versions prior to 2.1.0 don't support the Monitoring API
-          if !@patched && (defined?(::Mongo::Monitoring::Global) && \
-                  Gem::Version.new(::Mongo::VERSION) >= Gem::Version.new('2.1.0'))
+          do_once(:mongo) do
             begin
               require 'ddtrace/pin'
               require 'ddtrace/ext/net'
-              require 'ddtrace/ext/mongo'
               require 'ddtrace/ext/app_types'
+              require 'ddtrace/contrib/mongodb/ext'
               require 'ddtrace/contrib/mongodb/parsers'
               require 'ddtrace/contrib/mongodb/subscribers'
 
-              patch_mongo_client()
-              add_mongo_monitoring()
-
-              @patched = true
+              patch_mongo_client
+              add_mongo_monitoring
             rescue StandardError => e
               Datadog::Tracer.log.error("Unable to apply MongoDB integration: #{e}")
             end
           end
-          @patched
         end
 
         def add_mongo_monitoring
           # Subscribe to all COMMAND queries with our subscriber class
-          ::Mongo::Monitoring::Global.subscribe(
-            ::Mongo::Monitoring::COMMAND,
-            Datadog::Contrib::MongoDB::MongoCommandSubscriber.new
-          )
+          ::Mongo::Monitoring::Global.subscribe(::Mongo::Monitoring::COMMAND, MongoCommandSubscriber.new)
         end
 
         def patch_mongo_client
@@ -63,8 +47,14 @@ module Datadog
             def initialize(*args, &blk)
               # attach the Pin instance
               initialize_without_datadog(*args, &blk)
+              tracer = Datadog.configuration[:mongo][:tracer]
               service = Datadog.configuration[:mongo][:service_name]
-              pin = Datadog::Pin.new(service, app: APP, app_type: Datadog::Ext::AppTypes::DB)
+              pin = Datadog::Pin.new(
+                service,
+                app: Datadog::Contrib::MongoDB::Ext::APP,
+                app_type: Datadog::Ext::AppTypes::DB,
+                tracer: tracer
+              )
               pin.onto(self)
             end
 

data/lib/ddtrace/contrib/mongodb/subscribers.rb

@@ -1,6 +1,8 @@
+require 'ddtrace/contrib/mongodb/ext'
+require 'ddtrace/contrib/mongodb/parsers'
+
 module Datadog
   module Contrib
-    # MongoDB module includes classes and functions to instrument MongoDB clients
     module MongoDB
       # `MongoCommandSubscriber` listens to all events from the `Monitoring`
       # system available in the Mongo driver.
@@ -14,20 +16,19 @@ module Datadog
           # thread is involved in this execution so thread-local storage should be safe. Reference:
           # https://github.com/mongodb/mongo-ruby-driver/blob/master/lib/mongo/monitoring.rb#L70
           # https://github.com/mongodb/mongo-ruby-driver/blob/master/lib/mongo/monitoring/publishable.rb#L38-L56
-          span = pin.tracer.trace('mongo.cmd', service: pin.service, span_type: Datadog::Ext::Mongo::TYPE)
+          span = pin.tracer.trace(Ext::SPAN_COMMAND, service: pin.service, span_type: Ext::SPAN_TYPE_COMMAND)
           Thread.current[:datadog_mongo_span] = span
 
           # build a quantized Query using the Parser module
-          query = Datadog::Contrib::MongoDB
-                  .query_builder(event.command_name, event.database_name, event.command)
+          query = MongoDB.query_builder(event.command_name, event.database_name, event.command)
           serialized_query = query.to_s
 
           # add operation tags; the full query is stored and used as a resource,
           # since it has been quantized and reduced
-          span.set_tag(Datadog::Ext::Mongo::DB, query['database'])
-          span.set_tag(Datadog::Ext::Mongo::COLLECTION, query['collection'])
-          span.set_tag(Datadog::Ext::Mongo::OPERATION, query['operation'])
-          span.set_tag(Datadog::Ext::Mongo::QUERY, serialized_query)
+          span.set_tag(Ext::TAG_DB, query['database'])
+          span.set_tag(Ext::TAG_COLLECTION, query['collection'])
+          span.set_tag(Ext::TAG_OPERATION, query['operation'])
+          span.set_tag(Ext::TAG_QUERY, serialized_query)
           span.set_tag(Datadog::Ext::NET::TARGET_HOST, event.address.host)
           span.set_tag(Datadog::Ext::NET::TARGET_PORT, event.address.port)
 
@@ -47,7 +48,7 @@ module Datadog
         ensure
           # whatever happens, the Span must be removed from the local storage and
           # it must be finished to prevent any leak
-          span.finish() unless span.nil?
+          span.finish unless span.nil?
           Thread.current[:datadog_mongo_span] = nil
         end
 
@@ -57,13 +58,13 @@ module Datadog
 
           # add fields that are available only after executing the query
           rows = event.reply.fetch('n', nil)
-          span.set_tag(Datadog::Ext::Mongo::ROWS, rows) unless rows.nil?
+          span.set_tag(Ext::TAG_ROWS, rows) unless rows.nil?
         rescue StandardError => e
           Datadog::Tracer.log.debug("error when handling MongoDB 'succeeded' event: #{e}")
         ensure
           # whatever happens, the Span must be removed from the local storage and
           # it must be finished to prevent any leak
-          span.finish() unless span.nil?
+          span.finish unless span.nil?
           Thread.current[:datadog_mongo_span] = nil
         end
       end

data/lib/ddtrace/contrib/mysql2/client.rb

@@ -1,5 +1,7 @@
-require 'ddtrace/ext/sql'
 require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/sql'
+require 'ddtrace/contrib/mysql2/ext'
 
 module Datadog
   module Contrib
@@ -34,13 +36,13 @@ module Datadog
           end
 
           def query(sql, options = {})
-            datadog_pin.tracer.trace('mysql2.query') do |span|
+            datadog_pin.tracer.trace(Ext::SPAN_QUERY) do |span|
               span.resource = sql
               span.service = datadog_pin.service
               span.span_type = Datadog::Ext::SQL::TYPE
-              span.set_tag('mysql2.db.name', query_options[:database])
-              span.set_tag('out.host', query_options[:host])
-              span.set_tag('out.port', query_options[:port])
+              span.set_tag(Ext::TAG_DB_NAME, query_options[:database])
+              span.set_tag(Datadog::Ext::NET::TARGET_HOST, query_options[:host])
+              span.set_tag(Datadog::Ext::NET::TARGET_PORT, query_options[:port])
               super(sql, options)
             end
           end
@@ -48,7 +50,7 @@ module Datadog
           def datadog_pin
             @datadog_pin ||= Datadog::Pin.new(
               Datadog.configuration[:mysql2][:service_name],
-              app: 'mysql2',
+              app: Ext::APP,
               app_type: Datadog::Ext::AppTypes::DB,
               tracer: Datadog.configuration[:mysql2][:tracer]
             )