ls-trace 0.1.2 → 0.2.0

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

@@ -5,6 +5,7 @@ module Datadog
       module Ext
         APP = 'concurrent-ruby'.freeze
         SERVICE_NAME = 'concurrent-ruby'.freeze
+        ENV_ENABLED = 'DD_TRACE_CONCURRENT_RUBY_ENABLED'.freeze
       end
     end
   end

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

@@ -9,14 +9,20 @@ module Datadog
       class Integration
         include Contrib::Integration
 
+        MINIMUM_VERSION = Gem::Version.new('0.9')
+
         register_as :concurrent_ruby
 
         def self.version
           Gem.loaded_specs['concurrent-ruby'] && Gem.loaded_specs['concurrent-ruby'].version
         end
 
-        def self.present?
-          super && defined?(::Concurrent::Future)
+        def self.loaded?
+          !defined?(::Concurrent::Future).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
         end
 
         def default_configuration

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

@@ -9,20 +9,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:concurrent_ruby)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:concurrent_ruby) do
-            begin
-              require 'ddtrace/contrib/concurrent_ruby/future_patch'
-
-              patch_future
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Future integration: #{e}")
-            end
-          end
+          require 'ddtrace/contrib/concurrent_ruby/future_patch'
+          patch_future
         end
 
         # Propagate tracing context in Concurrent::Future

data/lib/ddtrace/contrib/configurable.rb

@@ -20,35 +20,52 @@ module Datadog
           @resolver = nil
         end
 
+        # Get matching configuration for key.
+        # If no match, returns default configuration.
         def configuration(key = :default)
-          configurations[resolve_configuration_key(key)]
+          configurations[configuration_key(key)]
+        end
+
+        # If the key has matching configuration explicitly defined for it,
+        # then return true. Otherwise return false.
+        def configuration_for?(key)
+          key = resolver.resolve(key) unless key == :default
+          configurations.key?(key)
         end
 
         def configurations
-          @configurations ||= Hash.new { default_configuration }.tap do |configs|
-            configs[:default] = default_configuration
-          end
+          @configurations ||= {
+            default: default_configuration
+          }
         end
 
+        # Create or update configuration with provided settings.
         def configure(key, options = {}, &block)
-          key = resolver.resolve(key || :default)
+          key ||= :default
 
-          configurations[key].tap do |settings|
-            settings.configure(options, &block)
-            configurations[key] = settings
-          end
+          # Get or add the configuration
+          config = configuration_for?(key) ? configuration(key) : add_configuration(key)
+
+          # Apply the settings
+          config.configure(options, &block)
+          config
         end
 
         protected
 
-        attr_writer :resolver
-
         def resolver
           @resolver ||= Configuration::Resolver.new
         end
 
-        def resolve_configuration_key(key = :default)
-          key = :default if key.nil?
+        def add_configuration(key)
+          resolver.add(key)
+          config_key = resolver.resolve(key)
+          configurations[config_key] = default_configuration
+        end
+
+        def configuration_key(key)
+          return :default if key.nil? || key == :default
+
           key = resolver.resolve(key)
           key = :default unless configurations.key?(key)
           key

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

@@ -1,10 +1,14 @@
 module Datadog
   module Contrib
     module Configuration
-      # Resolves a value to a configuration key
+      # Resolves a configuration key to a Datadog::Contrib::Configuration:Settings object
       class Resolver
-        def resolve(name)
-          name
+        def resolve(key)
+          key
+        end
+
+        def add(key)
+          key
         end
       end
     end

data/lib/ddtrace/contrib/configuration/resolvers/pattern_resolver.rb

@@ -0,0 +1,39 @@
+require 'ddtrace/contrib/configuration/resolver'
+
+module Datadog
+  module Contrib
+    module Configuration
+      # Resolves a value to a configuration key
+      module Resolvers
+        # Matches strings against Regexps.
+        class PatternResolver < Datadog::Contrib::Configuration::Resolver
+          def resolve(name)
+            # Try to find a matching pattern
+            matching_pattern = patterns.find do |pattern|
+              # Rubocop incorrectly thinks assignment is done here...
+              # rubocop:disable Style/ConditionalAssignment
+              if pattern.is_a?(Proc)
+                pattern === name
+              else
+                pattern === name.to_s # Co-erce to string
+              end
+            end
+
+            # Return match or default
+            matching_pattern || :default
+          end
+
+          def add(pattern)
+            patterns << (pattern.is_a?(Regexp) || pattern.is_a?(Proc) ? pattern : pattern.to_s)
+          end
+
+          private
+
+          def patterns
+            @patterns ||= Set.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,14 +9,18 @@ module Datadog
 
         option :analytics_enabled, default: false
         option :analytics_sample_rate, default: 1.0
+        option :enabled, default: true
         option :service_name
         option :tracer do |o|
           o.delegate_to { Datadog.tracer }
+          o.on_set do |_value|
+            log_deprecation_warning(:tracer)
+          end
         end
 
         def configure(options = {})
           self.class.options.dependency_order.each do |name|
-            self[name] = options.fetch(name, self[name])
+            self[name] = options[name] if options.key?(name)
           end
 
           yield(self) if block_given?
@@ -29,6 +33,21 @@ module Datadog
         def []=(name, value)
           respond_to?("#{name}=") ? send("#{name}=", value) : set_option(name, value)
         end
+
+        DEPRECATION_WARNING = %(
+          Explicitly providing a tracer instance is DEPRECATED.
+          It's recommended to not provide an explicit tracer instance
+          and let Datadog::Contrib::Configuration::Settings resolve
+          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")}")
+          end
+        end
       end
     end
   end

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

