ls-trace 0.1.2 → 0.2.0

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

@@ -4,8 +4,11 @@ module Datadog
       # Rake integration constants
       module Ext
         APP = 'rake'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_RAKE_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_RAKE_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_RAKE_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAKE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_RAKE_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAKE_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_RAKE_ANALYTICS_SAMPLE_RATE'.freeze
         SERVICE_NAME = 'rake'.freeze
         SPAN_INVOKE = 'rake.invoke'.freeze
         SPAN_EXECUTE = 'rake.execute'.freeze

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

@@ -44,17 +44,21 @@ 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_TASK_ARG_NAMES, arg_names)
             span.set_tag(Ext::TAG_INVOKE_ARGS, quantize_args(args)) unless args.nil?
           rescue StandardError => e
-            Datadog::Tracer.log.debug("Error while tracing Rake invoke: #{e.message}")
+            Datadog.logger.debug("Error while tracing Rake invoke: #{e.message}")
           end
 
           def annotate_execute!(span, args)
             span.resource = name
             span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
           rescue StandardError => e
-            Datadog::Tracer.log.debug("Error while tracing Rake execute: #{e.message}")
+            Datadog.logger.debug("Error while tracing Rake execute: #{e.message}")
           end
 
           def quantize_args(args)

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

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

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

@@ -12,19 +12,13 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:rake)
+        def target_version
+          Integration.version
         end
 
         def patch
-          do_once(:rake) do
-            begin
-              # Add instrumentation patch to Rake task
-              ::Rake::Task.send(:include, Instrumentation)
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Rake integration: #{e}")
-            end
-          end
+          # Add instrumentation patch to Rake task
+          ::Rake::Task.send(:include, Instrumentation)
         end
 
         def get_option(option)

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

@@ -0,0 +1,36 @@
+require 'ddtrace/contrib/redis/vendor/resolver'
+
+module Datadog
+  module Contrib
+    module Redis
+      module Configuration
+        # Converts Symbols, Strings, 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
+
+            normalize(connection_resolver.resolve(key_or_hash))
+          end
+
+          def normalize(hash)
+            return { url: hash[:url] } if hash[:scheme] == 'unix'
+
+            # Connexion strings are always converted to host, port, db and scheme
+            # but the host, port, db and scheme will generate the :url only after
+            # establishing a first connexion
+            {
+              host: hash[:host],
+              port: hash[:port],
+              db: hash[:db],
+              scheme: hash[:scheme]
+            }
+          end
+
+          def connection_resolver
+            @connection_resolver ||= ::Datadog::Contrib::Redis::Vendor::Resolver.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,13 +7,18 @@ module Datadog
       module Configuration
         # Custom settings for the Redis 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/redis/ext.rb

@@ -4,8 +4,11 @@ module Datadog
       # Redis integration constants
       module Ext
         APP = 'redis'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_REDIS_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_REDIS_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ENABLED = 'DD_TRACE_REDIS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_REDIS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_REDIS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REDIS_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_REDIS_ANALYTICS_SAMPLE_RATE'.freeze
         METRIC_PIPELINE_LEN = 'redis.pipeline_length'.freeze
         SERVICE_NAME = 'redis'.freeze
         SPAN_COMMAND = 'redis.command'.freeze

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

@@ -9,18 +9,20 @@ module Datadog
       class Integration
         include Contrib::Integration
 
+        MINIMUM_VERSION = Gem::Version.new('3.2')
+
         register_as :redis, auto_patch: true
 
         def self.version
           Gem.loaded_specs['redis'] && Gem.loaded_specs['redis'].version
         end
 
-        def self.present?
-          super && defined?(::Redis)
+        def self.loaded?
+          !defined?(::Redis).nil?
         end
 
         def self.compatible?
-          !version.nil? && version >= Gem::Version.new('3.0.0')
+          super && version >= MINIMUM_VERSION
         end
 
         def default_configuration
@@ -30,6 +32,10 @@ module Datadog
         def patcher
           Patcher
         end
+
+        def resolver
+          @resolver ||= Configuration::Resolver.new
+        end
       end
     end
   end

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

