ddtrace 0.46.0 → 0.47.0

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

@@ -1,4 +1,5 @@
 require 'ddtrace/configuration/base'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   module Contrib
@@ -7,6 +8,8 @@ module Datadog
       class Settings
         include Datadog::Configuration::Base
 
+        DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
         option :analytics_enabled, default: false
         option :analytics_sample_rate, default: 1.0
         option :enabled, default: true
@@ -14,7 +17,7 @@ module Datadog
         option :tracer do |o|
           o.delegate_to { Datadog.tracer }
           o.on_set do |_value|
-            log_deprecation_warning(:tracer)
+            log_deprecation_warning
           end
         end
 
@@ -41,11 +44,9 @@ module Datadog
           the correct tracer internally.
           ).freeze
 
-        include Datadog::Patcher # DEV includes #do_once here. We should move that logic to a generic component.
-
-        def log_deprecation_warning(method_name)
-          do_once(method_name) do
-            Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}:#{caller.join("\n")}")
+        def log_deprecation_warning
+          DEPRECATION_WARN_ONLY_ONCE.run do
+            Datadog.logger.warn("tracer:#{DEPRECATION_WARNING}:#{caller.join("\n")}")
           end
         end
       end

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

@@ -1,3 +1,4 @@
+require 'ddtrace/patcher'
 require 'ddtrace/contrib/patcher'
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/integration'

data/lib/ddtrace/contrib/extensions.rb

@@ -47,7 +47,7 @@ module Datadog
               desc += ", Compatible? #{patch_results[:compatible]}"
               desc += ", Patchable? #{patch_results[:patchable]}"
 
-              Datadog.logger.warn("Unable to patch #{patch_results['name']} (#{desc})")
+              Datadog.logger.warn("Unable to patch #{patch_results[:name]} (#{desc})")
             end
 
             target.integrations_pending_activation.clear
@@ -67,9 +67,32 @@ module Datadog
             end
           end
 
-          def [](integration_name, configuration_name = :default)
+          # For the provided `integration_name`, resolves a matching configuration
+          # for the provided integration from an integration-specific `key`.
+          #
+          # How the matching is performed is integration-specific.
+          #
+          # @param [Symbol] integration_name the integration name
+          # @param [Object] key the integration-specific lookup key
+          # @return [Datadog::Contrib::Configuration::Settings]
+          def [](integration_name, key = :default)
             integration = fetch_integration(integration_name)
-            integration.configuration(configuration_name) unless integration.nil?
+            integration.resolve(key) unless integration.nil?
+          end
+
+          # For the provided `integration_name`, retrieves a configuration previously
+          # stored by `#instrument`. Specifically, `describes` should be
+          # the same value provided in the `describes:` option for `#instrument`.
+          #
+          # If no `describes` value is provided, the default configuration is returned.
+          #
+          # @param [Symbol] integration_name the integration name
+          # @param [Object] describes the previously configured `describes:` object. If `nil`,
+          #   fetches the default configuration
+          # @return [Datadog::Contrib::Configuration::Settings]
+          def configuration(integration_name, describes = nil)
+            integration = fetch_integration(integration_name)
+            integration.configuration(describes) unless integration.nil?
           end
 
           def instrument(integration_name, options = {}, &block)

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

@@ -88,14 +88,12 @@ module Datadog
             service = config[:service_name]
             tracer = config[:tracer]
 
-            @datadog_pin ||= begin
-              Datadog::Pin.new(
-                service,
-                app: Ext::APP,
-                app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
-                tracer: -> { config[:tracer] }
-              )
-            end
+            @datadog_pin ||= Datadog::Pin.new(
+              service,
+              app: Ext::APP,
+              app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
+              tracer: -> { config[:tracer] }
+            )
 
             if @datadog_pin.service_name == default_datadog_pin.service_name && @datadog_pin.service_name != service
               @datadog_pin.service = service
@@ -111,14 +109,12 @@ module Datadog
             config = Datadog.configuration[:httpclient]
             service = config[:service_name]
 
-            @default_datadog_pin ||= begin
-              Datadog::Pin.new(
-                service,
-                app: Ext::APP,
-                app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
-                tracer: -> { config[:tracer] }
-              )
-            end
+            @default_datadog_pin ||= Datadog::Pin.new(
+              service,
+              app: Ext::APP,
+              app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
+              tracer: -> { config[:tracer] }
+            )
           end
 
           def datadog_configuration(host = :default)

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

@@ -1,5 +1,6 @@
 require 'ddtrace/contrib/patcher'
 require 'ddtrace/contrib/httpclient/instrumentation'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   module Contrib
@@ -9,10 +10,12 @@ module Datadog
       module Patcher
         include Contrib::Patcher
 
+        PATCH_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
         module_function
 
         def patched?
-          done?(:httpclient)
+          PATCH_ONLY_ONCE.ran?
         end
 
         def target_version
@@ -21,7 +24,7 @@ module Datadog
 
         # patch applies our patch
         def patch
