ddtrace 0.35.2 → 1.1.0

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

@@ -1,26 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/http/ext'
-require 'ddtrace/contrib/http/instrumentation'
-
-module Datadog
-  module Contrib
-    # Datadog Net/HTTP integration.
-    module HTTP
-      # Patcher enables patching of 'net/http' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        # patch applies our patch if needed
-        def patch
-          ::Net::HTTP.send(:include, Instrumentation)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/http_annotation_helper.rb

@@ -1,10 +0,0 @@
-module Datadog
-  module Contrib
-    # Contains methods helpful for tracing/annotating HTTP request libraries
-    module HttpAnnotationHelper
-      def service_name(hostname, configuration_options)
-        configuration_options[:split_by_domain] ? hostname : configuration_options[:service_name]
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/integration.rb

@@ -1,16 +0,0 @@
-require 'ddtrace/contrib/configurable'
-require 'ddtrace/contrib/patchable'
-require 'ddtrace/contrib/registerable'
-
-module Datadog
-  module Contrib
-    # Base provides features that are shared across all integrations
-    module Integration
-      def self.included(base)
-        base.send(:include, Configurable)
-        base.send(:include, Patchable)
-        base.send(:include, Registerable)
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-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 :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 :quantize, default: DEFAULT_QUANTIZE
-          option :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module Datadog
-  module Contrib
-    module MongoDB
-      # MongoDB integration constants
-      module Ext
-        APP = 'mongodb'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_MONGO_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_MONGO_ANALYTICS_SAMPLE_RATE'.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/instrumentation.rb

@@ -1,68 +0,0 @@
-require 'ddtrace/pin'
-require 'ddtrace/ext/net'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/mongodb/ext'
-require 'ddtrace/contrib/mongodb/parsers'
-require 'ddtrace/contrib/mongodb/subscribers'
-
-module Datadog
-  module Contrib
-    module MongoDB
-      # Instrumentation for Mongo integration
-      module Instrumentation
-        # Instrumentation for Mongo::Client
-        module Client
-          def self.included(base)
-            base.send(:include, InstanceMethods)
-          end
-
-          # Instance methods for Mongo::Client
-          module InstanceMethods
-            def datadog_pin
-              # safe-navigation to avoid crashes during each query
-              return unless respond_to? :cluster
-              return unless cluster.respond_to? :addresses
-              return unless cluster.addresses.respond_to? :first
-              Datadog::Pin.get_from(cluster.addresses.first)
-            end
-
-            def datadog_pin=(pin)
-              # safe-navigation to avoid crashes during each query
-              return unless respond_to? :cluster
-              return unless cluster.respond_to? :addresses
-              return unless cluster.addresses.respond_to? :each
-              # attach the PIN to all cluster addresses. One of them is used
-              # when executing a Command and it is attached to the Monitoring
-              # Event instance.
-              cluster.addresses.each { |x| pin.onto(x) }
-            end
-          end
-        end
-
-        # Instrumentation for Mongo::Address
-        module Address
-          def self.included(base)
-            base.send(:include, InstanceMethods)
-          end
-
-          # Instance methods for Mongo::Address
-          module InstanceMethods
-            def datadog_pin
-              @datadog_pin ||= begin
-                tracer = Datadog.configuration[:mongo][:tracer]
-                service = Datadog.configuration[:mongo][:service_name]
-
-                Datadog::Pin.new(
-                  service,
-                  app: Datadog::Contrib::MongoDB::Ext::APP,
-                  app_type: Datadog::Ext::AppTypes::DB,
-                  tracer: tracer
-                )
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-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
-
-        MINIMUM_VERSION = Gem::Version.new('2.1.0')
-
-        register_as :mongo, auto_patch: true
-
-        def self.version
-          Gem.loaded_specs['mongo'] && Gem.loaded_specs['mongo'].version
-        end
-
-        def self.loaded?
-          !defined?(::Mongo::Monitoring::Global).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/mongodb/parsers.rb

