datadog 2.17.0 → 2.19.0

data/lib/datadog/profiling/component.rb

@@ -67,6 +67,7 @@ module Datadog
           allocation_profiling_enabled: allocation_profiling_enabled,
           allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
           gvl_profiling_enabled: enable_gvl_profiling?(settings, logger),
+          sighandler_sampling_enabled: settings.profiling.advanced.sighandler_sampling_enabled,
         )
 
         internal_metadata = {
@@ -96,6 +97,7 @@ module Datadog
           timeline_enabled: timeline_enabled,
           waiting_for_gvl_threshold_ns: settings.profiling.advanced.waiting_for_gvl_threshold_ns,
           otel_context_enabled: settings.profiling.advanced.preview_otel_context_enabled,
+          native_filenames_enabled: settings.profiling.advanced.native_filenames_enabled,
         )
       end
 
@@ -221,13 +223,14 @@ module Datadog
         end
 
         unless allocation_profiling_enabled
-          raise ArgumentError, "Heap profiling requires allocation profiling to be enabled"
+          logger.warn(
+            "Heap profiling was requested but allocation profiling is not enabled. " \
+            "Heap profiling has been disabled."
+          )
+          return false
         end
 
-        logger.warn(
-          "Enabled experimental heap profiling: heap_sample_rate=#{heap_sample_rate}. This is experimental, not " \
-          "recommended, and will increase overhead!"
-        )
+        logger.debug("Enabled heap profiling: heap_sample_rate=#{heap_sample_rate}")
 
         true
       end
@@ -237,10 +240,6 @@ module Datadog
 
         return false unless heap_profiling_enabled && heap_size_profiling_enabled
 
-        logger.warn(
-          "Enabled experimental heap size profiling. This is experimental, not recommended, and will increase overhead!"
-        )
-
         true
       end
 

data/lib/datadog/profiling/exporter.rb

@@ -26,7 +26,8 @@ module Datadog
         :last_flush_finish_at,
         :created_at,
         :internal_metadata,
-        :info_json
+        :info_json,
+        :sequence_tracker
 
       public
 
@@ -37,7 +38,8 @@ module Datadog
         code_provenance_collector:,
         internal_metadata:,
         minimum_duration_seconds: PROFILE_DURATION_THRESHOLD_SECONDS,
-        time_provider: Time
+        time_provider: Time,
+        sequence_tracker: Datadog::Profiling::SequenceTracker
       )
         @pprof_recorder = pprof_recorder
         @worker = worker
@@ -50,6 +52,7 @@ module Datadog
         # NOTE: At the time of this comment collected info does not change over time so we'll hardcode
         #       it on startup to prevent serializing the same info on every flush.
         @info_json = JSON.generate(info_collector.info).freeze
+        @sequence_tracker = sequence_tracker
       end
 
       def flush
@@ -73,7 +76,10 @@ module Datadog
           encoded_profile: encoded_profile,
           code_provenance_file_name: Datadog::Profiling::Ext::Transport::HTTP::CODE_PROVENANCE_FILENAME,
           code_provenance_data: uncompressed_code_provenance,