@@ -7,13 +7,18 @@ module Datadog
       module Configuration
         # Custom settings for the Dalli integration
         class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
           option :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
             o.lazy
           end
 
           option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
             o.lazy
           end
 

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

@@ -4,8 +4,11 @@ module Datadog
       # Dalli integration constants
       module Ext
         APP = 'dalli'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_DALLI_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_DALLI_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_DALLI_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_DALLI_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_DALLI_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_DALLI_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_DALLI_ANALYTICS_SAMPLE_RATE'.freeze
         QUANTIZE_MAX_CMD_LENGTH = 100
         SERVICE_NAME = 'memcached'.freeze
         SPAN_COMMAND = 'memcached.command'.freeze

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

@@ -9,18 +9,20 @@ module Datadog
       class Integration
         include Contrib::Integration
 
+        MINIMUM_VERSION = Gem::Version.new('2.0.0')
+
         register_as :dalli, auto_patch: true
 
         def self.version
           Gem.loaded_specs['dalli'] && Gem.loaded_specs['dalli'].version
         end
 
-        def self.present?
-          super && defined?(::Dalli)
+        def self.loaded?
+          !defined?(::Dalli).nil?
         end
 
         def self.compatible?
-          super && version > Gem::Version.new('2.0.0')
+          super && version >= MINIMUM_VERSION
         end
 
         def default_configuration

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

@@ -12,19 +12,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:dalli)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:dalli) do
-            begin
-              add_pin!
-              ::Dalli::Server.send(:include, Instrumentation)
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Dalli integration: #{e}")
-            end
-          end
+          add_pin!
+          ::Dalli::Server.send(:include, Instrumentation)
         end
 
         # DEPRECATED: Only kept for users still using `Dalli.datadog_pin` to configure.
@@ -35,7 +29,7 @@ module Datadog
               get_option(:service_name),
               app: Ext::APP,
               app_type: Datadog::Ext::AppTypes::CACHE,
-              tracer: get_option(:tracer)
+              tracer: -> { get_option(:tracer) }
             ).onto(::Dalli)
         end
 
@@ -53,17 +47,13 @@ module Datadog
             Upgrade to the configuration API using the migration guide here:
             https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
 
-          def tracer=(tracer)
-            Datadog.configuration[:dalli][:tracer] = tracer
-          end
-
           def service_name=(service_name)
             Datadog.configuration[:dalli][:service_name] = service_name
           end
 
           def log_deprecation_warning(method_name)
             do_once(method_name) do
-              Datadog::Tracer.log.warn("#{method_name}:#{DEPRECATION_WARNING}")
+              Datadog.logger.warn("#{method_name}:#{DEPRECATION_WARNING}")
             end
           end
         end

data/lib/ddtrace/contrib/dalli/quantize.rb

@@ -13,7 +13,7 @@ module Datadog
           command = Utils.utf8_encode(command, binary: true, placeholder: placeholder)
           Utils.truncate(command, Ext::QUANTIZE_MAX_CMD_LENGTH)
         rescue => e
-          Tracer.log.debug("Error sanitizing Dalli operation: #{e}")
+          Datadog.logger.debug("Error sanitizing Dalli operation: #{e}")
           placeholder
         end
       end

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

@@ -7,13 +7,18 @@ module Datadog
       module Configuration
         # Custom settings for the DelayedJob integration
         class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
           option :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
             o.lazy
           end
 
           option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
             o.lazy
           end
 

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

@@ -4,8 +4,11 @@ module Datadog
       # DelayedJob integration constants
       module Ext
         APP = 'delayed_job'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_DELAYED_JOB_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_DELAYED_JOB_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_DELAYED_JOB_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_DELAYED_JOB_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_DELAYED_JOB_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_DELAYED_JOB_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_DELAYED_JOB_ANALYTICS_SAMPLE_RATE'.freeze
         SERVICE_NAME = 'delayed_job'.freeze
         SPAN_JOB = 'delayed_job'.freeze
         TAG_ATTEMPTS = 'delayed_job.attempts'.freeze

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

@@ -9,14 +9,20 @@ module Datadog
       class Integration
         include Contrib::Integration
 
+        MINIMUM_VERSION = Gem::Version.new('4.1')
+
         register_as :delayed_job
 
         def self.version
           Gem.loaded_specs['delayed_job'] && Gem.loaded_specs['delayed_job'].version
         end
 
-        def self.present?
-          super && defined?(::Delayed)
+        def self.loaded?
+          !defined?(::Delayed).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
         end
 
         def default_configuration

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

@@ -10,19 +10,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:delayed_job)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:delayed_job) do
-            begin
-              require 'ddtrace/contrib/delayed_job/plugin'
-              add_instrumentation(::Delayed::Worker)
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply DelayedJob integration: #{e}")
-            end
-          end
+          require 'ddtrace/contrib/delayed_job/plugin'
+          add_instrumentation(::Delayed::Worker)
         end
 
         def add_instrumentation(klass)

data/lib/ddtrace/contrib/delayed_job/plugin.rb

@@ -23,6 +23,10 @@ module Datadog
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
               Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
             end
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
             span.set_tag(Ext::TAG_ID, job.id)
             span.set_tag(Ext::TAG_QUEUE, job.queue) if job.queue
             span.set_tag(Ext::TAG_PRIORITY, job.priority)

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

@@ -7,13 +7,18 @@ module Datadog
       module Configuration
         # Custom settings for the Elasticsearch integration
         class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
           option :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
             o.lazy
           end
 
           option :analytics_sample_rate do |o|
-            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
             o.lazy
           end