ddtrace 0.52.0 → 1.8.0

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

@@ -1,46 +0,0 @@
-# typed: true
-require 'ddtrace/contrib/redis/vendor/resolver'
-
-module Datadog
-  module Contrib
-    module Redis
-      module Configuration
-        UNIX_SCHEME = 'unix'.freeze
-
-        # Converts String URLs and Hashes to a normalized connection settings Hash.
-        class Resolver < Contrib::Configuration::Resolver
-          # @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(matcher))
-          end
-
-          def normalize(hash)
-            return { url: hash[:url] } if hash[:scheme] == UNIX_SCHEME
-
-            # 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

@@ -1,36 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/redis/ext'
-
-module Datadog
-  module Contrib
-    module Redis
-      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, 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, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-
-          option :command_args do |o|
-            o.default { env_to_bool(Ext::ENV_COMMAND_ARGS, true) }
-            o.lazy
-          end
-
-          option :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module Redis
-      # Redis integration constants
-      module Ext
-        APP = 'redis'.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
-        ENV_COMMAND_ARGS = 'DD_REDIS_COMMAND_ARGS'.freeze
-        METRIC_PIPELINE_LEN = 'redis.pipeline_length'.freeze
-        SERVICE_NAME = 'redis'.freeze
-        SPAN_COMMAND = 'redis.command'.freeze
-        TAG_DB = 'out.redis_db'.freeze
-        TAG_RAW_COMMAND = 'redis.raw_command'.freeze
-        TYPE = 'redis'.freeze
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/redis/configuration/settings'
-require 'ddtrace/contrib/redis/patcher'
-
-module Datadog
-  module Contrib
-    module Redis
-      # Description of Redis integration
-      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.loaded?
-          !defined?(::Redis).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-
-        def resolver
-          @resolver ||= Configuration::Resolver.new
-        end
-      end
-    end
-  end
-end

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

@@ -1,115 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/contrib/redis/ext'
-require 'ddtrace/contrib/redis/configuration/resolver'
-
-module Datadog
-  module Contrib
-    module Redis
-      # Patcher enables patching of 'redis' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        # patch applies our patch if needed
-        def patch
-          # 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
-        # rubocop:disable Metrics/BlockLength
-        # rubocop:disable Metrics/AbcSize
-        def patch_redis_client
-          ::Redis::Client.class_eval do
-            alias_method :call_without_datadog, :call
-            remove_method :call
-            def call(*args, &block)
-              pin = Datadog::Pin.get_from(self)
-              return call_without_datadog(*args, &block) unless pin && pin.tracer
-
-              response = nil
-              pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = pin.service
-                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)
-              end
-
-              response
-            end
-
-            alias_method :call_pipeline_without_datadog, :call_pipeline
-            remove_method :call_pipeline
-            def call_pipeline(*args, &block)
-              pin = Datadog::Pin.get_from(self)
-              return call_pipeline_without_datadog(*args, &block) unless pin && pin.tracer
-
-              response = nil
-              pin.tracer.trace(Datadog::Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = pin.service
-                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)
-
-                response = call_pipeline_without_datadog(*args, &block)
-              end
-
-              response
-            end
-
-            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
-end

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

@@ -1,76 +0,0 @@
-# typed: true
-require 'set'
-
-module Datadog
-  module Contrib
-    module Redis
-      # Quantize contains Redis-specific resource quantization tools.
-      module Quantize
-        PLACEHOLDER = '?'.freeze
-        TOO_LONG_MARK = '...'.freeze
-        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)
-          str = arg.is_a?(Symbol) ? arg.to_s.upcase : arg.to_s
-          str = Utils.utf8_encode(str, binary: true, placeholder: PLACEHOLDER)
-          Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
-        rescue => 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
-end

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

@@ -1,47 +0,0 @@
-# typed: true
-require 'ddtrace/ext/integration'
-require 'ddtrace/ext/net'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/redis/ext'
-
-module Datadog
-  module Contrib
-    module Redis
-      # Tags handles generic common tags assignment.
-      module Tags
-        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)
-
-            # 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
-  end
-end

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

@@ -1,159 +0,0 @@
-# typed: false
-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

data/lib/ddtrace/contrib/registerable.rb

@@ -1,34 +0,0 @@
-# typed: false
-require 'datadog/contrib'
-
-module Datadog
-  module Contrib
-    # Defines registerable behavior for integrations
-    module Registerable
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.include(InstanceMethods)
-      end
-
-      # Class methods for registerable behavior
-      module ClassMethods
-        def register_as(name, options = {})
-          registry = options.fetch(:registry, Contrib::REGISTRY)
-          auto_patch = options.fetch(:auto_patch, false)
-
-          registry.add(name, new(name, options), auto_patch)
-        end
-      end
-
-      # Instance methods for registerable behavior
-      module InstanceMethods
-        attr_reader \
-          :name
-
-        def initialize(name, options = {})
-          @name = name
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/registry.rb

@@ -1,43 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    # Registry is a collection of integrations.
-    class Registry
-      include Enumerable
-
-      Entry = Struct.new(:name, :klass, :auto_patch)
-
-      def initialize
-        @data = {}
-        @mutex = Mutex.new
-      end
-
-      def add(name, klass, auto_patch = false)
-        @mutex.synchronize do
-          @data[name] = Entry.new(name, klass, auto_patch).freeze
-        end
-      end
-
-      def each(&block)
-        @mutex.synchronize do
-          @data.each_value(&block)
-        end
-      end
-
-      def [](name)
-        @mutex.synchronize do
-          entry = @data[name]
-          entry.klass if entry
-        end
-      end
-
-      def to_h
-        @mutex.synchronize do
-          @data.each_with_object({}) do |(_, entry), hash|
-            hash[entry.name] = entry.auto_patch
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/resque/ext'
-
-module Datadog
-  module Contrib
-    module Resque
-      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, 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, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-
-          option :service_name, default: Ext::SERVICE_NAME
-
-          # A list Ruby worker classes to be instrumented.
-          # The value of `nil` has special semantics: it instruments all workers dynamically.
-          #
-          # TODO: 1.0: Automatic patching should be the default behavior.
-          # We should not provide this option in the future,
-          # as our integrations should always instrument all possible scenarios when feasible.
-          option :workers, default: nil do |o|
-            o.on_set do |value|
-              unless value.nil?
-                Datadog.logger.warn(
-                  "DEPRECATED: Resque integration now instruments all workers. \n" \
-                  'The `workers:` option is unnecessary and will be removed in the future.'
-                )
-              end
-            end
-          end
-          option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
-        end
-      end
-    end
-  end
-end