ddtrace 0.34.1 → 1.23.1

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

@@ -1,38 +0,0 @@
-require 'ddtrace/ext/http'
-require 'ddtrace/contrib/action_pack/utils'
-
-module Datadog
-  module Contrib
-    # Rails module includes middlewares that are required for Rails to be properly instrumented.
-    module Rails
-      # This is only here to catch errors, the Rack module does something very similar, however,
-      # since it's not in the same place in the stack, when the Rack middleware is called,
-      # error is already swallowed and handled by Rails so we miss the call stack, for instance.
-      class ExceptionMiddleware
-        def initialize(app)
-          @app = app
-        end
-
-        def call(env)
-          @app.call(env)
-        # rubocop:disable Lint/RescueException
-        # Here we really want to catch *any* exception, not only StandardError,
-        # as we really have no clue of what is in the block,
-        # and it is user code which should be executed no matter what.
-        # It's not a problem since we re-raise it afterwards so for example a
-        # SignalException::Interrupt would still bubble up.
-        rescue Exception => e
-          tracer = Datadog.configuration[:rails][:tracer]
-          span = tracer.active_span
-          unless span.nil?
-            # Only set error if it's supposed to be flagged as such
-            # e.g. we don't want to flag 404s.
-            # You can add custom errors via `config.action_dispatch.rescue_responses`
-            span.set_error(e) if ActionPack::Utils.exception_is_error?(e)
-          end
-          raise e
-        end
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-require 'ddtrace/contrib/rails/utils'
-require 'ddtrace/contrib/rails/framework'
-require 'ddtrace/contrib/rails/middlewares'
-require 'ddtrace/contrib/rack/middlewares'
-
-module Datadog
-  module Contrib
-    module Rails
-      # Patcher enables patching of 'rails' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          patch_before_intialize
-          patch_after_intialize
-        end
-
-        def patch_before_intialize
-          ::ActiveSupport.on_load(:before_initialize) do
-            Datadog::Contrib::Rails::Patcher.before_intialize(self)
-          end
-        end
-
-        def before_intialize(app)
-          do_once(:rails_before_initialize, for: app) do
-            # Middleware must be added before the application is initialized.
-            # Otherwise the middleware stack will be frozen.
-            # Sometimes we don't want to activate middleware e.g. OpenTracing, etc.
-            add_middleware(app) if Datadog.configuration[:rails][:middleware]
-          end
-        end
-
-        def add_middleware(app)
-          # Add trace middleware
-          app.middleware.insert_before(0, Datadog::Contrib::Rack::TraceMiddleware)
-
-          # Insert right after Rails exception handling middleware, because if it's before,
-          # it catches and swallows the error. If it's too far after, custom middleware can find itself
-          # between, and raise exceptions that don't end up getting tagged on the request properly.
-          # e.g lost stack trace.
-          app.middleware.insert_after(
-            ActionDispatch::ShowExceptions,
-            Datadog::Contrib::Rails::ExceptionMiddleware
-          )
-        end
-
-        def patch_after_intialize
-          ::ActiveSupport.on_load(:after_initialize) do
-            Datadog::Contrib::Rails::Patcher.after_intialize(self)
-          end
-        end
-
-        def after_intialize(app)
-          do_once(:rails_after_initialize, for: app) do
-            # Finish configuring the tracer after the application is initialized.
-            # We need to wait for some things, like application name, middleware stack, etc.
-            setup_tracer
-          end
-        end
-
-        # Configure Rails tracing with settings
-        def setup_tracer
-          Datadog::Contrib::Rails::Framework.setup
-        end
-      end
-    end
-  end
-end

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

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

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

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

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

@@ -1,88 +0,0 @@
-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.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::Logger.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

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

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

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

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

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

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

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

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

@@ -1,38 +0,0 @@
-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)
-            # 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
-          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
-        end
-      end
-    end
-  end
-end