ddtrace 0.38.0

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

@@ -0,0 +1,27 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/rake/ext'
+
+module Datadog
+  module Contrib
+    module Rake
+      module Configuration
+        # Custom settings for the Rake integration
+        class Settings < Contrib::Configuration::Settings
+          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 :enabled, default: true
+          option :quantize, default: {}
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module Rake
+      # 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
+        SERVICE_NAME = 'rake'.freeze
+        SPAN_INVOKE = 'rake.invoke'.freeze
+        SPAN_EXECUTE = 'rake.execute'.freeze
+        TAG_EXECUTE_ARGS = 'rake.execute.args'.freeze
+        TAG_INVOKE_ARGS = 'rake.invoke.args'.freeze
+        TAG_TASK_ARG_NAMES = 'rake.task.arg_names'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/rake/ext'
+
+module Datadog
+  module Contrib
+    module Rake
+      # Instrumentation for Rake tasks
+      module Instrumentation
+        def self.included(base)
+          base.send(:prepend, InstanceMethods)
+        end
+
+        # Instance methods for Rake instrumentation
+        module InstanceMethods
+          def invoke(*args)
+            return super unless enabled?
+
+            tracer.trace(Ext::SPAN_INVOKE, span_options) do |span|
+              super.tap { annotate_invoke!(span, args) }
+            end
+          ensure
+            shutdown_tracer!
+          end
+
+          def execute(args = nil)
+            return super unless enabled?
+
+            tracer.trace(Ext::SPAN_EXECUTE, span_options) do |span|
+              super.tap { annotate_execute!(span, args) }
+            end
+          ensure
+            shutdown_tracer!
+          end
+
+          private
+
+          def shutdown_tracer!
+            tracer.shutdown! if tracer.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(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.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.logger.debug("Error while tracing Rake execute: #{e.message}")
+          end
+
+          def quantize_args(args)
+            quantize_options = configuration[:quantize][:args]
+            Datadog::Quantization::Hash.format(args, quantize_options)
+          end
+
+          def enabled?
+            configuration[:enabled] == true
+          end
+
+          def tracer
+            configuration[:tracer]
+          end
+
+          def span_options
+            { service: configuration[:service_name] }
+          end
+
+          def configuration
+            Datadog.configuration[:rake]
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,30 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/rake/ext'
+require 'ddtrace/contrib/rake/instrumentation'
+
+module Datadog
+  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.send(:include, Instrumentation)
+        end
+
+        def get_option(option)
+          Datadog.configuration[:rake].get_option(option)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+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 :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, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Datadog
+  module Contrib
+    module Redis
+      # 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
+        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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,97 @@
+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
+        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 = Datadog::Contrib::Redis::Quantize.format_command_args(*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 = args[0].commands.map { |c| Datadog::Contrib::Redis::Quantize.format_command_args(c) }
+                span.resource = commands.join("\n")
+                Datadog::Contrib::Redis::Tags.set_common_tags(self, span)
+                span.set_metric Datadog::Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
+
+                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 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

@@ -0,0 +1,47 @@
+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
+
+        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 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