-          do_once(:httpclient) do
+          PATCH_ONLY_ONCE.run do
             begin
               ::HTTPClient.send(:include, Instrumentation)
             rescue StandardError => e

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

@@ -16,7 +16,6 @@ module Datadog
         end
 
         # Instance methods for configuration
-        # rubocop:disable Metrics/ModuleLength
         module InstanceMethods
           include Datadog::Contrib::HttpAnnotationHelper
 
@@ -99,14 +98,12 @@ module Datadog
             service = config[:service_name]
             tracer = config[:tracer]
 
-            @datadog_pin ||= begin
-              Datadog::Pin.new(
-                service,
-                app: Ext::APP,
-                app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
-                tracer: -> { config[:tracer] }
-              )
-            end
+            @datadog_pin ||= Datadog::Pin.new(
+              service,
+              app: Ext::APP,
+              app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
+              tracer: -> { config[:tracer] }
+            )
 
             if @datadog_pin.service_name == default_datadog_pin.service_name && @datadog_pin.service_name != service
               @datadog_pin.service = service
@@ -122,14 +119,12 @@ module Datadog
             config = Datadog.configuration[:httprb]
             service = config[:service_name]
 
-            @default_datadog_pin ||= begin
-              Datadog::Pin.new(
-                service,
-                app: Ext::APP,
-                app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
-                tracer: -> { config[:tracer] }
-              )
-            end
+            @default_datadog_pin ||= Datadog::Pin.new(
+              service,
+              app: Ext::APP,
+              app_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
+              tracer: -> { config[:tracer] }
+            )
           end
 
           def datadog_configuration(host = :default)

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

@@ -1,5 +1,6 @@
 require 'ddtrace/contrib/patcher'
 require 'ddtrace/contrib/httprb/instrumentation'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   module Contrib
@@ -9,10 +10,12 @@ module Datadog
       module Patcher
         include Contrib::Patcher
 
+        PATCH_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
         module_function
 
         def patched?
-          done?(:httprb)
+          PATCH_ONLY_ONCE.ran?
         end
 
         def target_version
@@ -21,7 +24,7 @@ module Datadog
 
         # patch applies our patch
         def patch
-          do_once(:httprb) do
+          PATCH_ONLY_ONCE.run do
             begin
               ::HTTP::Client.send(:include, Instrumentation)
             rescue StandardError => e

data/lib/ddtrace/contrib/patcher.rb

@@ -1,12 +1,10 @@
-require 'ddtrace/patcher'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   module Contrib
     # Common behavior for patcher modules
     module Patcher
       def self.included(base)
-        base.send(:include, Datadog::Patcher)
-
         base.singleton_class.send(:prepend, CommonMethods)
         base.send(:prepend, CommonMethods) if base.instance_of?(Class)
       end
@@ -18,13 +16,13 @@ module Datadog
         end
 
         def patched?
-          done?(:patch)
+          patch_only_once.ran?
         end
 
         def patch
           return unless defined?(super)
 
-          do_once(:patch) do
+          patch_only_once.run do
             begin
               super.tap do
                 # Emit a metric
@@ -56,6 +54,11 @@ module Datadog
             tags << "target_version:#{target_version}" if respond_to?(:target_version) && !target_version.nil?
           end
         end
+
+        def patch_only_once
+          # NOTE: This is not thread-safe
+          @patch_only_once ||= Datadog::Utils::OnlyOnce.new
+        end
       end
     end
   end

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

@@ -1,6 +1,7 @@
 require 'ddtrace/contrib/patcher'
 require 'ddtrace/contrib/presto/ext'
 require 'ddtrace/contrib/presto/instrumentation'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   module Contrib
@@ -9,14 +10,16 @@ module Datadog
       module Patcher
         include Contrib::Patcher
 
+        PATCH_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
         module_function
 
         def patched?
-          done?(:presto)
+          PATCH_ONLY_ONCE.ran?
         end
 
         def patch
-          do_once(:presto) do
+          PATCH_ONLY_ONCE.run do
             begin
               ::Presto::Client::Client.send(:include, Instrumentation::Client)
             rescue StandardError => e

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

@@ -3,6 +3,7 @@ require 'ddtrace/contrib/rails/framework'
 require 'ddtrace/contrib/rails/middlewares'
 require 'ddtrace/contrib/rails/log_injection'
 require 'ddtrace/contrib/rack/middlewares'
+require 'ddtrace/utils/only_once'
 
 module Datadog
   module Contrib
@@ -11,6 +12,9 @@ module Datadog
       module Patcher
         include Contrib::Patcher
 
+        BEFORE_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Datadog::Utils::OnlyOnce.new }
+        AFTER_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Datadog::Utils::OnlyOnce.new }
+
         module_function
 
         def target_version
@@ -29,7 +33,7 @@ module Datadog
         end
 
         def before_intialize(app)
-          do_once(:rails_before_initialize, for: app) do
+          BEFORE_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
             # Middleware must be added before the application is initialized.
             # Otherwise the middleware stack will be frozen.
             # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
@@ -86,7 +90,7 @@ module Datadog
         end
 
         def after_intialize(app)