-          tags_as_array: Datadog::Profiling::TagBuilder.call(settings: Datadog.configuration).to_a,
+          tags_as_array: Datadog::Profiling::TagBuilder.call(
+            settings: Datadog.configuration,
+            profile_seq: sequence_tracker.get_next,
+          ).to_a,
           internal_metadata: internal_metadata.merge(
             {
               worker_stats: worker_stats,

data/lib/datadog/profiling/ext.rb

@@ -11,19 +11,7 @@ module Datadog
 
       module Transport
         module HTTP
-          FORM_FIELD_TAG_ENV = "env"
-          FORM_FIELD_TAG_HOST = "host"
-          FORM_FIELD_TAG_LANGUAGE = "language"
-          FORM_FIELD_TAG_PID = "process_id"
           FORM_FIELD_TAG_PROFILER_VERSION = "profiler_version"
-          FORM_FIELD_TAG_RUNTIME = "runtime"
-          FORM_FIELD_TAG_RUNTIME_ENGINE = "runtime_engine"
-          FORM_FIELD_TAG_RUNTIME_ID = "runtime-id"
-          FORM_FIELD_TAG_RUNTIME_VERSION = "runtime_version"
-          FORM_FIELD_TAG_SERVICE = "service"
-          FORM_FIELD_TAG_VERSION = "version"
-          TAG_GIT_REPOSITORY_URL = "git.repository_url"
-          TAG_GIT_COMMIT_SHA = "git.commit.sha"
 
           CODE_PROVENANCE_FILENAME = "code-provenance.json"
         end

data/lib/datadog/profiling/http_transport.rb

@@ -37,7 +37,7 @@ module Datadog
             Datadog.logger.debug("Successfully reported profiling data")
             true
           else
-            Datadog.logger.error(
+            Datadog.logger.warn(
               "Failed to report profiling data (#{config_without_api_key}): " \
               "server returned unexpected HTTP #{result} status code"
             )
@@ -47,7 +47,7 @@ module Datadog
             false
           end
         else
-          Datadog.logger.error("Failed to report profiling data (#{config_without_api_key}): #{result}")
+          Datadog.logger.warn("Failed to report profiling data (#{config_without_api_key}): #{result}")
           Datadog::Core::Telemetry::Logger.error("Failed to report profiling data")
           false
         end

data/lib/datadog/profiling/profiler.rb

@@ -50,6 +50,8 @@ module Datadog
           "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
           "See previous log messages for details."
         )
+        Datadog::Core::Telemetry::Logger
+          .error("Detected issue with profiler (#{failed_component} component), stopping profiling")
 
         # 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.

data/lib/datadog/profiling/scheduler.rb

@@ -68,6 +68,7 @@ module Datadog
           "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
         )
         on_failure_proc&.call
+        Datadog::Core::Telemetry::Logger.report(e, description: "Profiling::Scheduler thread error")
         raise
       ensure
         Datadog.logger.debug("#flush was interrupted or failed before it could complete") if interrupted
@@ -133,7 +134,7 @@ module Datadog
         begin
           transport.export(flush)
         rescue => e
-          Datadog.logger.error(
+          Datadog.logger.warn(
             "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")

data/lib/datadog/profiling/sequence_tracker.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../core/utils/forking'
+
+module Datadog
+  module Profiling
+    # Used to generate the `profile_seq` tag, which effectively counts how many profiles we've attempted to report
+    # from a given runtime-id.
+    #
+    # Note that the above implies a few things:
+    # 1. The sequence number only gets incremented when we decide to report a profile and create a `Flush` for it
+    # 2. The `SequenceTracker` must live across profiler reconfigurations and resets, since no matter how many
+    #    profiler instances get created due to reconfiguration, the runtime-id is still the same, so the sequence number
+    #    should be kept and not restarted from 0
+    # 3. The `SequenceTracker` must be reset after a fork, since the runtime-id will change, and we want to start
+    #    counting from 0 again
+    #
+    # This is why this module is implemented as a singleton that we reuse, not as an instance that we recreate.
+    #
+    # Note that this module is not thread-safe, so it's up to the callers to make sure
+    # it's only used by a single thread at a time (which is what the `Profiling::Exporter`)
+    # is doing.
+    module SequenceTracker
+      class << self
+        include Core::Utils::Forking
+
+        def get_next
+          reset! unless defined?(@sequence_number)
+          after_fork! { reset! }
+
+          next_seq = @sequence_number
+          @sequence_number += 1
+          next_seq
+        end
+
+        private
+
+        def reset!
+          @sequence_number = 0
+        end
+      end
+    end
+  end
+end

data/lib/datadog/profiling/stack_recorder.rb

@@ -23,7 +23,7 @@ module Datadog
         # This isn't something we expect to happen normally, but because it would break the assumptions of the
         # C-level mutexes (that there is a single serializer thread), we add it here as an extra safeguard against it
         # accidentally happening.
-        @no_concurrent_synchronize_mutex = Mutex.new
+        @no_concurrent_serialize_mutex = Mutex.new
 
         self.class._native_initialize(
           self_instance: self,
@@ -60,7 +60,7 @@ module Datadog
       end
 
       def serialize
-        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+        status, result = @no_concurrent_serialize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
           start, finish, encoded_profile, profile_stats = result
@@ -71,15 +71,15 @@ module Datadog
         else
           error_message = result
 
-          Datadog.logger.error("Failed to serialize profiling data: #{error_message}")
-          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data")
+          Datadog.logger.warn("Failed to serialize profiling data: #{error_message}")
+          Datadog::Core::Telemetry::Logger.error("Failed to serialize profiling data (#{error_message})")
 
           nil
         end
       end
 
       def serialize!
-        status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
+        status, result = @no_concurrent_serialize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
           _start, _finish, encoded_profile = result

data/lib/datadog/profiling/tag_builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../core/tag_builder"
 require_relative "../core/utils"
-require_relative "../core/environment/git"
 
 module Datadog
   module Profiling
@@ -11,45 +11,15 @@ module Datadog
 
       def self.call(
         settings:,
-        # Unified service tagging
-        env: settings.env,
-        service: settings.service,
-        version: settings.version,
         # Other metadata
-        host: Core::Environment::Socket.hostname,
-        language: Core::Environment::Identity.lang,
-        pid: Process.pid.to_s,
-        profiler_version: Core::Environment::Identity.gem_datadog_version,
-        runtime_engine: Core::Environment::Identity.lang_engine,
-        runtime_id: Core::Environment::Identity.id,
-        runtime_version: Core::Environment::Identity.lang_version,
-        git_repository_url: Core::Environment::Git.git_repository_url,
-        git_commit_sha: Core::Environment::Git.git_commit_sha,
-        # User-provided tags
-        user_tags: settings.tags
+        profile_seq:,
+        profiler_version: Core::Environment::Identity.gem_datadog_version
       )
-        tags = {
-          # When changing or adding these, make sure they are kept in sync with
-          # https://docs.google.com/spreadsheets/d/1LOGMf4c4Avbtn36uZ2SWvhIGKRPLM1BoWkUP4JYj7hA/ (Datadog internal link)
-          FORM_FIELD_TAG_HOST => host,
-          FORM_FIELD_TAG_LANGUAGE => language,
-          FORM_FIELD_TAG_PID => pid,
+        hash = Core::TagBuilder.tags(settings).merge(
           FORM_FIELD_TAG_PROFILER_VERSION => profiler_version,
-          FORM_FIELD_TAG_RUNTIME => language, # This is known to be repeated from language, above
-          FORM_FIELD_TAG_RUNTIME_ENGINE => runtime_engine,
-          FORM_FIELD_TAG_RUNTIME_ID => runtime_id,
-          FORM_FIELD_TAG_RUNTIME_VERSION => runtime_version,
-        }
-        tags[FORM_FIELD_TAG_ENV] = env if env
-        tags[FORM_FIELD_TAG_SERVICE] = service if service
-        tags[FORM_FIELD_TAG_VERSION] = version if version
-        tags[TAG_GIT_REPOSITORY_URL] = git_repository_url if git_repository_url
-        tags[TAG_GIT_COMMIT_SHA] = git_commit_sha if git_commit_sha
-
-        # Make sure everything is an utf-8 string, to avoid encoding issues in native code/further downstream
-        user_tags.merge(tags).map do |key, value|
-          [Datadog::Core::Utils.utf8_encode(key), Datadog::Core::Utils.utf8_encode(value)]
-        end.to_h
+          'profile_seq' => profile_seq.to_s,
+        )
+        Core::Utils.encode_tags(hash)
       end
     end
   end

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

@@ -19,6 +19,7 @@ module Datadog
               "Profiler extensions unavailable. Cause: #{e.class.name} #{e.message} " \
               "Location: #{Array(e.backtrace).first}"
             end
+            Datadog::Core::Telemetry::Logger.report(e, description: "Profiler extensions unavailable")
           end
         end
 
@@ -33,6 +34,7 @@ module Datadog
               "Error during post-fork hooks. Cause: #{e.class.name} #{e.message} " \
               "Location: #{Array(e.backtrace).first}"
             end
+            Datadog::Core::Telemetry::Logger.report(e, description: "Error during post-fork hooks")
           end
         end
       end

data/lib/datadog/profiling.rb

@@ -157,6 +157,7 @@ module Datadog
       require_relative 'profiling/native_extension'
       require_relative 'profiling/tag_builder'
       require_relative 'profiling/http_transport'
+      require_relative 'profiling/sequence_tracker'
 
       replace_noop_allocation_count
 

data/lib/datadog/single_step_instrument.rb

@@ -5,8 +5,17 @@
 #
 # This file's path is private. Do not reference this file.
 #
+
+module Datadog
+  # This module handles conditional loading of single step auto-instrumentation,
+  # which enables Datadog tracing and profiling features when available.
+  module SingleStepInstrument
+  end
+end
+
 begin
   require_relative 'auto_instrument'
+  Datadog::SingleStepInstrument::LOADED = true
 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_pack/action_controller/instrumentation.rb

@@ -68,6 +68,12 @@ module Datadog
 
                 span.set_tag(Ext::TAG_ROUTE_ACTION, payload.fetch(:action))
                 span.set_tag(Ext::TAG_ROUTE_CONTROLLER, payload.fetch(:controller))
+                if (runtime = payload[:view_runtime])
+                  span.set_tag(Ext::TAG_VIEW_RUNTIME, runtime)
+                end
+                if (runtime = payload[:db_runtime])
+                  span.set_tag(Ext::TAG_DB_RUNTIME, runtime)
+                end
 
                 exception = payload[:exception_object]
                 if exception.nil?
@@ -118,6 +124,15 @@ module Datadog
                   payload[:exception] = [e.class.name, e.message]
                   payload[:exception_object] = e
                   raise e
+                ensure
+                  # Database and view runtime are available for controllers
+                  # deriving from ActionController::Base.
+                  # They are not defined on controllers deriving from
+                  # ActionController::Metal, unless
+                  # ActionController::Instrumentation is explicitly included
+                  # into the controller class.
+                  payload[:db_runtime] = db_runtime if respond_to?(:db_runtime)
+                  payload[:view_runtime] = view_runtime if respond_to?(:view_runtime)
                 end
               # rubocop:enable Lint/RescueException
               ensure

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

@@ -9,9 +9,12 @@ module Datadog
         module ActionDispatch
           # Instrumentation for ActionDispatch components
           module Instrumentation
+            SCRIPT_NAME_KEY = 'SCRIPT_NAME'
+            FORMAT_SUFFIX = '(.:format)'
+
             module_function
 
-            def set_http_route_tags(route_spec, script_name)
+            def set_http_route_tags(route_spec, route_path)
               return unless Tracing.enabled?
 
               return unless route_spec
@@ -19,10 +22,10 @@ module Datadog
               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/, ''))
+              request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, route_spec)
 