@@ -1,5 +1,6 @@
 require 'ddtrace/contrib/patcher'
 require 'ddtrace/contrib/redis/ext'
+require 'ddtrace/contrib/redis/configuration/resolver'
 
 module Datadog
   module Contrib
@@ -10,25 +11,19 @@ module Datadog
 
         module_function
 
-        def patched?
-          done?(:redis)
+        def target_version
+          Integration.version
         end
 
         # patch applies our patch if needed
         def patch
-          do_once(:redis) do
-            begin
-              # do not require these by default, but only when actually patching
-              require 'redis'
-              require 'ddtrace/ext/app_types'
-              require 'ddtrace/contrib/redis/tags'
-              require 'ddtrace/contrib/redis/quantize'
-
-              patch_redis_client
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Redis integration: #{e}")
-            end
-          end
+          # do not require these by default, but only when actually patching
+          require 'redis'
+          require 'ddtrace/ext/app_types'
+          require 'ddtrace/contrib/redis/tags'
+          require 'ddtrace/contrib/redis/quantize'
+
+          patch_redis_client
         end
 
         # rubocop:disable Metrics/MethodLength
@@ -78,16 +73,24 @@ module Datadog
             def datadog_pin
               @datadog_pin ||= begin
                 pin = Datadog::Pin.new(
-                  Datadog.configuration[:redis][:service_name],
+                  datadog_configuration[:service_name],
                   app: Ext::APP,
                   app_type: Datadog::Ext::AppTypes::DB,
-                  tracer: Datadog.configuration[:redis][:tracer]
+                  tracer: -> { datadog_configuration[:tracer] }
                 )
                 pin.onto(self)
               end
             end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration[:redis, options]
+            end
           end
         end
+        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/BlockLength
       end
     end
   end

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

@@ -15,7 +15,7 @@ module Datadog
           str = Utils.utf8_encode(str, binary: true, placeholder: PLACEHOLDER)
           Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
         rescue => e
-          Datadog::Tracer.log.debug("non formattable Redis arg #{str}: #{e}")
+          Datadog.logger.debug("non formattable Redis arg #{str}: #{e}")
           PLACEHOLDER
         end
 

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