-          do_once(:rails_after_initialize, for: app) do
+          AFTER_INITIALIZE_ONLY_ONCE_PER_APP[app].run do
             # Finish configuring the tracer after the application is initialized.
             # We need to wait for some things, like application name, middleware stack, etc.
             setup_tracer

data/lib/ddtrace/contrib/redis/configuration/resolver.rb

@@ -6,12 +6,19 @@ module Datadog
       module Configuration
         UNIX_SCHEME = 'unix'.freeze
 
-        # Converts Symbols, Strings, and Hashes to a normalized connection settings Hash.
+        # Converts String URLs and Hashes to a normalized connection settings Hash.
         class Resolver < Contrib::Configuration::Resolver
-          def resolve(key_or_hash)
-            return :default if key_or_hash == :default
+          # @param [Hash,String] Redis connection information
+          def resolve(hash)
+            super(parse_matcher(hash))
+          end
+
+          protected
+
+          def parse_matcher(matcher)
+            matcher = { url: matcher } if matcher.is_a?(String)
 
-            normalize(connection_resolver.resolve(key_or_hash))
+            normalize(connection_resolver.resolve(matcher))
           end
 
           def normalize(hash)

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

@@ -25,7 +25,7 @@ module Datadog
 
         def self.compatible?
           super \
-            && version >= Gem::Version.new('1.0') \
+            && version >= MINIMUM_VERSION \
             && version < MAXIMUM_VERSION
         end
 

data/lib/ddtrace/ext/runtime.rb

@@ -5,7 +5,9 @@ module Datadog
     module Runtime
       # Identity
       LANG = 'ruby'.freeze
+      LANG_ENGINE = RUBY_ENGINE
       LANG_INTERPRETER = "#{RUBY_ENGINE}-#{RUBY_PLATFORM}".freeze
+      LANG_PLATFORM = RUBY_PLATFORM
       LANG_VERSION = RUBY_VERSION
       RUBY_ENGINE =  ::RUBY_ENGINE # e.g. 'ruby', 'jruby', 'truffleruby'
       TRACER_VERSION = Datadog::VERSION::STRING

data/lib/ddtrace/patcher.rb

@@ -1,7 +1,21 @@
+require 'ddtrace/utils/only_once'
+
 module Datadog
-  # Defines some useful patching methods for integrations
+  # Deprecated: This module should no longer be included. It's only being kept around for backwards compatibility
+  # concerns regarding customer usage.
   module Patcher
+    INCLUDED_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+    DO_ONCE_USAGE_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
     def self.included(base)
+      INCLUDED_WARN_ONLY_ONCE.run do
+        Datadog.logger.warn(
+          'Including Datadog::Patcher is deprecated. ' \
+          'For the #do_once behavior, use Datadog::Utils::OnlyOnce instead. ' \
+          'For the #without_warnings behavior, use Datadog::Patcher.without_warnings { ... } as a module function.'
+        )
+      end
+
       base.send(:extend, CommonMethods)
       base.send(:include, CommonMethods)
     end
@@ -22,6 +36,10 @@ module Datadog
       end
 
       def do_once(key = nil, options = {})
+        DO_ONCE_USAGE_WARN_ONLY_ONCE.run do
+          Datadog.logger.warn('Datadog::Patcher#do_once is deprecated. Use Datadog::Utils::OnlyOnce instead.')
+        end
+
         # If already done, don't do again
         @done_once ||= Hash.new { |h, k| h[k] = {} }
         return @done_once[key][options[:for]] if @done_once.key?(key) && @done_once[key].key?(options[:for])
@@ -34,6 +52,10 @@ module Datadog
       end
 
       def done?(key, options = {})
+        DO_ONCE_USAGE_WARN_ONLY_ONCE.run do
+          Datadog.logger.warn('Datadog::Patcher#done? is deprecated. Use Datadog::Utils::OnlyOnce instead.')
+        end
+
         return false unless instance_variable_defined?(:@done_once)
 
         !@done_once.nil? && @done_once.key?(key) && @done_once[key].key?(options[:for])

data/lib/ddtrace/pin.rb

@@ -1,4 +1,5 @@
 require 'ddtrace/patcher'
+require 'ddtrace/utils/only_once'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
@@ -7,6 +8,8 @@ module Datadog
   # This is useful if you wanted to, say, trace two different
   # database clusters.
   class Pin
+    DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
     def self.get_from(obj)
       return nil unless obj.respond_to? :datadog_pin
 
@@ -74,15 +77,8 @@ module Datadog
       ).freeze
 
     def deprecation_warning
-      log_deprecation_warning('Datadog::Pin.new')
-    end
-
-    include Datadog::Patcher
-
-    def log_deprecation_warning(method_name)
-      # Only log each deprecation warning once (safeguard against log spam)
-      do_once(method_name) do
-        Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}")
+      DEPRECATION_WARN_ONLY_ONCE.run do
+        Datadog.logger.warn("Datadog::Pin.new:#{DEPRECATION_WARNING}")
       end
     end
   end