-              if script_name && !script_name.empty?
-                request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, script_name)
+              if route_path && !route_path.empty?
+                request_trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, route_path)
               end
             end
 
@@ -40,16 +43,17 @@ module Datadog
               # Instrumentation for ActionDispatch::Journey::Router for Rails versions older than 7.1
               module Router
                 def find_routes(req)
+                  # result is an array of [match, parameters, route] tuples
                   result = super
+                  result.each do |_, _, route|
+                    next unless Instrumentation.dispatcher_route?(route)
 
-                  # result is an array of [match, parameters, route] tuples
-                  routes = result.map(&:last)
+                    http_route = route.path.spec.to_s
+                    http_route.delete_suffix!(FORMAT_SUFFIX)
 
-                  routes.each do |route|
-                    if Instrumentation.dispatcher_route?(route)
-                      Instrumentation.set_http_route_tags(route.path.spec, req.env['SCRIPT_NAME'])
-                      break
-                    end
+                    Instrumentation.set_http_route_tags(http_route, req.env[SCRIPT_NAME_KEY])
+
+                    break
                   end
 
                   result
@@ -62,7 +66,10 @@ module Datadog
                 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'])
+                      http_route = route.path.spec.to_s
+                      http_route.delete_suffix!(FORMAT_SUFFIX)
+
+                      Instrumentation.set_http_route_tags(http_route, req.env[SCRIPT_NAME_KEY])
                     end
 
                     yield [match, parameters, route]

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