@@ -0,0 +1,159 @@
+require 'uri'
+
+# NOTE: This code is copied directly from Redis.
+#       Its purpose is to resolve connection information.
+#       It exists here only because it doesn't exist in the redis
+#       library as a separated module and it allows to avoid
+#       instantiating a new Redis::Client for resolving the connection
+module Datadog
+  module Contrib
+    module Redis
+      module Vendor
+        class Resolver # :nodoc:
+          # Connection DEFAULTS for a Redis::Client are unchanged for
+          # the integration supported options.
+          # https://github.com/redis/redis-rb/blob/v3.0.0/lib/redis/client.rb#L6-L14
+          # https://github.com/redis/redis-rb/blob/v4.1.3/lib/redis/client.rb#L10-L26
+          # Since the integration takes in consideration only few attributes, all
+          # versions are compatible for :url, :scheme, :host, :port, :db
+          DEFAULTS = {
+            url: -> { ENV['REDIS_URL'] },
+            scheme: 'redis',
+            host: '127.0.0.1',
+            port: 6379,
+            path: nil,
+            # :timeout => 5.0,
+            password: nil,
+            db: 0 # ,
+            # :driver => nil,
+            # :id => nil,
+            # :tcp_keepalive => 0,
+            # :reconnect_attempts => 1,
+            # :reconnect_delay => 0,
+            # :reconnect_delay_max => 0.5,
+            # :inherit_socket => false
+          }.freeze
+
+          def resolve(options)
+            _parse_options(options)
+          end
+
+          # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
+          # rubocop:disable Metrics/PerceivedComplexity
+          #
+          # This method is a subset of the implementation provided in v3.0.0
+          # https://github.com/redis/redis-rb/blob/v3.0.0/lib/redis/client.rb
+          # https://github.com/redis/redis-rb/blob/v4.1.3/lib/redis/client.rb
+          #
+          # Since it has been backported from the original gem, some linting
+          # cops have been disabled
+          def _parse_options(options)
+            # https://github.com/redis/redis-rb/blob/v4.1.3/lib/redis/client.rb#L404
+            # Early return for modern client options
+            return options if options[:_parsed]
+
+            defaults = DEFAULTS.dup
+            options = options.dup
+
+            defaults.keys.each do |key|
+              # Fill in defaults if needed
+              if defaults[key].respond_to?(:call)
+                defaults[key] = defaults[key].call
+              end
+
+              # Symbolize only keys that are needed
+              options[key] = options[key.to_s] if options.key?(key.to_s)
+            end
+
+            url = options[:url]
+            url = defaults[:url] if url.nil?
+
+            # Override defaults from URL if given
+            if url
+              uri = URI(url)
+
+              if uri.scheme == 'unix'
+                defaults[:path] = uri.path
+              elsif uri.scheme == 'redis' || uri.scheme == 'rediss'
+                defaults[:scheme]   = uri.scheme
+                defaults[:host]     = uri.host if uri.host
+                defaults[:port]     = uri.port if uri.port
+                defaults[:password] = CGI.unescape(uri.password) if uri.password
+                defaults[:db]       = uri.path[1..-1].to_i if uri.path
+                defaults[:role] = :master
+              else
+                raise ArgumentError, "invalid uri scheme '#{uri.scheme}'"
+              end
+
+              # defaults[:ssl] = true if uri.scheme == "rediss"
+            end
+
+            # Use default when option is not specified or nil
+            defaults.keys.each do |key|
+              options[key] = defaults[key] if options[key].nil?
+            end
+
+            if options[:path]
+              # Unix socket
+              options[:scheme] = 'unix'
+              options.delete(:host)
+              options.delete(:port)
+            else
+              # TCP socket
+              options[:host] = options[:host].to_s
+              options[:port] = options[:port].to_i
+            end
+
+            # Options ignored by the integration
+            #
+            # if options.has_key?(:timeout)
+            #   options[:connect_timeout] ||= options[:timeout]
+            #   options[:read_timeout]    ||= options[:timeout]
+            #   options[:write_timeout]   ||= options[:timeout]
+            # end
+
+            # options[:connect_timeout] = Float(options[:connect_timeout])
+            # options[:read_timeout]    = Float(options[:read_timeout])
+            # options[:write_timeout]   = Float(options[:write_timeout])
+
+            # options[:reconnect_attempts] = options[:reconnect_attempts].to_i
+            # options[:reconnect_delay] = options[:reconnect_delay].to_f
+            # options[:reconnect_delay_max] = options[:reconnect_delay_max].to_f
+
+            options[:db] = options[:db].to_i
+            # options[:driver] = _parse_driver(options[:driver]) || Connection.drivers.last
+
+            # case options[:tcp_keepalive]
+            # when Hash
+            #   [:time, :intvl, :probes].each do |key|
+            #     unless options[:tcp_keepalive][key].is_a?(Integer)
+            #       raise "Expected the #{key.inspect} key in :tcp_keepalive to be an Integer"
+            #     end
+            #   end
+
+            # when Integer
+            #   if options[:tcp_keepalive] >= 60
+            #     options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 20, :intvl => 10, :probes => 2}
+
+            #   elsif options[:tcp_keepalive] >= 30
+            #     options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 10, :intvl => 5, :probes => 2}
+
+            #   elsif options[:tcp_keepalive] >= 5
+            #     options[:tcp_keepalive] = {:time => options[:tcp_keepalive] - 2, :intvl => 2, :probes => 1}
+            #   end
+            # end
+
+            options[:_parsed] = true
+
+            options
+          end
+
+          # rubocop:enable Metrics/AbcSize
+          # rubocop:enable Metrics/MethodLength
+          # rubocop:enable Metrics/PerceivedComplexity
+        end
+      end
+    end
+  end
+end

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

@@ -7,13 +7,18 @@ module Datadog
       module Configuration
         # Custom settings for the Resque 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