datadog 2.2.0 → 2.4.0

data/lib/datadog/profiling/profiler.rb

@@ -8,34 +8,30 @@ module Datadog
 
       private
 
-      attr_reader :worker, :scheduler, :optional_crashtracker
+      attr_reader :worker, :scheduler
 
       public
 
-      def initialize(worker:, scheduler:, optional_crashtracker:)
+      def initialize(worker:, scheduler:)
         @worker = worker
         @scheduler = scheduler
-        @optional_crashtracker = optional_crashtracker
       end
 
       def start
         after_fork! do
-          optional_crashtracker.reset_after_fork if optional_crashtracker
           worker.reset_after_fork
           scheduler.reset_after_fork
         end
 
-        optional_crashtracker.start if optional_crashtracker
         worker.start(on_failure_proc: proc { component_failed(:worker) })
         scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
       end
 
       def shutdown!
-        Datadog.logger.debug('Shutting down profiler')
+        Datadog.logger.debug("Shutting down profiler")
 
         stop_worker
         stop_scheduler
-        optional_crashtracker.stop if optional_crashtracker
       end
 
       private
@@ -52,13 +48,14 @@ module Datadog
       def component_failed(failed_component)
         Datadog.logger.warn(
           "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
-          'See previous log messages for details.'
+          "See previous log messages for details."
         )
 
         # We explicitly not stop the crash tracker in this situation, under the assumption that, if a component failed,
         # we're operating in a degraded state and crash tracking may still be helpful.
 
         if failed_component == :worker
+          scheduler.mark_profiler_failed
           stop_scheduler
         elsif failed_component == :scheduler
           stop_worker

data/lib/datadog/profiling/scheduler.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../core/utils/time'
+require_relative "../core/utils/time"
 
-require_relative '../core/worker'
-require_relative '../core/workers/polling'
+require_relative "../core/worker"
+require_relative "../core/workers/polling"
+require_relative "../core/telemetry/logger"
 
 module Datadog
   module Profiling
@@ -22,7 +23,8 @@ module Datadog
 
       attr_reader \
         :exporter,
-        :transport
+        :transport,
+        :profiler_failed
 
       public
 
@@ -34,6 +36,7 @@ module Datadog
       )
         @exporter = exporter
         @transport = transport
+        @profiler_failed = false
 
         # Workers::Async::Thread settings
         self.fork_policy = fork_policy
@@ -50,25 +53,23 @@ module Datadog
       end
 
       def perform(on_failure_proc)