@@ -16,6 +16,8 @@ module Datadog
           TAG_OPERATION_CONTROLLER = 'controller'
           TAG_ROUTE_ACTION = 'rails.route.action'
           TAG_ROUTE_CONTROLLER = 'rails.route.controller'
+          TAG_DB_RUNTIME = 'rails.db.runtime'
+          TAG_VIEW_RUNTIME = 'rails.view.runtime'
         end
       end
     end

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

@@ -45,9 +45,15 @@ module Datadog
                 'cache_write_multi.active_support' => { resource: Ext::RESOURCE_CACHE_MSET, multi_key: true }
               }.freeze
 
-              def trace?(event, _payload)
+              def trace?(event, payload)
                 return false if !Tracing.enabled? || !configuration.enabled
 
+                if (cache_store = configuration[:cache_store])
+                  store = cache_backend(payload[:store])
+
+                  return false unless cache_store.include?(store)
+                end
+
                 # DEV-3.0: Backwards compatibility code for the 2.x gem series.
                 # DEV-3.0: See documentation at {Datadog::Tracing::Contrib::ActiveSupport::Cache::Instrumentation}
                 # DEV-3.0: for the complete information about this backwards compatibility code.

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

@@ -49,6 +49,19 @@ module Datadog
                 o.default true
               end
             end
