datadog 2.41.0 → 2.42.0

data/ext/datadog_profiling_native_extension/heap_recorder.h

@@ -80,9 +80,9 @@ void heap_recorder_set_size_enabled(heap_recorder *heap_recorder, bool size_enab
 // Controls how many recordings will be ignored before committing a heap allocation and
 // the weight of the committed heap allocation.
 //
-// A value of 1 will effectively track all objects that are passed through
-// start/end_heap_allocation_recording pairs. A value of 10 will only track every 10th
-// object passed through such calls and its effective weight for the purposes of heap
+// A value of 1 will effectively track all objects that are passed to
+// `heap_recorder_record_allocation`. A value of 10 will only track every 10th
+// object passed to it and its effective weight for the purposes of heap
 // profiling will be multiplied by 10.
 //
 // NOTE: Default is 1, i.e., track all heap allocation recordings.
@@ -94,45 +94,47 @@ void heap_recorder_set_sample_rate(heap_recorder *heap_recorder, int sample_rate
 // WARN: Assumes this gets called before profiler is reinitialized on the fork
 void heap_recorder_after_fork(heap_recorder *heap_recorder);
 
-// Start a heap allocation recording on the heap recorder for a new object.
+// Record a heap allocation on the heap recorder.
 //
-// This heap allocation recording needs to be ended via ::end_heap_allocation_recording
-// before it will become fully committed and able to be iterated on.
+// The recording is added to a pending list, and only becomes fully tracked and able to be iterated on once
+// `heap_recorder_commit_recordings_may_lose_gvl` gets to it.
 //
-// @param new_obj
+// @param new_object
 //   The newly allocated Ruby object/value.
 // @param weight
 //   The sampling weight of this object.
-//
-// WARN: It needs to be paired with a ::end_heap_allocation_recording call.
-// Returns needs_after_allocation: true whenever the pending_recordings buffer goes from empty to non-empty and thus
-// a after_sample callback is required to flush it
-bool start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj, unsigned int weight, ddog_CharSlice alloc_class);
-
-// End a previously started heap allocation recording on the heap recorder.
-//
-// It is at this point that an allocated object will become fully tracked and able to be iterated on.
-//
-// @param locations The stacktrace representing the location of the allocation.
-//
-// WARN: It is illegal to call this without previously having called ::start_heap_allocation_recording.
-// WARN: This method rescues exceptions with `rb_protect`, returning the exception state integer for the caller to handle.
-__attribute__((warn_unused_result))
-int end_heap_allocation_recording_with_rb_protect(heap_recorder *heap_recorder, ddog_prof_Slice_Location locations);
+// @param alloc_class
+//   The class of the newly allocated object.
+// @param locations
+//   The stacktrace representing the location of the allocation.
+// @param needs_commit
+//   Out: set to whether there are pending recordings, and thus a `heap_recorder_commit_recordings_may_lose_gvl`
+//   callback is needed to commit them. Note that we answer this on every call, including the ones where we don't
+//   record anything: asking again is how we recover if a commit gets skipped for any reason.
+//
+// WARN: This gets called from inside the RUBY_INTERNAL_EVENT_NEWOBJ tracepoint, so it neither allocates in the Ruby
+// heap nor releases the GVL (https://github.com/DataDog/dd-trace-rb/pull/4240).
+void heap_recorder_record_allocation(
+  heap_recorder *heap_recorder,
+  VALUE new_object,
+  unsigned int weight,
+  ddog_CharSlice alloc_class,
+  ddog_prof_Slice_Location locations,
+  bool *needs_commit
+);
 
 // Update the heap recorder, **checking young objects only**. The idea here is to align with GC: most young objects never
 // survive enough GC generations, and thus periodically running this method reduces memory usage (we get rid of
 // these objects quicker) and hopefully reduces tail latency (because there's less objects at serialization time to check).
 void heap_recorder_update_young_objects(heap_recorder *heap_recorder);
 
-// Finalize any pending heap allocation recordings by getting their object IDs.
+// Commit any pending heap allocation recordings by taking a weak reference to their objects.
 // This should be called via a postponed job, after the on_newobj_event has completed.
-// Raises an exception if a fatal error occurs (e.g., bignum object ID detected).
-void heap_recorder_finalize_pending_recordings(heap_recorder *heap_recorder);
+void heap_recorder_commit_recordings_may_lose_gvl(heap_recorder *heap_recorder);
 
-// Mark pending recordings to prevent GC from collecting the objects
-// while they're waiting for the recordings to be finalized.
-void heap_recorder_mark_pending_recordings(heap_recorder *heap_recorder);
+// Mark the Ruby objects the heap recorder holds on to: the objects of any pending recordings (so that GC does not
+// collect them while they're waiting to be committed) and the weak map itself.
+void heap_recorder_mark(heap_recorder *heap_recorder);
 
 // Update the heap recorder to reflect the latest state of the VM and prepare internal structures
 // for efficient iteration.
@@ -179,10 +181,23 @@ VALUE heap_recorder_state_snapshot(heap_recorder *heap_recorder);
 // troubleshoot issues such as unexpected test failures.
 VALUE heap_recorder_testonly_debug(heap_recorder *heap_recorder);
 
-// Check if a given object_id is being tracked or not
-VALUE heap_recorder_testonly_is_object_recorded(heap_recorder *heap_recorder, VALUE obj_id);
+// Check if a given record_id is being tracked or not
+VALUE heap_recorder_testonly_is_object_recorded(heap_recorder *heap_recorder, long record_id);
+
+// Returns the record id being used to track the given (still alive) object, or nil if it's not being tracked (which
+// includes the case where heap profiling is disabled). This lets tests hold on to a record id and keep asking about
+// it after the object itself is gone.
+// NOTE: This is a linear scan over the tracked objects; fine for the small numbers tests track.
+VALUE heap_recorder_testonly_record_id_for(heap_recorder *heap_recorder, VALUE obj);
 
 // Used to ensure that a GC actually triggers an update of the objects
 void heap_recorder_testonly_reset_last_update(heap_recorder *heap_recorder);
 
+// Exhausts the usable record ids, so that all subsequent heap recordings raise (the id keeps being incremented, so
+// there's no going back). Used to test that our callers correctly handle a heap recorder that raises in the middle of
+// recording a sample.
+//
+// WARN: This should only be used for testing.
+void heap_recorder_testonly_exhaust_record_ids(heap_recorder *heap_recorder);
+
 void heap_recorder_testonly_benchmark_intern(heap_recorder *heap_recorder, ddog_CharSlice string, int times, bool use_all);

data/ext/datadog_profiling_native_extension/native_extension_helpers.rb

@@ -9,9 +9,6 @@ module Datadog
       # Can be set to force rubygems to fail gem installation when profiling extension could not be built
       ENV_FAIL_INSTALL_IF_MISSING_EXTENSION = "DD_PROFILING_FAIL_INSTALL_IF_MISSING_EXTENSION"
 
-      # The MJIT header was introduced on 2.6 and removed on 3.3; for other Rubies we rely on datadog-ruby_core_source
-      CAN_USE_MJIT_HEADER = RUBY_VERSION.start_with?("2.6", "2.7", "3.0.", "3.1.", "3.2.")
-
       def self.fail_install_if_missing_extension?
         ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == "true"
       end
@@ -35,7 +32,6 @@ module Datadog
             on_macos? ||
             on_unknown_os? ||
             on_unsupported_cpu_arch? ||
-            expected_to_use_mjit_but_mjit_is_disabled? ||
             libdatadog_not_available? ||
             libdatadog_not_usable?
         end
@@ -97,13 +93,6 @@ module Datadog
           suggested: CONTACT_SUPPORT,
         )
 