-        begin
-          # A profiling flush may be called while the VM is shutting down, to report the last profile. When we do so,
-          # we impose a strict timeout. This means this last profile may or may not be sent, depending on if the flush can
-          # successfully finish in the strict timeout.
-          # This can be somewhat confusing (why did it not get reported?), so let's at least log what happened.
-          interrupted = true
-
-          flush_and_wait
-          interrupted = false
-        rescue Exception => e # rubocop:disable Lint/RescueException
-          Datadog.logger.warn(
-            'Profiling::Scheduler thread error. ' \
-            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
-          )
-          on_failure_proc&.call
-          raise
-        ensure
-          Datadog.logger.debug('#flush was interrupted or failed before it could complete') if interrupted
-        end
+        # A profiling flush may be called while the VM is shutting down, to report the last profile. When we do so,
+        # we impose a strict timeout. This means this last profile may or may not be sent, depending on if the flush can
+        # successfully finish in the strict timeout.
+        # This can be somewhat confusing (why did it not get reported?), so let's at least log what happened.
+        interrupted = true
+
+        flush_and_wait
+        interrupted = false
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        Datadog.logger.warn(
+          "Profiling::Scheduler thread error. " \
+          "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+        )
+        on_failure_proc&.call
+        raise
+      ensure
+        Datadog.logger.debug("#flush was interrupted or failed before it could complete") if interrupted
       end
 
       # Configure Workers::IntervalLoop to not report immediately when scheduler starts
@@ -80,8 +81,14 @@ module Datadog
         true
       end
 
+      # This is called by the Profiler class whenever an issue happened in the profiler. This makes sure that even
+      # if there is data to be flushed, we don't try to flush it.
+      def mark_profiler_failed
+        @profiler_failed = true
+      end
+
       def work_pending?
-        exporter.can_flush?
+        !profiler_failed && exporter.can_flush?
       end
 
       def reset_after_fork
@@ -124,10 +131,11 @@ module Datadog
 
         begin
           transport.export(flush)
-        rescue StandardError => e
+        rescue => e
           Datadog.logger.error(
             "Unable to report profile. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
           )
+          Datadog::Core::Telemetry::Logger.report(e, description: "Unable to report profile")
         end
 
         true

data/lib/datadog/profiling/stack_recorder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../core/telemetry/logger"
+
 module Datadog
   module Profiling
     # Stores stack samples in a native libdatadog data structure and expose Ruby-level serialization APIs
@@ -42,6 +44,7 @@ module Datadog
           error_message = result
 
           Datadog.logger.error("Failed to serialize profiling data: #{error_message}")
+          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data")
 
           nil
         end

data/lib/datadog/profiling/tag_builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../core/utils'
-require_relative '../core/environment/git'
+require_relative "../core/utils"
+require_relative "../core/environment/git"
 
 module Datadog
   module Profiling

data/lib/datadog/profiling/tasks/exec.rb

@@ -18,16 +18,16 @@ module Datadog
 
         def rubyopts
           [
-            '-rdatadog/profiling/preload'
+            "-rdatadog/profiling/preload"
           ]
         end
 
         private
 
         def set_rubyopt!
-          existing_rubyopt = ENV['RUBYOPT']
+          existing_rubyopt = ENV["RUBYOPT"]
 
-          ENV['RUBYOPT'] = existing_rubyopt ? "#{existing_rubyopt} #{rubyopts.join(' ')}" : rubyopts.join(' ')
+          ENV["RUBYOPT"] = existing_rubyopt ? "#{existing_rubyopt} #{rubyopts.join(" ")}" : rubyopts.join(" ")
         end
 
         # If there's an error here, rather than throwing a cryptic stack trace, let's instead have clearer messages, and
@@ -38,10 +38,10 @@ module Datadog
         def exec_with_error_handling(args)
           Kernel.exec(*args)
         rescue Errno::ENOENT => e
-          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(' ')}')"
+          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
           Kernel.exit 127
         rescue Errno::EACCES, Errno::ENOEXEC => e
-          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(' ')}')"
+          Kernel.warn "ddprofrb exec failed: #{e.class.name} #{e.message} (command was '#{args.join(" ")}')"
           Kernel.exit 126
         end
       end

data/lib/datadog/profiling/tasks/setup.rb

@@ -1,56 +1,37 @@
 # frozen_string_literal: true
 
-require_relative '../../core/utils/only_once'
-require_relative '../ext/forking'
+require_relative "../../core/utils/only_once"
+require_relative "../../core/utils/at_fork_monkey_patch"
 
 module Datadog
   module Profiling
     module Tasks
-      # Takes care of loading our extensions/monkey patches to handle fork() and validating if CPU-time profiling is usable
+      # Takes care of restarting the profiler when the process forks
       class Setup
         ACTIVATE_EXTENSIONS_ONLY_ONCE = Core::Utils::OnlyOnce.new
 
         def run
           ACTIVATE_EXTENSIONS_ONLY_ONCE.run do
-            begin
-              activate_forking_extensions
-              setup_at_fork_hooks
-            rescue StandardError, ScriptError => e
-              Datadog.logger.warn do
-                "Profiler extensions unavailable. Cause: #{e.class.name} #{e.message} " \
-                "Location: #{Array(e.backtrace).first}"
-              end
+            Datadog::Core::Utils::AtForkMonkeyPatch.apply!
+            setup_at_fork_hooks
+          rescue StandardError, ScriptError => e
+            Datadog.logger.warn do
+              "Profiler extensions unavailable. Cause: #{e.class.name} #{e.message} " \
+              "Location: #{Array(e.backtrace).first}"
             end
           end
         end
 
         private
 
