ddtrace 0.52.0 → 1.8.0

data/lib/datadog/tracing/contrib/redis/quantize.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# typed: true
+
+require 'set'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        # Quantize contains Redis-specific resource quantization tools.
+        module Quantize
+          PLACEHOLDER = '?'
+          TOO_LONG_MARK = '...'
+          VALUE_MAX_LEN = 50
+          CMD_MAX_LEN = 500
+
+          AUTH_COMMANDS = %w[AUTH auth].freeze
+
+          MULTI_VERB_COMMANDS = Set.new(
+            %w[
+              ACL
+              CLIENT
+              CLUSTER
+              COMMAND
+              CONFIG
+              DEBUG
+              LATENCY
+              MEMORY
+            ]
+          ).freeze
+
+          module_function
+
+          def format_arg(arg)
+            str = Core::Utils.utf8_encode(arg, binary: true, placeholder: PLACEHOLDER)
+            Core::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)
+
+            verb, *args = command_args.map { |x| format_arg(x) }
+            Core::Utils.truncate("#{verb.upcase} #{args.join(' ')}", 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)
+
+            verb = command_args.first.to_s.upcase
+            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?
+
+            verb = command_args.first.to_s
+            AUTH_COMMANDS.include?(verb)
+          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
+end

data/lib/datadog/tracing/contrib/redis/tags.rb

@@ -0,0 +1,56 @@
+# typed: true
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        # Tags handles generic common tags assignment.
+        module Tags
+          class << self
+            def set_common_tags(client, span, show_command_args)
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
+
+              # Tag as an external peer service
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, span.service)
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, client.host)
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+
+              # Set analytics sample rate
+              Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+              span.set_tag Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM
+
+              span.set_tag Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, client.host
+              span.set_tag Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, client.port
+
+              span.set_tag Ext::TAG_DATABASE_INDEX, client.db.to_s
+              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.tracing[:redis]
+            end
+
+            def analytics_enabled?
+              Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+            end
+
+            def analytics_sample_rate
+              datadog_configuration[:analytics_sample_rate]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/redis/trace_middleware.rb

@@ -0,0 +1,72 @@
+# typed: false
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'quantize'
+require_relative 'tags'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        # Instrumentation for Redis 5+
+        module TraceMiddleware
+          def call(commands, redis_config)
+            Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
+              datadog_configuration = resolve(redis_config)
+              resource = get_command(commands, datadog_configuration[:command_args])
+
+              span.service = datadog_configuration[:service_name]
+              span.span_type = Contrib::Redis::Ext::TYPE
+              span.resource = resource
+
+              Contrib::Redis::Tags.set_common_tags(redis_config, span, datadog_configuration[:command_args])
+
+              super
+            end
+          end
+
+          def call_pipelined(commands, redis_config)
+            Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
+              datadog_configuration = resolve(redis_config)
+              pipelined_commands = get_pipeline_commands(commands, datadog_configuration[:command_args])
+
+              span.service = datadog_configuration[:service_name]
+              span.span_type = Contrib::Redis::Ext::TYPE
+              span.resource = pipelined_commands.join("\n")
+              span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, pipelined_commands.length
+
+              Contrib::Redis::Tags.set_common_tags(redis_config, span, datadog_configuration[:command_args])
+
+              super
+            end
+          end
+
+          private
+
+          def get_command(commands, boolean)
+            if boolean
+              Contrib::Redis::Quantize.format_command_args(commands)
+            else
+              Contrib::Redis::Quantize.get_verb(commands)
+            end
+          end
+
+          def get_pipeline_commands(commands, boolean)
+            if boolean
+              commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
+            else
+              commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
+            end
+          end
+
+          def resolve(redis_config)
+            custom = redis_config.custom[:datadog] || {}
+
+            Datadog.configuration.tracing[:redis, redis_config.server_url].to_h.merge(custom)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/redis/vendor/resolver.rb

@@ -0,0 +1,162 @@
+# 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 Tracing
+    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
+end

data/lib/datadog/tracing/contrib/registerable.rb

@@ -0,0 +1,50 @@
+# typed: false
+
+module Datadog
+  module Tracing
+    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
+        # @public_api
+        module ClassMethods
+          # Registers this integration in the global tracer registry.
+          # Once registered, this integration can be activated with:
+          #
+          # ```
+          # Datadog.configure do |c|
+          #   c.tracing.instrument :name
+          # end
+          # ```
+          #
+          # @param [Symbol] name integration name. Used during activation.
+          # @param [Datadog::Tracing::Contrib::Registry] registry a custom registry.
+          #        Defaults to the global tracing registry.
+          # @param [Boolean] auto_patch will this integration be activated during
+          #   {file:docs/AutoInstrumentation.md Auto Instrumentation}?
+          # @param [Hash] options additional keyword options passed to the initializer of
+          #   a custom {Registerable} instrumentation
+          # @see Datadog::Tracing::Contrib::Integration
+          def register_as(name, registry: Contrib::REGISTRY, auto_patch: false, **options)
+            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
+end

data/lib/datadog/tracing/contrib/registry.rb

@@ -0,0 +1,52 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Registry is a collection of tracing integrations.
+      # @public_api
+      class Registry
+        include Enumerable
+
+        Entry = Struct.new(:name, :klass, :auto_patch)
+
+        # @!visibility private
+        def initialize
+          @data = {}
+          @mutex = Mutex.new
+        end
+
+        # @param name [Symbol] instrumentation name, to be used when activating this integration
+        # @param klass [Object] instrumentation implementation
+        # @param auto_patch [Boolean] is the tracer allowed to automatically patch
+        #   the host application with this instrumentation?
+        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
+end

data/lib/datadog/tracing/contrib/resque/configuration/settings.rb

@@ -0,0 +1,37 @@
+# typed: false
+
+require_relative '../../../span_operation'
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        module Configuration
+          # Custom settings for the Resque integration
+          # @public_api
+          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.lazy
+            end
+
+            option :analytics_sample_rate do |o|
+              o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+              o.lazy
+            end
+
+            option :service_name
+            option :error_handler, default: Tracing::SpanOperation::Events::DEFAULT_ON_ERROR
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/resque/ext.rb

@@ -0,0 +1,21 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        # Resque integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_RESQUE_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RESQUE_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RESQUE_ANALYTICS_SAMPLE_RATE'.freeze
+          SERVICE_NAME = 'resque'.freeze
+          SPAN_JOB = 'resque.job'.freeze
+          TAG_COMPONENT = 'resque'.freeze
+          TAG_OPERATION_JOB = 'job'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/resque/integration.rb

@@ -0,0 +1,48 @@
+# typed: false
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        # Description of Resque integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('1.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :resque, auto_patch: true
+
+          def self.version
+            Gem.loaded_specs['resque'] && Gem.loaded_specs['resque'].version
+          end
+
+          def self.loaded?
+            !defined?(::Resque).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+
+          class << self
+            # Globally-acccesible reference for pre-forking optimization
+            attr_accessor :sync_writer
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/resque/patcher.rb

@@ -0,0 +1,29 @@
+# typed: false
+
+require_relative '../patcher'
+require_relative '../sidekiq/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Resque
+        # Patcher enables patching of 'resque' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'resque_job'
+
+            ::Resque::Job.prepend(Resque::Job)
+          end
+        end
+      end
+    end
+  end
+end