datadog 2.0.0.beta1

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rake
+        # Rake integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_RAKE_ENABLED'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAKE_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RAKE_ANALYTICS_SAMPLE_RATE'
+          SERVICE_NAME = 'rake'
+          SPAN_INVOKE = 'rake.invoke'
+          SPAN_EXECUTE = 'rake.execute'
+          TAG_EXECUTE_ARGS = 'rake.execute.args'
+          TAG_INVOKE_ARGS = 'rake.invoke.args'
+          TAG_TASK_ARG_NAMES = 'rake.task.arg_names'
+          TAG_COMPONENT = 'rake'
+          TAG_OPERATION_EXECUTE = 'execute'
+          TAG_OPERATION_INVOKE = 'invoke'
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rake/instrumentation.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative '../utils/quantization/hash'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rake
+        # Instrumentation for Rake tasks
+        module Instrumentation
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # Instance methods for Rake instrumentation
+          module InstanceMethods
+            def invoke(*args)
+              return super if !enabled? || !instrumented_task?
+
+              Tracing.trace(Ext::SPAN_INVOKE, **span_options) do |span|
+                annotate_invoke!(span, args)
+                super
+              end
+            ensure
+              shutdown_tracer!
+            end
+
+            def execute(args = nil)
+              return super if !enabled? || !instrumented_task?
+
+              Tracing.trace(Ext::SPAN_EXECUTE, **span_options) do |span|
+                annotate_execute!(span, args)
+                super
+              end
+            ensure
+              shutdown_tracer!
+            end
+
+            private
+
+            # Task names are verified dynamically, in order to be agnostic of
+            # when tracing is configured in relation to Rake task declaration.
+            def instrumented_task?
+              configuration[:tasks].include?(name)
+            end
+
+            def shutdown_tracer!
+              Tracing.shutdown! if Tracing.active_span.nil? && ::Rake.application.top_level_tasks.include?(name)
+            end
+
+            def annotate_invoke!(span, args)
+              span.resource = name
+              # Set analytics sample rate
+              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(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_INVOKE)
+              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.logger.debug("Error while tracing Rake invoke: #{e.class.name} #{e.message}")
+            end
+
+            def annotate_execute!(span, args)
+              span.resource = name
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_EXECUTE)
+              span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
+            rescue StandardError => e
+              Datadog.logger.debug("Error while tracing Rake execute: #{e.class.name} #{e.message}")
+            end
+
+            def quantize_args(args)
+              quantize_options = configuration[:quantize][:args]
+              Contrib::Utils::Quantization::Hash.format(args, quantize_options)
+            end
+
+            def enabled?
+              Datadog.configuration.tracing.enabled && \
+                configuration[:enabled] == true
+            end
+
+            def span_options
+              { service: configuration[:service_name] }
+            end
+
+            def configuration
+              Datadog.configuration.tracing[:rake]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rake
+        # Description of Rake integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('12.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :rake
+
+          def self.version
+            Gem.loaded_specs['rake'] && Gem.loaded_specs['rake'].version
+          end
+
+          def self.loaded?
+            !defined?(::Rake::Task).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rake
+        # Patcher enables patching of 'rake' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            # Add instrumentation patch to Rake task
+            ::Rake::Task.include(Instrumentation)
+          end
+
+          def get_option(option)
+            Datadog.configuration.tracing[:rake].get_option(option)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../vendor/resolver'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        module Configuration
+          UNIX_SCHEME = 'unix'
+
+          # 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 ||= Vendor::Resolver.new
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        module Configuration
+          # Custom settings for the Redis integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :command_args do |o|
+              o.type :bool
+              o.env Ext::ENV_COMMAND_ARGS
+              o.default false
+            end
+
+            option :service_name do |o|
+              o.default do
+                Contrib::SpanAttributeSchema.fetch_service_name(
+                  Ext::ENV_SERVICE_NAME,
+                  Ext::DEFAULT_PEER_SERVICE_NAME
+                )
+              end
+            end
+
+            option :peer_service do |o|
+              o.type :string, nilable: true
+              o.env Ext::ENV_PEER_SERVICE
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        # Redis integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_REDIS_ENABLED'
+          ENV_SERVICE_NAME = 'DD_TRACE_REDIS_SERVICE_NAME'
+          ENV_PEER_SERVICE = 'DD_TRACE_REDIS_PEER_SERVICE'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_REDIS_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REDIS_ANALYTICS_SAMPLE_RATE'
+          ENV_COMMAND_ARGS = 'DD_REDIS_COMMAND_ARGS'
+          METRIC_PIPELINE_LEN = 'redis.pipeline_length'
+          DEFAULT_PEER_SERVICE_NAME = 'redis'
+          SPAN_COMMAND = 'redis.command'
+          TAG_DB = 'out.redis_db'
+          TAG_RAW_COMMAND = 'redis.raw_command'
+          TYPE = 'redis'
+          TAG_COMPONENT = 'redis'
+          TAG_OPERATION_COMMAND = 'command'
+          TAG_SYSTEM = 'redis'
+          TAG_DATABASE_INDEX = 'db.redis.database_index'
+          PEER_SERVICE_SOURCES = Array[
+            Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
+            Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'configuration/resolver'
+require_relative 'ext'
+require_relative 'quantize'
+require_relative 'tags'
+require_relative 'trace_middleware'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        # Instrumentation for Redis < 5
+        module Instrumentation
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # InstanceMethods - implementing instrumentation
+          module InstanceMethods
+            def call(*args, &block)
+              TraceMiddleware.call(self, args[0], service_name, command_args?) { super }
+            end
+
+            def call_pipeline(*args, &block)
+              TraceMiddleware.call_pipelined(self, args[0].commands, service_name, command_args?) { super }
+            end
+
+            private
+
+            def command_args?
+              pinned = Datadog.configuration_for(self, :command_args)
+
+              return pinned unless pinned.nil?
+
+              datadog_configuration[:command_args]
+            end
+
+            def service_name
+              Datadog.configuration_for(self, :service_name) ||
+                datadog_configuration[:service_name]
+            end
+
+            def datadog_configuration
+              Datadog.configuration.tracing[:redis, options]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        # Description of Redis integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('3.2')
+
+          # Support `Config#custom`
+          # https://github.com/redis-rb/redis-client/blob/master/CHANGELOG.md#0110
+          REDISCLIENT_MINIMUM_VERSION = Gem::Version.new('0.11.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :redis, auto_patch: true
+
+          # Until Redis 4, all instrumentation happened in one gem: redis.
+          # Since Redis 5, instrumentation happens in a separate gem: redis-client.
+          # Because Redis 4 does not depend on redis-client, it's possible for both gems to be installed at the same time.
+          # For example, if Sidekiq 7 and Redis 4 are installed: both redis and redis-client will be installed.
+          # If redis-client and redis > 5 are installed, than they will be in sync, and only redis-client will be installed.
+          def self.version
+            redis_version || redis_client_version
+          end
+
+          def self.redis_version
+            Gem.loaded_specs['redis'] && Gem.loaded_specs['redis'].version
+          end
+
+          def self.redis_client_version
+            Gem.loaded_specs['redis-client'] && Gem.loaded_specs['redis-client'].version
+          end
+
+          def self.loaded?
+            redis_loaded? || redis_client_loaded?
+          end
+
+          def self.redis_loaded?
+            !defined?(::Redis).nil?
+          end
+
+          def self.redis_client_loaded?
+            !defined?(::RedisClient).nil?
+          end
+
+          def self.compatible?
+            super && (redis_compatible? || redis_client_compatible?)
+          end
+
+          def self.redis_compatible?
+            !!(redis_version && redis_version >= MINIMUM_VERSION)
+          end
+
+          def self.redis_client_compatible?
+            !!(redis_client_version && redis_client_version >= REDISCLIENT_MINIMUM_VERSION)
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+
+          def resolver
+            @resolver ||= Configuration::Resolver.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'configuration/resolver'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        # Patcher enables patching of 'redis' module.
+        module Patcher
+          include Contrib::Patcher
+
+          # Patch for redis instance (with redis < 5)
+          module DatadogPinPatch
+            def self.included(base)
+              base.prepend(InstanceMethods)
+            end
+
+            # Instance method patch for redis instance
+            module InstanceMethods
+              def datadog_pin=(pin)
+                pin.onto(datadog_target)
+              end
+
+              def datadog_target
+                # For `redis-rb` 4.x
+                return _client if respond_to?(:_client)
+                # For `redis-rb` 3.x
+                return client if respond_to?(:client)
+
+                Datadog.logger.warn 'Fail to apply configuration on redis client instance with '  \
+                                                        '`Datadog.configure_onto(redis)`.'
+
+                # Null object instead of raising error
+                self
+              end
+            end
+          end
+
+          # Patch for redis instance (with redis >= 5)
+          module NotSupportedNoticePatch
+            def self.included(base)
+              base.prepend(InstanceMethods)
+            end
+
+            # Instance method patch for redis instance
+            module InstanceMethods
+              def datadog_pin=(_pin)
+                Datadog.logger.warn \
+                  '`Datadog.configure_onto(redis)` is not supported on Redis 5+. To instrument '\
+                  "a redis instance with custom configuration, please initialize it with:\n"\
+                  "  `Redis.new(..., custom: { datadog: { service_name: 'my-service' } })`.\n\n" \
+                  'See: https://github.com/DataDog/dd-trace-rb/blob/master/docs/GettingStarted.md#redis'
+              end
+            end
+          end
+
+          module_function
+
+          def default_tags
+            [].tap do |tags|
+              tags << "target_redis_version:#{Integration.redis_version}"               if Integration.redis_version
+              tags << "target_redis_client_version:#{Integration.redis_client_version}" if Integration.redis_client_version
+            end
+          end
+
+          def patch
+            # Redis 5+ extracts RedisClient to its own gem and provide instrumentation interface
+            if Integration.redis_client_compatible?
+              require_relative 'trace_middleware'
+
+              ::RedisClient.register(TraceMiddleware)
+            end
+
+            if Integration.redis_compatible?
+              if Integration.redis_version < Gem::Version.new('5.0.0')
+                require_relative 'instrumentation'
+
+                ::Redis.include(DatadogPinPatch)
+                ::Redis::Client.include(Instrumentation)
+              else # warn about non-supported configure_onto usage
+                ::Redis.include(NotSupportedNoticePatch)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: 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