-        # Validation for this check is done in extconf.rb because it relies on mkmf
-        COMPILATION_BROKEN = explain_issue(
-          "compilation of the Ruby VM just-in-time header failed.",
-          "Your C compiler or Ruby VM just-in-time compiler seem to be broken.",
-          suggested: CONTACT_SUPPORT,
-        )
-
         # Validation for this check is done in extconf.rb because it relies on mkmf
         COMPILER_ATOMIC_MISSING = explain_issue(
           "your C compiler is missing support for the <stdatomic.h> header.",
@@ -187,19 +176,6 @@ module Datadog
           architecture_not_supported unless RUBY_PLATFORM.start_with?("x86_64", "aarch64", "arm64")
         end
 
-        # On some Rubies, we require the mjit header to be present. If Ruby was installed without MJIT support, we also skip
-        # building the extension.
-        private_class_method def self.expected_to_use_mjit_but_mjit_is_disabled?
-          ruby_without_mjit = explain_issue(
-            "your Ruby has been compiled without JIT support (--disable-jit-support).",
-            "The profiling native extension requires a Ruby compiled with JIT support,",
-            "even if the JIT is not in use by the application itself.",
-            suggested: CONTACT_SUPPORT,
-          )
-
-          ruby_without_mjit if CAN_USE_MJIT_HEADER && RbConfig::CONFIG["MJIT_SUPPORT"] != "yes"
-        end
-
         private_class_method def self.libdatadog_not_available?
           Datadog::LibdatadogExtconfHelpers.try_loading_libdatadog do |exception|
             explain_issue(