-        def activate_forking_extensions
-          if Ext::Forking.supported?
-            Ext::Forking.apply!
-          elsif Datadog.configuration.profiling.enabled
-            Datadog.logger.debug('Profiler forking extensions skipped; forking not supported.')
-          end
-        rescue StandardError, ScriptError => e
-          Datadog.logger.warn do
-            "Profiler forking extensions unavailable. Cause: #{e.class.name} #{e.message} " \
-            "Location: #{Array(e.backtrace).first}"
-          end
-        end
-
         def setup_at_fork_hooks
-          if Process.respond_to?(:at_fork)
-            Process.at_fork(:child) do
-              begin
-                # Restart profiler, if enabled
-                Profiling.start_if_enabled
-              rescue StandardError => e
-                Datadog.logger.warn do
-                  "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
-                  "Location: #{Array(e.backtrace).first}"
-                end
-              end
+          Datadog::Core::Utils::AtForkMonkeyPatch.at_fork(:child) do
+            # Restart profiler, if enabled
+            Profiling.start_if_enabled
+          rescue => e
+            Datadog.logger.warn do
+              "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
+              "Location: #{Array(e.backtrace).first}"
             end
           end
         end

data/lib/datadog/profiling.rb

@@ -30,7 +30,7 @@ module Datadog
       profiler = Datadog.send(:components).profiler
       # ...but we still try to start it BECAUSE if the process forks, the profiler will exist but may
       # not yet have been started in the fork
-      profiler.start if profiler
+      profiler&.start
       !!profiler
     end
 
@@ -47,6 +47,7 @@ module Datadog
     # (This is similar to some OS-based time representations.)
     #
     # Note 2: All fibers in the same thread will share the same counter values.
+    # Note 3: This counter is not accurate when using the M:N scheduler.
     #
     # Only available when the profiler is running, and allocation-related features are not disabled via configuration.
     #
@@ -62,7 +63,7 @@ module Datadog
     def self.enabled?
       profiler = Datadog.send(:components).profiler
       # Use .send(...) to avoid exposing the attr_reader as an API to the outside
-      !!(profiler.send(:scheduler).running? if profiler)
+      !!profiler&.send(:scheduler)&.running?
     end
 
     def self.wait_until_running(timeout_seconds: 5)
@@ -97,7 +98,7 @@ module Datadog
 
         contents = file_api.read(skipped_reason_file).strip
         contents unless contents.empty?
-      rescue StandardError
+      rescue
         # Do nothing
       end
     end
@@ -135,7 +136,6 @@ module Datadog
     private_class_method def self.load_profiling
       return false unless supported?
 
-      require_relative 'profiling/ext/forking'
       require_relative 'profiling/ext/dir_monkey_patches'
       require_relative 'profiling/collectors/info'
       require_relative 'profiling/collectors/code_provenance'
@@ -144,7 +144,6 @@ module Datadog
       require_relative 'profiling/collectors/idle_sampling_helper'
       require_relative 'profiling/collectors/stack'
       require_relative 'profiling/collectors/thread_context'
-      require_relative 'profiling/crashtracker'
       require_relative 'profiling/stack_recorder'
       require_relative 'profiling/exporter'
       require_relative 'profiling/flush'

data/lib/datadog/single_step_instrument.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+#
+# Entrypoint file for single step instrumentation.
+#
+# This file's path is private. Do not reference this file.
+#
+begin
+  require_relative 'auto_instrument'
+rescue StandardError, LoadError => e
+  warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
+end

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

@@ -14,21 +14,17 @@ module Datadog
           module ActionCableConnection
             def on_open
               Tracing.trace(Ext::SPAN_ON_OPEN) do |span, trace|
-                begin
-                  span.resource = "#{self.class}#on_open"
-                  span.type = Tracing::Metadata::Ext::AppTypes::TYPE_WEB
+                span.resource = "#{self.class}#on_open"
+                span.type = Tracing::Metadata::Ext::AppTypes::TYPE_WEB
 
