datadog-ci 1.36.1 → 1.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70fc5fea2d200dd9654e43d303bc20ca67937ee3d6fdc03ff5595d5c22991424
-  data.tar.gz: 0ad11c672983e445ef7baed4fcf15af2c4710871b90962076f3075b572383ca7
+  metadata.gz: 4a6bdfb71fe5140388ad8b1ea7a086977ba9a4a69c86fdc1b465746f287ba2ec
+  data.tar.gz: 27615bb724035bc22617b7495cac97cac343fac08da9363fba31e7a4fc21a84e
 SHA512:
-  metadata.gz: c0df4d0e21c6bab928409176b1eee9b401532eac85b9522623c88dd89f54e4a75cb64c3c528cc508357cc77642e3c7e042bc6459edffea8423ef94d48dd6ee4d
-  data.tar.gz: '07888f1e31d079859c4e3bcfde608dc6c5c56028857f5c4feb58cbdacac4ab7be6a9865076174cf27cc7d6f9d1868e3f4a7cc6a1e014cd74c34982e335151b55'
+  metadata.gz: 9ae087aef544b7775bb9784fb64a27a836e3181076229cac5c814d4263ecb02432f723d9e136350aba020d6ad67820a8658edcce62fb3dcccea5d5efff999820
+  data.tar.gz: aca348e24dba29c5a98fe60fe7e89879257e1466bce6b179c9efd43c40e4f3f1cffb2641f1d35fd54adbd111ba0c1f957db144848702fb51b0bf567282508ace

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [1.38.0] - 2026-08-28
+
+### Added
+* Trace RSpec and Minitest lifecycle steps ([#595][])
+
+### Changed
+* Optimize TIA performance ([#589][])
+
+### Fixed
+* Isolate state between parallel_tests sessions ([#593][])
+* Test Optimization telemetry shutdown order ([#586][])
+
+### Removed
+* Disable LiveDebugger's SymDB upload in CI mode ([#594][])
+
+## [1.37.0] - 2026-08-19
+
 ## [1.36.1] - 2026-08-11
 
 ### Fixed
@@ -682,7 +699,9 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 
 - Ruby versions < 2.7 no longer supported ([#8][])
 
-[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.36.1...main
+[Unreleased]: https://github.com/DataDog/datadog-ci-rb/compare/v1.38.0...main
+[1.38.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.37.0...v1.38.0
+[1.37.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.36.1...v1.37.0
 [1.36.1]: https://github.com/DataDog/datadog-ci-rb/compare/v1.36.0...v1.36.1
 [1.36.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.35.0...v1.36.0
 [1.35.0]: https://github.com/DataDog/datadog-ci-rb/compare/v1.34.0...v1.35.0
@@ -966,4 +985,9 @@ Currently test suite level visibility is not used by our instrumentation: it wil
 [#554]: https://github.com/DataDog/datadog-ci-rb/issues/554
 [#555]: https://github.com/DataDog/datadog-ci-rb/issues/555
 [#566]: https://github.com/DataDog/datadog-ci-rb/issues/566
-[#570]: https://github.com/DataDog/datadog-ci-rb/issues/570
+[#570]: https://github.com/DataDog/datadog-ci-rb/issues/570
+[#586]: https://github.com/DataDog/datadog-ci-rb/issues/586
+[#589]: https://github.com/DataDog/datadog-ci-rb/issues/589
+[#593]: https://github.com/DataDog/datadog-ci-rb/issues/593
+[#594]: https://github.com/DataDog/datadog-ci-rb/issues/594
+[#595]: https://github.com/DataDog/datadog-ci-rb/issues/595

data/ext/datadog_ci_native/ci.c

@@ -1,11 +1,15 @@
 #include "datadog_cov.h"
 #include "datadog_method_inspect.h"
+#include "file_serialization.h"
 #include "iseq_collector.h"
 
 void Init_datadog_ci_native(void) {
   // Coverage::DDCov
   Init_datadog_cov();
 
+  // FileSerialization
+  Init_file_serialization();
+
   // SourceCode
   Init_datadog_method_inspect();
   Init_dd_ci_iseq_collector();

data/ext/datadog_ci_native/datadog_common.c

@@ -2,14 +2,25 @@
 #include <ruby.h>
 #include <string.h>
 
-bool dd_ci_is_path_included(const char *path, const char *root_path,
-                            long root_path_len, const char *ignored_path,
-                            long ignored_path_len) {
-  if (strncmp(root_path, path, root_path_len) != 0) {
+static bool has_directory_prefix(const char *path, long path_len,
+                                 const char *prefix, long prefix_len) {
+  if (prefix_len > path_len || memcmp(prefix, path, prefix_len) != 0) {
     return false;
   }
-  if (ignored_path_len > 0 &&
-      strncmp(ignored_path, path, ignored_path_len) == 0) {
+
+  return prefix_len == path_len || prefix[prefix_len - 1] == '/' ||
+         path[prefix_len] == '/';
+}
+
+bool dd_ci_is_path_included(const char *path, long path_len,
+                            const char *root_path, long root_path_len,
+                            const char *ignored_path, long ignored_path_len) {
+  if (!has_directory_prefix(path, path_len, root_path, root_path_len)) {
+    return false;
+  }
+  if (ignored_path_len > 0 && has_directory_prefix(
+                                  path, path_len, ignored_path,
+                                  ignored_path_len)) {
     return false;
   }
   return true;

data/ext/datadog_ci_native/datadog_common.h

@@ -11,14 +11,15 @@
  * Returns true if the path should be included, false otherwise.
  *
  * @param path          The file path to check
+ * @param path_len      Length of path
  * @param root_path     The root path prefix (required)
  * @param root_path_len Length of root_path
  * @param ignored_path  Path prefix to exclude (can be NULL)
  * @param ignored_path_len Length of ignored_path (0 if not set)
  */
-bool dd_ci_is_path_included(const char *path, const char *root_path,
-                            long root_path_len, const char *ignored_path,
-                            long ignored_path_len);
+bool dd_ci_is_path_included(const char *path, long path_len,
+                            const char *root_path, long root_path_len,
+                            const char *ignored_path, long ignored_path_len);
 
 /* ---- Utility functions -------------------------------------------------- */
 

data/ext/datadog_ci_native/datadog_cov.c

@@ -3,6 +3,7 @@
 #include <ruby/st.h>
 
 #include <stdbool.h>
+#include <string.h>
 
 #include "datadog_common.h"
 
@@ -11,12 +12,26 @@
 // running only the tests that are affected by the changes.
 
 #define PROFILE_FRAMES_BUFFER_SIZE 1
+#define SEEN_FILENAME_CACHE_SIZE 1024
+#define SEEN_ALLOCATED_CLASS_CACHE_SIZE 4096
+#define KLASS_FILES_CACHE_SIZE 100000
+
+#if SEEN_FILENAME_CACHE_SIZE == 0 ||                                       \
+    (SEEN_FILENAME_CACHE_SIZE & (SEEN_FILENAME_CACHE_SIZE - 1)) != 0
+#error "SEEN_FILENAME_CACHE_SIZE must be a power of two"
+#endif
+
+#if SEEN_ALLOCATED_CLASS_CACHE_SIZE == 0 ||                               \
+    (SEEN_ALLOCATED_CLASS_CACHE_SIZE &                                   \
+     (SEEN_ALLOCATED_CLASS_CACHE_SIZE - 1)) != 0
+#error "SEEN_ALLOCATED_CLASS_CACHE_SIZE must be a power of two"
+#endif
 
 // threading modes
 enum threading_mode { single, multi };
 
 // functions declarations
-static void on_newobj_event(VALUE tracepoint_data, void *data);
+static void on_newobj_event(VALUE self, const rb_trace_arg_t *tracearg);
 
 static int mark_key_for_gc_i(st_data_t key, st_data_t _value, st_data_t _data) {
   VALUE klass = (VALUE)key;
@@ -25,6 +40,15 @@ static int mark_key_for_gc_i(st_data_t key, st_data_t _value, st_data_t _data) {
   return ST_CONTINUE;
 }
 
+static int mark_klass_files_for_gc_i(st_data_t key, st_data_t value,
+                                     st_data_t _data) {
+  // Both the class key and its cached filenames must remain at stable addresses
+  // because they are stored outside Ruby's object containers.
+  rb_gc_mark((VALUE)key);
+  rb_gc_mark((VALUE)value);
+  return ST_CONTINUE;
+}
+
 // Data structure
 struct dd_cov_data {
   // Ruby hash with filenames impacted by the test.
@@ -40,9 +64,12 @@ struct dd_cov_data {
   char *ignored_path;
   long ignored_path_len;
 
-  // Line tracepoint optimisation: cache last seen filename pointer to avoid
-  // unnecessary string comparison if we stay in the same file.
-  uintptr_t last_filename_ptr;
+  // Line tracepoint optimisation: make consecutive events from the same file a
+  // single comparison, then use a direct-mapped cache for later revisits. Keep
+  // the Ruby strings alive so their pointers cannot be reused for other paths.
+  // A collision only repeats path processing; it can never suppress coverage.
+  VALUE last_filename;
+  VALUE seen_filenames[SEEN_FILENAME_CACHE_SIZE];
 
   // Line tracepoint can work in two modes: single threaded and multi threaded
   //
@@ -61,22 +88,38 @@ struct dd_cov_data {
   // contain any methods that could be covered by line tracepoint.
   //
   // Allocation tracing works only in multi threaded mode.
-  VALUE object_allocation_tracepoint;
+  bool allocation_tracing_enabled;
+  bool allocation_hook_active;
   st_table *klasses_table; // { (VALUE) -> int } hashmap with class names that
                            // were covered by allocation during the test run
+  VALUE last_allocated_klass;
+  VALUE seen_allocated_klasses[SEEN_ALLOCATED_CLASS_CACHE_SIZE];
+  st_table *klass_files_cache; // { (VALUE) -> Array<String> } resolved files
+  size_t klass_files_cache_size;
 };
 
 static void dd_cov_mark(void *ptr) {
   struct dd_cov_data *dd_cov_data = ptr;
   rb_gc_mark_movable(dd_cov_data->impacted_files);
   rb_gc_mark_movable(dd_cov_data->th_covered);
-  rb_gc_mark_movable(dd_cov_data->object_allocation_tracepoint);
+
+  if (dd_cov_data->last_filename != Qnil) {
+    rb_gc_mark(dd_cov_data->last_filename);
+  }
+  for (size_t i = 0; i < SEEN_FILENAME_CACHE_SIZE; i++) {
+    if (dd_cov_data->seen_filenames[i] != Qnil) {
+      rb_gc_mark(dd_cov_data->seen_filenames[i]);
+    }
+  }
 
   // if GC starts withing dd_cov_allocate() call, klasses_table might not be
   // initialized yet
   if (dd_cov_data->klasses_table != NULL) {
     st_foreach(dd_cov_data->klasses_table, mark_key_for_gc_i, 0);
   }
+  if (dd_cov_data->klass_files_cache != NULL) {
+    st_foreach(dd_cov_data->klass_files_cache, mark_klass_files_for_gc_i, 0);
+  }
 }
 
 static void dd_cov_free(void *ptr) {
@@ -84,6 +127,7 @@ static void dd_cov_free(void *ptr) {
   xfree(dd_cov_data->root);
   xfree(dd_cov_data->ignored_path);
   st_free_table(dd_cov_data->klasses_table);
+  st_free_table(dd_cov_data->klass_files_cache);
   xfree(dd_cov_data);
 }
 
@@ -91,8 +135,6 @@ static void dd_cov_compact(void *ptr) {
   struct dd_cov_data *dd_cov_data = ptr;
   dd_cov_data->impacted_files = rb_gc_location(dd_cov_data->impacted_files);
   dd_cov_data->th_covered = rb_gc_location(dd_cov_data->th_covered);
-  dd_cov_data->object_allocation_tracepoint =
-      rb_gc_location(dd_cov_data->object_allocation_tracepoint);
   // keys for dd_cov_data->klasses_table are not moved by GC, so we don't need
   // to update them
 }
@@ -115,12 +157,21 @@ static VALUE dd_cov_allocate(VALUE klass) {
   dd_cov_data->root_len = 0;
   dd_cov_data->ignored_path = NULL;
   dd_cov_data->ignored_path_len = 0;
-  dd_cov_data->last_filename_ptr = 0;
+  dd_cov_data->last_filename = Qnil;
+  for (size_t i = 0; i < SEEN_FILENAME_CACHE_SIZE; i++) {
+    dd_cov_data->seen_filenames[i] = Qnil;
+  }
   dd_cov_data->threading_mode = multi;
 
-  dd_cov_data->object_allocation_tracepoint = Qnil;
+  dd_cov_data->allocation_tracing_enabled = false;
+  dd_cov_data->allocation_hook_active = false;
+  dd_cov_data->last_allocated_klass = Qnil;
+  memset(dd_cov_data->seen_allocated_klasses, 0,
+         sizeof(dd_cov_data->seen_allocated_klasses));
   // numtable type is needed to store VALUE as a key
   dd_cov_data->klasses_table = st_init_numtable();
+  dd_cov_data->klass_files_cache = st_init_numtable();
+  dd_cov_data->klass_files_cache_size = 0;
 
   return dd_cov;
 }
@@ -131,8 +182,9 @@ static VALUE dd_cov_allocate(VALUE klass) {
 // not in the ignored folder) and adds it to the impacted_files hash.
 static bool record_impacted_file(struct dd_cov_data *dd_cov_data,
                                  VALUE filename) {
-  if (!dd_ci_is_path_included(RSTRING_PTR(filename), dd_cov_data->root,
-                              dd_cov_data->root_len, dd_cov_data->ignored_path,
+  if (!dd_ci_is_path_included(RSTRING_PTR(filename), RSTRING_LEN(filename),
+                              dd_cov_data->root, dd_cov_data->root_len,
+                              dd_cov_data->ignored_path,
                               dd_cov_data->ignored_path_len)) {
     return false;
   }
@@ -145,18 +197,29 @@ static bool record_impacted_file(struct dd_cov_data *dd_cov_data,
 // rb_profile_frames.
 static void on_line_event(rb_event_flag_t event, VALUE data, VALUE self, ID id,
                           VALUE klass) {
-  struct dd_cov_data *dd_cov_data;
-  TypedData_Get_Struct(data, struct dd_cov_data, &dd_cov_data_type,
-                       dd_cov_data);
+  // The hook is registered only with DDCov instances, so the full typed-data
+  // type check on every Ruby line is unnecessary.
+  struct dd_cov_data *dd_cov_data = RTYPEDDATA_DATA(data);
 
   const char *c_filename = rb_sourcefile();
+  if (c_filename == NULL) {
+    return;
+  }
 
-  // skip if we cover the same file again
   uintptr_t current_filename_ptr = (uintptr_t)c_filename;
-  if (dd_cov_data->last_filename_ptr == current_filename_ptr) {
+  if (dd_cov_data->last_filename != Qnil &&
+      RSTRING_PTR(dd_cov_data->last_filename) == c_filename) {
+    return;
+  }
+
+  size_t cache_index =
+      ((current_filename_ptr >> 4) ^ (current_filename_ptr >> 12)) &
+      (SEEN_FILENAME_CACHE_SIZE - 1);
+  VALUE cached_filename = dd_cov_data->seen_filenames[cache_index];
+  if (cached_filename != Qnil && RSTRING_PTR(cached_filename) == c_filename) {
+    dd_cov_data->last_filename = cached_filename;
     return;
   }
-  dd_cov_data->last_filename_ptr = current_filename_ptr;
 
   VALUE top_frame;
   int captured_frames =
@@ -172,6 +235,8 @@ static void on_line_event(rb_event_flag_t event, VALUE data, VALUE self, ID id,
     return;
   }
 
+  dd_cov_data->last_filename = filename;
+  dd_cov_data->seen_filenames[cache_index] = filename;
   record_impacted_file(dd_cov_data, filename);
 }
 
@@ -185,21 +250,6 @@ static VALUE safely_get_mod_ancestors(VALUE klass) {
   return dd_ci_rescue_nil(rb_mod_ancestors, klass);
 }
 
-static bool record_impacted_klass(struct dd_cov_data *dd_cov_data,
-                                  VALUE klass) {
-  VALUE klass_name = safely_get_class_name(klass);
-  if (klass_name == Qnil) {
-    return false;
-  }
-
-  VALUE filename = dd_ci_resolve_const_to_file(klass_name);
-  if (filename == Qnil) {
-    return false;
-  }
-
-  return record_impacted_file(dd_cov_data, filename);
-}
-
 // This function is called for each class that was instantiated during the test
 // run.
 static int each_instantiated_klass(st_data_t key, st_data_t _value,
@@ -207,6 +257,18 @@ static int each_instantiated_klass(st_data_t key, st_data_t _value,
   VALUE klass = (VALUE)key;
   struct dd_cov_data *dd_cov_data = (struct dd_cov_data *)data;
 
+  st_data_t cached_files;
+  if (st_lookup(dd_cov_data->klass_files_cache, key, &cached_files)) {
+    VALUE files = (VALUE)cached_files;
+    long files_len = RARRAY_LEN(files);
+    for (long i = 0; i < files_len; i++) {
+      rb_hash_aset(dd_cov_data->impacted_files, rb_ary_entry(files, i), Qtrue);
+    }
+    return ST_CONTINUE;
+  }
+
+  VALUE files = rb_ary_new();
+
   // rb_mod_ancestors returns an array containing the "klass" itself
   // and all the parent classes and/or included/prepended modules
   VALUE ancestors = safely_get_mod_ancestors(klass);
@@ -221,17 +283,36 @@ static int each_instantiated_klass(st_data_t key, st_data_t _value,
       continue;
     }
 
-    record_impacted_klass(dd_cov_data, mod);
+    VALUE klass_name = safely_get_class_name(mod);
+    if (klass_name == Qnil) {
+      continue;
+    }
+
+    VALUE filename = dd_ci_resolve_const_to_file(klass_name);
+    if (filename == Qnil || !record_impacted_file(dd_cov_data, filename)) {
+      continue;
+    }
+
+    rb_ary_push(files, filename);
   }
 
+  rb_obj_freeze(files);
+  // Bound cross-test retention without adding eviction work to cache hits.
+  // Reaching the limit starts a fresh cache generation.
+  if (dd_cov_data->klass_files_cache_size >= KLASS_FILES_CACHE_SIZE) {
+    st_clear(dd_cov_data->klass_files_cache);
+    dd_cov_data->klass_files_cache_size = 0;
+  }
+  st_insert(dd_cov_data->klass_files_cache, key, (st_data_t)files);
+  dd_cov_data->klass_files_cache_size++;
+
   return ST_CONTINUE;
 }
 
 // Executed on RUBY_INTERNAL_EVENT_NEWOBJ event and captures the source file for
 // the allocated object's class.
-static void on_newobj_event(VALUE tracepoint_data, void *data) {
-  rb_trace_arg_t *tracearg = rb_tracearg_from_tracepoint(tracepoint_data);
-  VALUE new_object = rb_tracearg_object(tracearg);
+static void on_newobj_event(VALUE self, const rb_trace_arg_t *tracearg) {
+  VALUE new_object = rb_tracearg_object((rb_trace_arg_t *)tracearg);
 
   // To keep things fast and practical, we only care about objects that extend
   // either Object or Struct.
@@ -244,20 +325,41 @@ static void on_newobj_event(VALUE tracepoint_data, void *data) {
   if (klass == Qnil || klass == 0) {
     return;
   }
-  // Skip anonymous classes starting with "#<Class".
-  // it allows us to skip the source location lookup that will always fail
-  //
-  // rb_mod_name returns nil for anonymous classes
-  if (rb_mod_name(klass) == Qnil) {
+
+  struct dd_cov_data *dd_cov_data = RTYPEDDATA_DATA(self);
+
+  if (dd_cov_data->last_allocated_klass == klass) {
     return;
   }
 
-  struct dd_cov_data *dd_cov_data = (struct dd_cov_data *)data;
+  uintptr_t klass_ptr = (uintptr_t)klass;
+  size_t cache_index =
+      ((klass_ptr >> 4) ^ (klass_ptr >> 12)) &
+      (SEEN_ALLOCATED_CLASS_CACHE_SIZE - 1);
+  if (dd_cov_data->seen_allocated_klasses[cache_index] == klass) {
+    dd_cov_data->last_allocated_klass = klass;
+    return;
+  }
+
+  // A direct-cache collision must not make us repeat name resolution or table
+  // insertion for a class that this test already observed.
+  if (st_is_member(dd_cov_data->klasses_table, (st_data_t)klass)) {
+    dd_cov_data->last_allocated_klass = klass;
+    dd_cov_data->seen_allocated_klasses[cache_index] = klass;
+    return;
+  }
+
+  // rb_mod_name returns nil for anonymous classes and is safe during NEWOBJ.
+  if (rb_mod_name(klass) == Qnil) {
+    return;
+  }
 
   // We use VALUE directly as a key for the hashmap
   // Ruby itself does it too:
   // https://github.com/ruby/ruby/blob/94b87084a689a3bc732dcaee744508a708223d6c/ext/objspace/object_tracing.c#L113
   st_insert(dd_cov_data->klasses_table, (st_data_t)klass, 1);
+  dd_cov_data->last_allocated_klass = klass;
+  dd_cov_data->seen_allocated_klasses[cache_index] = klass;
 }
 
 // DDCov instance methods available in Ruby
@@ -265,12 +367,22 @@ static VALUE dd_cov_initialize(int argc, VALUE *argv, VALUE self) {
   VALUE opt;
 
   rb_scan_args(argc, argv, "10", &opt);
+  Check_Type(opt, T_HASH);
+
   VALUE rb_root = rb_hash_lookup(opt, ID2SYM(rb_intern("root")));
   if (!RTEST(rb_root)) {
     rb_raise(rb_eArgError, "root is required");
   }
+  Check_Type(rb_root, T_STRING);
+  const char *root = StringValueCStr(rb_root);
+
   VALUE rb_ignored_path =
       rb_hash_lookup(opt, ID2SYM(rb_intern("ignored_path")));
+  const char *ignored_path = NULL;
+  if (RTEST(rb_ignored_path)) {
+    Check_Type(rb_ignored_path, T_STRING);
+    ignored_path = StringValueCStr(rb_ignored_path);
+  }
 
   VALUE rb_threading_mode =
       rb_hash_lookup(opt, ID2SYM(rb_intern("threading_mode")));
@@ -296,18 +408,16 @@ static VALUE dd_cov_initialize(int argc, VALUE *argv, VALUE self) {
 
   dd_cov_data->threading_mode = threading_mode;
   dd_cov_data->root_len = RSTRING_LEN(rb_root);
-  dd_cov_data->root =
-      dd_ci_ruby_strndup(RSTRING_PTR(rb_root), dd_cov_data->root_len);
+  dd_cov_data->root = dd_ci_ruby_strndup(root, dd_cov_data->root_len);
 
   if (RTEST(rb_ignored_path)) {
     dd_cov_data->ignored_path_len = RSTRING_LEN(rb_ignored_path);
     dd_cov_data->ignored_path = dd_ci_ruby_strndup(
-        RSTRING_PTR(rb_ignored_path), dd_cov_data->ignored_path_len);
+        ignored_path, dd_cov_data->ignored_path_len);
   }
 
   if (rb_allocation_tracing_enabled == Qtrue) {
-    dd_cov_data->object_allocation_tracepoint = rb_tracepoint_new(
-        Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, on_newobj_event, (void *)dd_cov_data);
+    dd_cov_data->allocation_tracing_enabled = true;
   }
 
   return Qnil;
@@ -332,9 +442,18 @@ static VALUE dd_cov_start(VALUE self) {
     rb_add_event_hook(on_line_event, RUBY_EVENT_LINE, self);
   }
 
-  // add object allocation tracepoint
-  if (dd_cov_data->object_allocation_tracepoint != Qnil) {
-    rb_tracepoint_enable(dd_cov_data->object_allocation_tracepoint);
+  // Register the raw hook that TracePoint would wrap and dispatch directly to
+  // the allocation callback. NEWOBJ permits no general Ruby API; the callback
+  // is limited to the existing event-safe accessors plus rb_mod_name, which is
+  // explicitly safe here. Each collector owns its hook, preserving concurrent
+  // collector behavior.
+  if (dd_cov_data->allocation_tracing_enabled &&
+      !dd_cov_data->allocation_hook_active) {
+    rb_add_event_hook2((rb_event_hook_func_t)on_newobj_event,
+                       RUBY_INTERNAL_EVENT_NEWOBJ, self,
+                       RUBY_EVENT_HOOK_FLAG_SAFE |
+                           RUBY_EVENT_HOOK_FLAG_RAW_ARG);
+    dd_cov_data->allocation_hook_active = true;
   }
 
   return self;
@@ -360,20 +479,28 @@ static VALUE dd_cov_stop(VALUE self) {
     rb_remove_event_hook(on_line_event);
   }
 
-  // stop object allocation tracepoint
-  if (dd_cov_data->object_allocation_tracepoint != Qnil) {
-    rb_tracepoint_disable(dd_cov_data->object_allocation_tracepoint);
+  // Remove only this collector's hook; other concurrently active collectors
+  // continue to receive allocation events.
+  if (dd_cov_data->allocation_hook_active) {
+    rb_remove_event_hook_with_data((rb_event_hook_func_t)on_newobj_event, self);
+    dd_cov_data->allocation_hook_active = false;
   }
 
   // process classes covered by allocation tracing
   st_foreach(dd_cov_data->klasses_table, each_instantiated_klass,
              (st_data_t)dd_cov_data);
+  dd_cov_data->last_allocated_klass = Qnil;
+  memset(dd_cov_data->seen_allocated_klasses, 0,
+         sizeof(dd_cov_data->seen_allocated_klasses));
   st_clear(dd_cov_data->klasses_table);
 
   VALUE res = dd_cov_data->impacted_files;
 
   dd_cov_data->impacted_files = rb_hash_new();
-  dd_cov_data->last_filename_ptr = 0;
+  dd_cov_data->last_filename = Qnil;
+  for (size_t i = 0; i < SEEN_FILENAME_CACHE_SIZE; i++) {
+    dd_cov_data->seen_filenames[i] = Qnil;
+  }
 
   return res;
 }