ddtrace 0.50.0 → 1.0.0

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

@@ -0,0 +1,49 @@
+# typed: false
+
+require 'datadog/tracing/contrib/integration'
+
+require 'datadog/tracing/contrib/rails/ext'
+require 'datadog/tracing/contrib/rails/configuration/settings'
+require 'datadog/tracing/contrib/rails/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rails
+        # Description of Rails integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('3.2')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :rails, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['railties'] && Gem.loaded_specs['railties'].version
+          end
+
+          def self.loaded?
+            !defined?(::Rails).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def self.patchable?
+            super && !ENV.key?(Ext::ENV_DISABLE)
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rails/log_injection.rb

@@ -0,0 +1,47 @@
+# typed: false
+
+require 'datadog/tracing'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Instrument Rails.
+      module Rails
+        # Rails log injection helper methods
+        module LogInjection
+          module_function
+
+          def add_as_tagged_logging_logger(app)
+            # we want to check if the current logger is a tagger logger instance
+            # log_tags defaults to nil so we have to set as an array if nothing exists yet
+            if (log_tags = app.config.log_tags).nil?
+              app.config.log_tags = [proc { Tracing.log_correlation }]
+            # if existing log_tags configuration exists, append to the end of the array
+            elsif log_tags.is_a?(Array)
+              app.config.log_tags << proc { Tracing.log_correlation }
+            end
+          rescue StandardError => e
+            # TODO: can we use Datadog.logger at this point?
+            Datadog.logger.warn("Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.message}")
+            false
+          end
+
+          def datadog_trace_log_hash(correlation)
+            {
+              # Adds IDs as tags to log output
+              dd: {
+                # To preserve precision during JSON serialization, use strings for large numbers
+                trace_id: correlation.trace_id.to_s,
+                span_id: correlation.span_id.to_s,
+                env: correlation.env.to_s,
+                service: correlation.service.to_s,
+                version: correlation.version.to_s
+              },
+              ddsource: ['ruby']
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rails/middlewares.rb

@@ -0,0 +1,47 @@
+# typed: true
+
+require 'datadog/tracing'
+require 'datadog/tracing/contrib/action_pack/utils'
+
+module Datadog
+  module Tracing
+    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
+            span = Tracing.active_span
+            if !span.nil? && ActionPack::Utils.exception_is_error?(e)
+              # 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)
+
+              # Some exception gets handled by Rails middleware before it can be set on Rack middleware
+              # The rack span is the root span of the request and should make sure it has the full exception
+              # set on it.
+              env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN].set_error(e) if env[Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]
+            end
+            raise e
+          end
+          # rubocop:enable Lint/RescueException
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,121 @@
+# typed: ignore
+
+require 'datadog/core/utils/only_once'
+require 'datadog/tracing'
+require 'datadog/tracing/contrib/rack/middlewares'
+require 'datadog/tracing/contrib/rails/framework'
+require 'datadog/tracing/contrib/rails/log_injection'
+require 'datadog/tracing/contrib/rails/middlewares'
+require 'datadog/tracing/contrib/rails/utils'
+require 'datadog/tracing/contrib/semantic_logger/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rails
+        # Patcher enables patching of 'rails' module.
+        module Patcher
+          include Contrib::Patcher
+
+          BEFORE_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Core::Utils::OnlyOnce.new }
+          AFTER_INITIALIZE_ONLY_ONCE_PER_APP = Hash.new { |h, key| h[key] = Core::Utils::OnlyOnce.new }
+
+          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
+              Contrib::Rails::Patcher.before_intialize(self)
+            end
+          end
+
+          def before_intialize(app)
+            BEFORE_INITIALIZE_ONLY_ONCE_PER_APP[app].run 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.tracing[:rails][:middleware]
+              add_logger(app) if Datadog.configuration.tracing.log_injection
+            end
+          end
+
+          def add_middleware(app)
+            # Add trace middleware at the top of the middleware stack,
+            # to ensure we capture the complete execution time.
+            app.middleware.insert_before(0, Contrib::Rack::TraceMiddleware)
+
+            # Some Rails middleware can swallow an application error, preventing
+            # the error propagation to the encompassing Rack span.
+            #
+            # We insert our own middleware right before these Rails middleware
+            # have a chance to swallow the error.
+            #
+            # Note: because the middleware stack is push/pop, "before" and "after" are reversed
+            # for our use case: we insert ourselves with "after" a middleware to ensure we are
+            # able to pop the request "before" it.
+            app.middleware.insert_after(::ActionDispatch::DebugExceptions, Contrib::Rails::ExceptionMiddleware)
+          end
+
+          def add_logger(app)
+            should_warn = true
+            # check if lograge key exists
+            # Note: Rails executes initializers sequentially based on alphabetical order,
+            # and lograge config could occur after datadog config.
+            # So checking for `app.config.lograge.enabled` may yield a false negative,
+            # and adding custom options naively if `config.lograge` exists from the lograge Railtie,
+            # is inconsistent since a lograge initializer would override it.
+            # Instead, we patch Lograge `custom_options` internals directly
+            # as part of Rails framework patching
+            # and just flag off the warning log here.
+            # SemanticLogger we similarly patch in the after_initiaize block, and should flag
+            # off the warning log here if we know we'll patch this gem later.
+            should_warn = false if app.config.respond_to?(:lograge) || defined?(::SemanticLogger)
+
+            # if lograge isn't set, check if tagged logged is enabled.
+            # if so, add proc that injects trace identifiers for tagged logging.
+            logger = app.config.logger || ::Rails.logger
+
+            if logger \
+                && defined?(::ActiveSupport::TaggedLogging) \
+                && logger.is_a?(::ActiveSupport::TaggedLogging)
+
+              Contrib::Rails::LogInjection.add_as_tagged_logging_logger(app)
+              should_warn = false
+            end
+
+            if should_warn
+              Datadog.logger.warn("Unable to enable Datadog Trace context, Logger #{logger.class} is not supported")
+            end
+          end
+
+          def patch_after_intialize
+            ::ActiveSupport.on_load(:after_initialize) do
+              Contrib::Rails::Patcher.after_intialize(self)
+            end
+          end
+
+          def after_intialize(app)
+            AFTER_INITIALIZE_ONLY_ONCE_PER_APP[app].run 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
+            Contrib::Rails::Framework.setup
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rails/railtie.rb