-                  span.set_tag(Ext::TAG_ACTION, 'on_open')
-                  span.set_tag(Ext::TAG_CONNECTION, self.class.to_s)
+                span.set_tag(Ext::TAG_ACTION, 'on_open')
+                span.set_tag(Ext::TAG_CONNECTION, self.class.to_s)
 
-                  span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
-                  span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ON_OPEN)
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ON_OPEN)
 
-                  # Set the resource name of the trace
-                  trace.resource = span.resource
-                rescue StandardError => e
-                  Datadog.logger.error("Error preparing span for ActionCable::Connection: #{e}")
-                end
+                # Set the resource name of the trace
+                trace.resource = span.resource
 
                 super
               end

data/lib/datadog/tracing/contrib/action_pack/action_controller/instrumentation.rb

@@ -7,6 +7,7 @@ require_relative '../ext'
 require_relative '../utils'
 require_relative '../../rack/middlewares'
 require_relative '../../analytics'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -43,6 +44,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CONTROLLER)
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             def finish_processing(payload)
@@ -81,10 +83,13 @@ module Datadog
               end
             rescue StandardError => e
               Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             # Instrumentation for ActionController::Metal
             module Metal
+              # TODO: Refactor this method to avoid using async API that splits the logic
+              # into two different methods (`start_processing` and `finish_processing`)
               def process_action(*args)
                 # mutable payload with a tracing context that is used in two different
                 # signals; it propagates the request span so that it can be finished

data/lib/datadog/tracing/contrib/action_pack/action_dispatch/instrumentation.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../../../metadata/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActionPack
+        module ActionDispatch
+          # Instrumentation for ActionDispatch components
+          module Instrumentation
+            module_function
+
+            def set_http_route_tags(route_spec, script_name)
+              return unless Tracing.enabled?
+
+              return unless route_spec
+
+              request_trace = Tracing.active_trace
+              return unless request_trace
+
+              request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, route_spec.to_s.gsub(/\(.:format\)\z/, ''))
+
+              if script_name && !script_name.empty?
+                request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, script_name)
+              end
+            end
+
+            def dispatcher_route?(route)
+              return true if route.dispatcher?
+
+              # in Rails 4 there is no #rack_app method on the app
+              return true if route.app.respond_to?(:rack_app) && !route.app.rack_app.nil?
+
+              false
+            end
+
+            # Instrumentation for ActionDispatch::Journey components
+            module Journey
+              # Instrumentation for ActionDispatch::Journey::Router for Rails versions older than 7.1
+              module Router
+                def find_routes(req)
+                  result = super
+
+                  # result is an array of [match, parameters, route] tuples
+                  routes = result.map(&:last)
+
+                  routes.each do |route|
+                    if Instrumentation.dispatcher_route?(route)
+                      Instrumentation.set_http_route_tags(route.path.spec, req.env['SCRIPT_NAME'])
+                      break
+                    end
+                  end
+
+                  result
+                end
+              end
+
+              # Since Rails 7.1 `Router#find_routes` makes the route computation lazy
+              # https://github.com/rails/rails/commit/35b280fcc2d5d474f9f2be3aca3ae7aa6bba66eb
+              module LazyRouter
+                def find_routes(req)
+                  super do |match, parameters, route|
+                    if Instrumentation.dispatcher_route?(route)
+                      Instrumentation.set_http_route_tags(route.path.spec, req.env['SCRIPT_NAME'])
+                    end
+
+                    yield [match, parameters, route]
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/action_pack/action_dispatch/patcher.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../patcher'
+require_relative 'instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActionPack
+        module ActionDispatch
+          # Patcher for ActionController components
+          module Patcher
+            include Contrib::Patcher
+
+            module_function
+
+            def target_version
+              Integration.version
+            end
+
+            def patch
+              if ::ActionPack.gem_version >= Gem::Version.new('7.1')
+                ::ActionDispatch::Journey::Router.prepend(ActionDispatch::Instrumentation::Journey::LazyRouter)
+              else
+                ::ActionDispatch::Journey::Router.prepend(ActionDispatch::Instrumentation::Journey::Router)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@
 
 require_relative '../patcher'
 require_relative 'action_controller/patcher'