@@ -1,68 +0,0 @@
-module Datadog
-  module Contrib
-    # MongoDB module includes classes and functions to instrument MongoDB clients
-    module MongoDB
-      EXCLUDE_KEYS = [:_id].freeze
-      SHOW_KEYS = [].freeze
-      DEFAULT_OPTIONS = { exclude: EXCLUDE_KEYS, show: SHOW_KEYS }.freeze
-
-      module_function
-
-      # skipped keys are related to command names, since they are already
-      # extracted by the query_builder
-      PLACEHOLDER = '?'.freeze
-
-      # returns a formatted and normalized query
-      def query_builder(command_name, database_name, command)
-        # always exclude the command name
-        options = Quantization::Hash.merge_options(quantization_options, exclude: [command_name.to_s])
-
-        # quantized statements keys are strings to avoid leaking Symbols in older Rubies
-        # as Symbols are not GC'ed in Rubies prior to 2.2
-        base_info = Quantization::Hash.format({
-                                                'operation' => command_name,
-                                                'database' => database_name,
-                                                'collection' => command.values.first
-                                              }, options)
-
-        base_info.merge(Quantization::Hash.format(command, options))
-      end
-
-      # removes the values from the given query; this quantization recursively
-      # replace elements available in a given query, so that Arrays, Hashes and so
-      # on are compacted. It ensures a low cardinality so that it can be used
-      # as a Span resource.
-      # @deprecated
-      def quantize_statement(statement, skip = [])
-        case statement
-        when Hash
-          statement.each_with_object({}) do |(key, value), quantized|
-            quantized[key] = quantize_value(value, skip) unless skip.include?(key)
-          end
-        else
-          quantize_value(statement, skip)
-        end
-      end
-
-      # @deprecated
-      def quantize_value(value, skip = [])
-        case value
-        when Hash
-          quantize_statement(value, skip)
-        when Array
-          quantize_value(value.first, skip)
-        else
-          PLACEHOLDER
-        end
-      end
-
-      def quantization_options
-        Datadog::Quantization::Hash.merge_options(DEFAULT_OPTIONS, configuration[:quantize])
-      end
-
-      def configuration
-        Datadog.configuration[:mongo]
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/mongodb/ext'
-require 'ddtrace/contrib/mongodb/instrumentation'
-
-module Datadog
-  module Contrib
-    module MongoDB
-      # Patcher enables patching of 'mongo' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          ::Mongo::Address.send(:include, Instrumentation::Address)
-          ::Mongo::Client.send(:include, Instrumentation::Client)
-          add_mongo_monitoring
-        end
-
-        def add_mongo_monitoring
-          # Subscribe to all COMMAND queries with our subscriber class
-          ::Mongo::Monitoring::Global.subscribe(::Mongo::Monitoring::COMMAND, MongoCommandSubscriber.new)
-        end
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/mongodb/ext'
-require 'ddtrace/contrib/mongodb/parsers'
-
-module Datadog
-  module Contrib
-    module MongoDB
-      # `MongoCommandSubscriber` listens to all events from the `Monitoring`
-      # system available in the Mongo driver.
-      class MongoCommandSubscriber
-        def started(event)
-          pin = Datadog::Pin.get_from(event.address)
-          return unless pin && pin.enabled?
-
-          # start a trace and store it in the current thread; using the `operation_id`
-          # is safe since it's a unique id used to link events together. Also only one
-          # 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(Ext::SPAN_COMMAND, service: pin.service, span_type: Ext::SPAN_TYPE_COMMAND)
-          set_span(event, span)
-
-          # build a quantized Query using the Parser module
-          query = MongoDB.query_builder(event.command_name, event.database_name, event.command)
-          serialized_query = query.to_s
-
-          # Set analytics sample rate
-          if analytics_enabled?
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
-          end
-
-          # add operation tags; the full query is stored and used as a resource,
-          # since it has been quantized and reduced
-          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)
-
-          # set the resource with the quantized query
-          span.resource = serialized_query
-        end
-
-        def failed(event)
-          span = get_span(event)
-          return unless span
-
-          # the failure is not a real exception because it's handled by
-          # the framework itself, so we set only the error and the message
-          span.set_error(event)
-        rescue StandardError => e
-          Datadog.logger.debug("error when handling MongoDB 'failed' 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?
-          clear_span(event)
-        end
-
-        def succeeded(event)
-          span = get_span(event)
-          return unless span
-
-          # add fields that are available only after executing the query
-          rows = event.reply.fetch('n', nil)
-          span.set_tag(Ext::TAG_ROWS, rows) unless rows.nil?
-        rescue StandardError => e
-          Datadog.logger.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?
-          clear_span(event)
-        end
-
-        private
-
-        def get_span(event)
-          Thread.current[:datadog_mongo_span] \
-            && Thread.current[:datadog_mongo_span][event.request_id]
-        end
-
-        def set_span(event, span)
-          Thread.current[:datadog_mongo_span] ||= {}
-          Thread.current[:datadog_mongo_span][event.request_id] = span
-        end
-
-        def clear_span(event)
-          return if Thread.current[:datadog_mongo_span].nil?
-          Thread.current[:datadog_mongo_span].delete(event.request_id)
-        end
-
-        def analytics_enabled?
-          Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
-        end
-
-        def analytics_sample_rate
-          datadog_configuration[:analytics_sample_rate]
-        end
-
-        def datadog_configuration
-          Datadog.configuration[:mongo]
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/mysql2/ext'
-
-module Datadog
-  module Contrib
-    module Mysql2
-      module Configuration
-        # Custom settings for the Mysql2 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/mysql2/ext.rb

@@ -1,15 +0,0 @@
-module Datadog
-  module Contrib
-    module Mysql2
-      # Mysql2 integration constants
-      module Ext
-        APP = 'mysql2'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_MYSQL2_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_MYSQL2_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'mysql2'.freeze
-        SPAN_QUERY = 'mysql2.query'.freeze
-        TAG_DB_NAME = 'mysql2.db.name'.freeze
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-require 'ddtrace/ext/app_types'
-require 'ddtrace/ext/net'
-require 'ddtrace/ext/sql'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/mysql2/ext'
-
-module Datadog
-  module Contrib
-    module Mysql2
-      # Mysql2::Client patch module
-      module Instrumentation
-        def self.included(base)
-          base.send(:prepend, InstanceMethods)
-        end
-
-        # Mysql2::Client patch instance methods
-        module InstanceMethods
-          def query(sql, options = {})
-            datadog_pin.tracer.trace(Ext::SPAN_QUERY) do |span|
-              span.resource = sql
-              span.service = datadog_pin.service
-              span.span_type = Datadog::Ext::SQL::TYPE
-
-              # Set analytics sample rate
-              Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
-
-              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
-
-          def datadog_pin
-            @datadog_pin ||= Datadog::Pin.new(
-              Datadog.configuration[:mysql2][:service_name],
-              app: Ext::APP,
-              app_type: Datadog::Ext::AppTypes::DB,
-              tracer: Datadog.configuration[:mysql2][:tracer]
-            )
-          end
-
-          private
-
-          def datadog_configuration
-            Datadog.configuration[:mysql2]
-          end
-
-          def analytics_enabled?
-            datadog_configuration[:analytics_enabled]
-          end
-
-          def analytics_sample_rate
-            datadog_configuration[:analytics_sample_rate]
-          end
-        end
-      end
-    end
-  end
-end

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

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

@@ -1,27 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/mysql2/instrumentation'
-
-module Datadog
-  module Contrib
-    module Mysql2
-      # Patcher enables patching of 'mysql2' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          patch_mysql2_client
-        end
-
-        def patch_mysql2_client
-          ::Mysql2::Client.send(:include, Instrumentation)
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/patchable.rb

@@ -1,59 +0,0 @@
-module Datadog
-  module Contrib
-    # Base provides features that are shared across all integrations
-    module Patchable
-      def self.included(base)
-        base.send(:extend, ClassMethods)
-        base.send(:include, InstanceMethods)
-      end
-
-      # Class methods for integrations
-      module ClassMethods
-        def version
-          nil
-        end
-
-        # Is the target available? (e.g. gem installed?)
-        def available?
-          !version.nil?
-        end
-
-        # Is the target loaded into the application? (e.g. constants defined?)
-        def loaded?
-          true
-        end
-
-        # Is the loaded code compatible with this integration? (e.g. minimum version met?)
-        def compatible?
-          available? && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new(VERSION::MINIMUM_RUBY_VERSION)
-        end
-
-        # Can the patch for this integration be applied?
-        def patchable?
-          available? && loaded? && compatible?
-        end
-      end
-
-      # Instance methods for integrations
-      module InstanceMethods
-        def patcher
-          nil
-        end
-
-        def patch
-          if !self.class.patchable? || patcher.nil?
-            desc = "Available?: #{self.class.available?}"
-            desc += ", Loaded? #{self.class.loaded?}"
-            desc += ", Compatible? #{self.class.compatible?}"
-            desc += ", Patchable? #{self.class.patchable?}"
-
-            Datadog.logger.warn("Unable to patch #{self.class.name} (#{desc})")
-            return
-          end
-
-          patcher.patch
-        end
-      end
-    end
-  end
-end