ddtrace 0.13.0 → 0.47.0

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

@@ -1,62 +1,36 @@
-# requirements should be kept minimal as Patcher is a shared requirement.
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/redis/ext'
+require 'ddtrace/contrib/redis/configuration/resolver'
 
 module Datadog
   module Contrib
     module Redis
-      SERVICE = 'redis'.freeze
-      DRIVER = 'redis.driver'.freeze
-
       # Patcher enables patching of 'redis' module.
       module Patcher
-        include Base
-        register_as :redis, auto_patch: true
-        option :service_name, default: SERVICE
-        option :tracer, default: Datadog.tracer
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
+        def target_version
+          Integration.version
+        end
+
         # patch applies our patch if needed
         def patch
-          if !@patched && compatible?
-            begin
-              # do not require these by default, but only when actually patching
-              require 'ddtrace/ext/app_types'
-              require 'ddtrace/contrib/redis/tags'
-              require 'ddtrace/contrib/redis/quantize'
-
-              patch_redis_client
-              @patched = true
-              RailsCachePatcher.reload_cache_store if Datadog.registry[:rails].patched?
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Redis integration: #{e}")
-            end
-          end
-          @patched
-        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'
 
-        def compatible?
-          defined?(::Redis::VERSION) && Gem::Version.new(::Redis::VERSION) >= Gem::Version.new('3.0.0')
+          patch_redis_client
         end
 
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/BlockLength
+        # rubocop:disable Metrics/AbcSize
         def patch_redis_client
           ::Redis::Client.class_eval do
-            alias_method :initialize_without_datadog, :initialize
-            Datadog::Patcher.without_warnings do
-              remove_method :initialize
-            end
-
-            def initialize(*args)
-              service = Datadog.configuration[:redis][:service_name]
-              tracer = Datadog.configuration[:redis][:tracer]
-              pin = Datadog::Pin.new(service, app: 'redis', app_type: Datadog::Ext::AppTypes::DB, tracer: tracer)
-              pin.onto(self)
-              initialize_without_datadog(*args)
-            end
-
             alias_method :call_without_datadog, :call
             remove_method :call
             def call(*args, &block)
@@ -64,10 +38,10 @@ module Datadog
               return call_without_datadog(*args, &block) unless pin && pin.tracer
 
               response = nil
-              pin.tracer.trace('redis.command') do |span|
+              pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
                 span.service = pin.service
-                span.span_type = Datadog::Ext::Redis::TYPE
-                span.resource = Datadog::Contrib::Redis::Quantize.format_command_args(*args)
+                span.span_type = Datadog::Contrib::Redis::Ext::TYPE
+                span.resource = get_command(args)
                 Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
 
                 response = call_without_datadog(*args, &block)
@@ -83,26 +57,57 @@ module Datadog
               return call_pipeline_without_datadog(*args, &block) unless pin && pin.tracer
 
               response = nil
-              pin.tracer.trace('redis.command') do |span|
+              pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
                 span.service = pin.service
-                span.span_type = Datadog::Ext::Redis::TYPE
-                commands = args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
+                span.span_type = Datadog::Contrib::Redis::Ext::TYPE
+                commands = get_pipeline_commands(args)
                 span.resource = commands.join("\n")
+                span.set_metric Datadog::Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
                 Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
-                span.set_metric Datadog::Ext::Redis::PIPELINE_LEN, commands.length
 
                 response = call_pipeline_without_datadog(*args, &block)
               end
 
               response
             end
-          end
-        end
 
-        # patched? tells wether patch has been successfully applied
-        def patched?
-          @patched
+            def datadog_pin
+              @datadog_pin ||= begin
+                pin = Datadog::Pin.new(
+                  datadog_configuration[:service_name],
+                  app: Ext::APP,
+                  app_type: Datadog::Ext::AppTypes::DB,
+                  tracer: -> { datadog_configuration[:tracer] }
+                )
+                pin.onto(self)
+              end
+            end
+
+            private
+
+            def get_command(args)
+              if datadog_configuration[:command_args]
+                Datadog::Contrib::Redis::Quantize.format_command_args(*args)
+              else
+                Datadog::Contrib::Redis::Quantize.get_verb(*args)
+              end
+            end
+
+            def get_pipeline_commands(args)
+              if datadog_configuration[:command_args]
+                args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
+              else
+                args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.get_verb(c) }
+              end
+            end
+
+            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

