ls-trace 0.1.1

data/lib/ddtrace/contrib/rails/railtie.rb

@@ -0,0 +1,17 @@
+require 'ddtrace/contrib/rails/framework'
+require 'ddtrace/contrib/rails/middlewares'
+require 'ddtrace/contrib/rack/middlewares'
+
+module Datadog
+  # Railtie class initializes
+  class Railtie < Rails::Railtie
+    # Add the trace middleware to the application stack
+    initializer 'datadog.before_intialize' do |app|
+      Datadog::Contrib::Rails::Patcher.before_intialize(app)
+    end
+
+    config.after_initialize do
+      Datadog::Contrib::Rails::Patcher.after_intialize(self)
+    end
+  end
+end

data/lib/ddtrace/contrib/rails/utils.rb

@@ -0,0 +1,20 @@
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module Rails
+      # common utilities for Rails
+      module Utils
+        def self.app_name
+          if ::Rails::VERSION::MAJOR >= 6
+            ::Rails.application.class.module_parent_name.underscore
+          elsif ::Rails::VERSION::MAJOR >= 4
+            ::Rails.application.class.parent_name.underscore
+          else
+            ::Rails.application.class.to_s.underscore
+          end
+        end
+      end
+    end
+  end
+end

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,84 @@
+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
+            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::Tracer.log.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::Tracer.log.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,32 @@
+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
+
+        register_as :rake
+
+        def self.version
+          Gem.loaded_specs['rake'] && Gem.loaded_specs['rake'].version
+        end
+
+        def self.present?
+          super && defined?(::Rake)
+        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,36 @@
+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 patched?
+          done?(:rake)
+        end
+
+        def patch
+          do_once(:rake) do
+            begin
+              # Add instrumentation patch to Rake task
+              ::Rake::Task.send(:include, Instrumentation)
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Rake integration: #{e}")
+            end
+          end
+        end
+
+        def get_option(option)
+          Datadog.configuration[:rake].get_option(option)
+        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,36 @@
+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
+
+        register_as :redis, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['redis'] && Gem.loaded_specs['redis'].version
+        end
+
+        def self.present?
+          super && defined?(::Redis)
+        end
+
+        def self.compatible?
+          !version.nil? && version >= Gem::Version.new('3.0.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/redis/ext'
+
+module Datadog
+  module Contrib
+    module Redis
+      # Patcher enables patching of 'redis' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:redis)
+        end
+
+        # patch applies our patch if needed
+        def patch
+          do_once(:redis) do
+            begin
+              # 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
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Redis integration: #{e}")
+            end
+          end
+        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[:redis][:service_name],
+                  app: Ext::APP,
+                  app_type: Datadog::Ext::AppTypes::DB,
+                  tracer: Datadog.configuration[:redis][:tracer]
+                )
+                pin.onto(self)
+              end
+            end
+          end
+        end
+      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::Tracer.log.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