+
+            # Specifies which cache stores to trace.
+            # Accepts a list, with the same format as `config.cache_store`
+            # (e.g. `memory_store`, `file_store`, or symbols like `:file_store`).
+            # Defaults to `nil`, which traces all cache stores.
+            # @see https://github.com/rails/rails/blob/b7520a13adda46c0cc5f3fb4a4c1726633af2bba/guides/source/caching_with_rails.md?plain=1#L576-L582
+            option :cache_store do |o|
+              o.type :array, nilable: true
+              o.default nil
+              o.after_set do |stores|
+                stores&.map!(&:to_s) # Convert symbols to strings to match the Rails configuration format
+              end
+            end
           end
         end
       end

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

@@ -20,10 +20,12 @@ module Datadog
 
           # patch applies our patch
           def patch
+            # First check Lograge logger directly for when keep_original_rails_log option is used
+            used_logger = ::Lograge.logger || ::Lograge::LogSubscribers::ActionController.logger
+
             # ActiveSupport::TaggedLogging is the default Rails logger since Rails 5
             if defined?(::ActiveSupport::TaggedLogging::Formatter) &&
-                ::Lograge::LogSubscribers::ActionController
-                    .logger&.formatter.is_a?(::ActiveSupport::TaggedLogging::Formatter)
+                used_logger&.formatter.is_a?(::ActiveSupport::TaggedLogging::Formatter)
               Datadog.logger.warn(
                 'Lograge and ActiveSupport::TaggedLogging (the default Rails log formatter) are not compatible: ' \
                   'Lograge does not account for Rails log tags, creating polluted logs and breaking log formatting. ' \

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

@@ -45,16 +45,13 @@ module Datadog
                 span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
                 span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_QUERY)
 
-                span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, query_options[:host])
+                tag_database_instance(span, query_options[:database])
+
+                set_span_tags(span, query_options)
 
                 # Set analytics sample rate
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
-                span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, query_options[:database])
-                span.set_tag(Ext::TAG_DB_NAME, query_options[:database])
-                span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, query_options[:host])
-                span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, query_options[:port])
-
                 Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
 
                 sql = inject_propagation(span, sql, trace_op)
@@ -91,6 +88,19 @@ module Datadog
             def analytics_sample_rate
               datadog_configuration[:analytics_sample_rate]
             end
+
+            def tag_database_instance(span, database)
+              return if database.nil? || database.empty?
+
+              span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, database)
+              span.set_tag(Ext::TAG_DB_NAME, database)
+            end
+
+            def set_span_tags(span, query_options)
+              span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, query_options[:host])
+              span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, query_options[:port])
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, query_options[:host])
+            end
           end
         end
       end

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

@@ -86,7 +86,10 @@ module Datadog
 
           # Instruments the `bin/rails runner` command.
           def patch_rails_runner
-            ::Rails::Command.singleton_class.prepend(Command) if defined?(::Rails::Command)
+            # The `RunnerCommand` class is only available in Rails 5.1 and later.
+            if defined?(::Rails::Command::RunnerCommand) && Integration.version >= Gem::Version.new('5.1')
+              ::Rails::Command::RunnerCommand.prepend(Runner)
+            end
           end
         end
       end