@@ -1,3 +1,5 @@
+require 'set'
+
 module Datadog
   module Contrib
     module Redis
@@ -8,6 +10,19 @@ module Datadog
         VALUE_MAX_LEN = 50
         CMD_MAX_LEN = 500
 
+        MULTI_VERB_COMMANDS = Set.new(
+          %w[
+            ACL
+            CLIENT
+            CLUSTER
+            COMMAND
+            CONFIG
+            DEBUG
+            LATENCY
+            MEMORY
+          ]
+        ).freeze
+
         module_function
 
         def format_arg(arg)
@@ -15,14 +30,45 @@ 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
 
         def format_command_args(command_args)
+          command_args = resolve_command_args(command_args)
+          return 'AUTH ?' if auth_command?(command_args)
+
           cmd = command_args.map { |x| format_arg(x) }.join(' ')
           Utils.truncate(cmd, CMD_MAX_LEN, TOO_LONG_MARK)
         end
+
+        def get_verb(command_args)
+          return unless command_args.is_a?(Array)
+
+          return get_verb(command_args.first) if command_args.first.is_a?(Array)
+
+          arg = command_args.first
+          verb = arg.is_a?(Symbol) ? arg.to_s.upcase : arg.to_s
+          return verb unless MULTI_VERB_COMMANDS.include?(verb) && command_args[1]
+
+          "#{verb} #{command_args[1]}"
+        end
+
+        def auth_command?(command_args)
+          return false unless command_args.is_a?(Array) && !command_args.empty?
+
+          command_args.first.to_sym == :auth
+        end
+
+        # Unwraps command array when Redis is called with the following syntax:
+        #   redis.call([:cmd, 'arg1', ...])
+        def resolve_command_args(command_args)
+          return command_args.first if command_args.is_a?(Array) && command_args.first.is_a?(Array)
+
+          command_args
+        end
+
+        private_class_method :auth_command?, :resolve_command_args
       end
     end
   end

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

@@ -1,18 +1,44 @@
+require 'ddtrace/ext/integration'
 require 'ddtrace/ext/net'
-require 'ddtrace/ext/redis'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/redis/ext'
 
 module Datadog
   module Contrib
     module Redis
       # Tags handles generic common tags assignment.
       module Tags
-        module_function
+        class << self
+          def set_common_tags(client, span)
+            # Tag as an external peer service
+            span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
 
-        def set_common_tags(client, span)
-          span.set_tag Datadog::Ext::NET::TARGET_HOST, client.host
-          span.set_tag Datadog::Ext::NET::TARGET_PORT, client.port
-          span.set_tag Datadog::Ext::Redis::DB, client.db
-          span.set_tag Datadog::Ext::Redis::RAW_COMMAND, span.resource
+            # Set analytics sample rate
+            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+            span.set_tag Datadog::Ext::NET::TARGET_HOST, client.host
+            span.set_tag Datadog::Ext::NET::TARGET_PORT, client.port
+            span.set_tag Ext::TAG_DB, client.db
+            span.set_tag Ext::TAG_RAW_COMMAND, span.resource if show_command_args?
+          end
+
+          private
+
+          def datadog_configuration
+            Datadog.configuration[:redis]
+          end
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            datadog_configuration[:analytics_sample_rate]
+          end
+
+          def show_command_args?
+            datadog_configuration[:command_args]
+          end
         end
       end
     end

data/lib/ddtrace/contrib/redis/vendor/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ezra Zygmuntowicz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

@@ -0,0 +1,158 @@
+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.each_key do |key|
+              # Fill in defaults if needed
+              defaults[key] = defaults[key].call if defaults[key].respond_to?(:call)
+
+              # 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)
+
+              case uri.scheme
+              when 'unix'
+                defaults[:path] = uri.path
+              when 'redis', '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.each_key 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