@@ -0,0 +1,19 @@
+# typed: ignore
+
+require 'datadog/tracing/contrib/rails/framework'
+require 'datadog/tracing/contrib/rails/middlewares'
+require 'datadog/tracing/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|
+      Tracing::Contrib::Rails::Patcher.before_intialize(app)
+    end
+
+    config.after_initialize do
+      Tracing::Contrib::Rails::Patcher.after_intialize(self)
+    end
+  end
+end

data/lib/datadog/tracing/contrib/rails/utils.rb

@@ -0,0 +1,28 @@
+# typed: false
+
+require 'datadog/tracing/contrib/analytics'
+
+module Datadog
+  module Tracing
+    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
+
+          def self.railtie_supported?
+            !(defined?(::Rails::VERSION::MAJOR) && ::Rails::VERSION::MAJOR >= 3 && defined?(::Rails::Railtie)).nil?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: false
+
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/rake/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Rake
+        module Configuration
+          # Custom settings for the Rake 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 :quantize, default: {}
+            option :service_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# typed: 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'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_RAKE_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_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
+          TAG_COMPONENT = 'rake'.freeze
+          TAG_OPERATION_EXECUTE = 'execute'.freeze
+          TAG_OPERATION_INVOKE = 'invoke'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# typed: false
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/rake/ext'
+require 'datadog/tracing/contrib/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 unless enabled?
+
+              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 unless enabled?
+
+              Tracing.trace(Ext::SPAN_EXECUTE, **span_options) do |span|
+                annotate_execute!(span, args)
+                super
+              end
+            ensure
+              shutdown_tracer!
+            end
+
+            private
+
+            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.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.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 @@
+# typed: false
+
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/rake/configuration/settings'
+require 'datadog/tracing/contrib/rake/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,35 @@
+# typed: true
+
+require 'datadog/tracing'
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/rake/ext'
+require 'datadog/tracing/contrib/rake/instrumentation'
+require 'datadog/tracing/contrib/rake/integration'
+
+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 @@
+# typed: true
+
+require 'datadog/tracing/contrib/redis/vendor/resolver'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Redis
+        module Configuration
+          UNIX_SCHEME = 'unix'.freeze
+
+          # 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,40 @@
+# typed: false
+
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/redis/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.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 :command_args do |o|
+              o.default { env_to_bool(Ext::ENV_COMMAND_ARGS, true) }
+              o.lazy
+            end
+
+            option :service_name, default: Ext::DEFAULT_PEER_SERVICE_NAME
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# typed: 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'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_REDIS_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_REDIS_ANALYTICS_SAMPLE_RATE'.freeze
+          ENV_COMMAND_ARGS = 'DD_REDIS_COMMAND_ARGS'.freeze
+          METRIC_PIPELINE_LEN = 'redis.pipeline_length'.freeze
+          DEFAULT_PEER_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
+          TAG_COMPONENT = 'redis'.freeze
+          TAG_OPERATION_COMMAND = 'command'.freeze
+        end
+      end
+    end
+  end
+end