+require_relative 'action_dispatch/patcher'
 
 module Datadog
   module Tracing
@@ -19,6 +20,7 @@ module Datadog
 
           def patch
             ActionController::Patcher.patch
+            ActionDispatch::Patcher.patch
           end
         end
       end

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

@@ -2,6 +2,7 @@
 
 require_relative '../../configuration/resolver'
 require_relative 'makara_resolver'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -72,10 +73,12 @@ module Datadog
               #
               # `db_config` input may contain sensitive information such as passwords,
               # hence provide a succinct summary for the error logging.
+              #
               Datadog.logger.error(
                 'Failed to resolve ActiveRecord database configuration. '\
                 "Cause: #{e.class.name} Source: #{Array(e.backtrace).first}"
               )
+              Core::Telemetry::Logger.report(e, description: 'Failed to resolve ActiveRecord database configuration')
 
               nil
             end
@@ -95,6 +98,7 @@ module Datadog
                 "Failed to resolve key #{matcher.inspect}. " \
                 "Cause: #{e.class.name} Source: #{Array(e.backtrace).first}"
               )
+              Core::Telemetry::Logger.report(e, description: 'Failed to resolve key')
 
               nil
             end

data/lib/datadog/tracing/contrib/active_record/events/instantiation.rb

@@ -4,6 +4,7 @@ require_relative '../../../metadata/ext'
 require_relative '../../analytics'
 require_relative '../ext'
 require_relative '../event'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -48,7 +49,8 @@ module Datadog
               span.set_tag(Ext::TAG_INSTANTIATION_CLASS_NAME, payload.fetch(:class_name))
               span.set_tag(Ext::TAG_INSTANTIATION_RECORD_COUNT, payload.fetch(:record_count))
             rescue StandardError => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
           end
         end

data/lib/datadog/tracing/contrib/active_record/events/sql.rb

@@ -6,6 +6,7 @@ require_relative '../event'
 require_relative '../ext'
 require_relative '../../analytics'
 require_relative '../../utils/database'
+require_relative '../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -62,12 +63,14 @@ module Datadog
               cached = payload[:cached] || (payload[:name] == PAYLOAD_CACHE)
 
               span.set_tag(Ext::TAG_DB_VENDOR, adapter_name)
+              span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, config[:database])
               span.set_tag(Ext::TAG_DB_NAME, config[:database])
               span.set_tag(Ext::TAG_DB_CACHED, cached) if cached
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, config[:host]) if config[:host]
               span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, config[:port]) if config[:port]
             rescue StandardError => e
-              Datadog.logger.debug(e.message)
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
           end
         end

data/lib/datadog/tracing/contrib/active_support/cache/events/cache.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../ext'
 require_relative '../event'
+require_relative '../../../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -64,7 +65,7 @@ module Datadog
                 key = payload[:key]
                 store = payload[:store]
 
-                mapping = MAPPING[event]
+                mapping = MAPPING.fetch(event)
 
                 span.service = configuration[:cache_service]
                 span.resource = mapping[:resource]
@@ -81,6 +82,9 @@ module Datadog
                 span.set_tag('EVENT', event)
 
                 set_cache_key(span, key, mapping[:multi_key])
+              rescue StandardError => e
+                Datadog.logger.error(e.message)
+                Datadog::Core::Telemetry::Logger.report(e)
               end
 
               def set_cache_key(span, key, multi_key)

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

@@ -29,6 +29,7 @@ module Datadog
           private
 
           # rubocop:disable Metrics/AbcSize
+          # rubocop:disable Metrics/MethodLength
           def annotate!(span, context)
             span.service = configuration[:service_name]
             span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
@@ -76,7 +77,11 @@ module Datadog
             span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, context.safely(:status_code))
 
             Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+          rescue StandardError => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
           end
+          # rubocop:enable Metrics/MethodLength
           # rubocop:enable Metrics/AbcSize
 
           def configuration