datadog 2.21.0 → 2.38.0

data/ext/datadog_profiling_native_extension/heap_recorder.h

@@ -105,7 +105,9 @@ void heap_recorder_after_fork(heap_recorder *heap_recorder);
 //   The sampling weight of this object.
 //
 // WARN: It needs to be paired with a ::end_heap_allocation_recording call.
-void start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj, unsigned int weight, ddog_CharSlice alloc_class);
+// 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.
 //
@@ -123,6 +125,15 @@ int end_heap_allocation_recording_with_rb_protect(heap_recorder *heap_recorder,
 // 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.
+// 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);
+
+// 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);
+
 // Update the heap recorder to reflect the latest state of the VM and prepare internal structures
 // for efficient iteration.
 //

data/ext/datadog_profiling_native_extension/http_transport.c

@@ -16,7 +16,11 @@ static VALUE library_version_string = Qnil;
 
 typedef struct {
   ddog_prof_ProfileExporter *exporter;
-  ddog_prof_Request_Result *build_result;
+  ddog_prof_EncodedProfile *profile;
+  ddog_prof_Exporter_Slice_File files_to_compress_and_export;
+  ddog_CharSlice internal_metadata;
+  ddog_CharSlice info;
+  ddog_CharSlice *process_tags;
   ddog_CancellationToken *cancel_token;
   ddog_prof_Result_HttpStatus result;
   bool send_ran;
@@ -29,7 +33,6 @@ static VALUE handle_exporter_failure(ddog_prof_ProfileExporter_Result exporter_r
 static VALUE _native_do_export(
   VALUE self,
   VALUE exporter_configuration,
-  VALUE upload_timeout_milliseconds,
   VALUE flush
 );
 static void *call_exporter_without_gvl(void *call_args);
@@ -39,7 +42,7 @@ void http_transport_init(VALUE profiling_module) {
   VALUE http_transport_class = rb_define_class_under(profiling_module, "HttpTransport", rb_cObject);
 
   rb_define_singleton_method(http_transport_class, "_native_validate_exporter",  _native_validate_exporter, 1);
-  rb_define_singleton_method(http_transport_class, "_native_do_export",  _native_do_export, 3);
+  rb_define_singleton_method(http_transport_class, "_native_do_export",  _native_do_export, 2);
 
   ok_symbol = ID2SYM(rb_intern_const("ok"));
   error_symbol = ID2SYM(rb_intern_const("error"));
@@ -75,17 +78,33 @@ static ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration) {
   ENFORCE_TYPE(exporter_working_mode, T_SYMBOL);
   ID working_mode = SYM2ID(exporter_working_mode);
 
-  if (working_mode == rb_intern("agentless")) {
-    VALUE site = rb_ary_entry(exporter_configuration, 1);
-    VALUE api_key = rb_ary_entry(exporter_configuration, 2);
+  VALUE timeout_milliseconds_value = rb_ary_entry(exporter_configuration, 1);
+  ENFORCE_TYPE(timeout_milliseconds_value, T_FIXNUM);
+  uint64_t timeout_milliseconds = NUM2ULONG(timeout_milliseconds_value);
+
+  VALUE use_system_dns = rb_ary_entry(exporter_configuration, 2);
+  ENFORCE_BOOLEAN(use_system_dns);
 
-    return ddog_prof_Endpoint_agentless(char_slice_from_ruby_string(site), char_slice_from_ruby_string(api_key));
+  if (working_mode == rb_intern("agentless")) {
+    VALUE site = rb_ary_entry(exporter_configuration, 3);
+    VALUE api_key = rb_ary_entry(exporter_configuration, 4);
+
+    return ddog_prof_Endpoint_agentless(
+      char_slice_from_ruby_string(site),
+      char_slice_from_ruby_string(api_key),
+      timeout_milliseconds,
+      use_system_dns == Qtrue
+    );
   } else if (working_mode == rb_intern("agent")) {
-    VALUE base_url = rb_ary_entry(exporter_configuration, 1);
+    VALUE base_url = rb_ary_entry(exporter_configuration, 3);
 
-    return ddog_prof_Endpoint_agent(char_slice_from_ruby_string(base_url));
+    return ddog_prof_Endpoint_agent(
+      char_slice_from_ruby_string(base_url),
+      timeout_milliseconds,
+      use_system_dns == Qtrue
+    );
   } else {
-    rb_raise(rb_eArgError, "Failed to initialize transport: Unexpected working mode, expected :agentless or :agent");
+    raise_error(rb_eArgError, "Failed to initialize transport: Unexpected working mode, expected :agentless or :agent");
   }
 }
 
@@ -112,7 +131,7 @@ static ddog_prof_ProfileExporter_Result create_exporter(VALUE exporter_configura
 }
 
 static void validate_token(ddog_CancellationToken token, const char *file, int line) {
-  if (token.inner == NULL) rb_raise(rb_eRuntimeError, "Unexpected: Validation token was empty at %s:%d", file, line);
+  if (token.inner == NULL) raise_error(rb_eRuntimeError, "Unexpected: Validation token was empty at %s:%d", file, line);
 }
 
 static VALUE handle_exporter_failure(ddog_prof_ProfileExporter_Result exporter_result) {
@@ -123,39 +142,18 @@ static VALUE handle_exporter_failure(ddog_prof_ProfileExporter_Result exporter_r
 
 // Note: This function handles a bunch of libdatadog dynamically-allocated objects, so it MUST not use any Ruby APIs
 // which can raise exceptions, otherwise the objects will be leaked.
-static VALUE perform_export(
-  ddog_prof_ProfileExporter *exporter,
-  ddog_prof_EncodedProfile *profile,
-  ddog_prof_Exporter_Slice_File files_to_compress_and_export,
-  ddog_CharSlice internal_metadata,
-  ddog_CharSlice info
-) {
-  ddog_prof_Request_Result build_result = ddog_prof_Exporter_Request_build(
-    exporter,
-    profile,
-    files_to_compress_and_export,
-    /* files_to_export_unmodified: */ ddog_prof_Exporter_Slice_File_empty(),
-    /* optional_additional_tags: */ NULL,
-    &internal_metadata,
-    &info
-  );
-
-  if (build_result.tag == DDOG_PROF_REQUEST_RESULT_ERR_HANDLE_REQUEST) {
-    ddog_prof_Exporter_drop(exporter);
-    return rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&build_result.err));
-  }
-
+static VALUE perform_export(call_exporter_without_gvl_arguments args) {
   ddog_CancellationToken cancel_token_request = ddog_CancellationToken_new();
   ddog_CancellationToken cancel_token_interrupt = ddog_CancellationToken_clone(&cancel_token_request);
 
   validate_token(cancel_token_request, __FILE__, __LINE__);
   validate_token(cancel_token_interrupt, __FILE__, __LINE__);
 
+  args.cancel_token = &cancel_token_request;
+  args.send_ran = false;
+
   // We'll release the Global VM Lock while we're calling send, so that the Ruby VM can continue to work while this
   // is pending
-  call_exporter_without_gvl_arguments args =
-    {.exporter = exporter, .build_result = &build_result, .cancel_token = &cancel_token_request, .send_ran = false};
-
   // We use rb_thread_call_without_gvl2 instead of rb_thread_call_without_gvl as the gvl2 variant never raises any
   // exceptions.
   //
@@ -180,18 +178,13 @@ static VALUE perform_export(
   // Cleanup exporter and token, no longer needed
   ddog_CancellationToken_drop(&cancel_token_request);
   ddog_CancellationToken_drop(&cancel_token_interrupt);
-  ddog_prof_Exporter_drop(exporter);
+  ddog_prof_Exporter_drop(args.exporter);
 
   if (pending_exception) {
-    // If we got here send did not run, so we need to explicitly dispose of the request
-    ddog_prof_Exporter_Request_drop(&build_result.ok);
-
     // Let Ruby propagate the exception. This will not return.
     rb_jump_tag(pending_exception);
   }
 
-  // The request itself does not need to be freed as libdatadog takes ownership of it as part of sending.
-
   ddog_prof_Result_HttpStatus result = args.result;
 
   return result.tag == DDOG_PROF_RESULT_HTTP_STATUS_OK_HTTP_STATUS ?
@@ -202,42 +195,46 @@ static VALUE perform_export(
 static VALUE _native_do_export(
   DDTRACE_UNUSED VALUE _self,
   VALUE exporter_configuration,
-  VALUE upload_timeout_milliseconds,
   VALUE flush
 ) {
   VALUE encoded_profile = rb_funcall(flush, rb_intern("encoded_profile"), 0);
-  VALUE code_provenance_file_name = rb_funcall(flush, rb_intern("code_provenance_file_name"), 0);
   VALUE code_provenance_data = rb_funcall(flush, rb_intern("code_provenance_data"), 0);
+  VALUE metrics_json = rb_funcall(flush, rb_intern("metrics"), 0);
   VALUE tags_as_array = rb_funcall(flush, rb_intern("tags_as_array"), 0);
   VALUE internal_metadata_json = rb_funcall(flush, rb_intern("internal_metadata_json"), 0);
   VALUE info_json = rb_funcall(flush, rb_intern("info_json"), 0);
+  VALUE process_tags = rb_funcall(flush, rb_intern("process_tags"), 0);
 
-  ENFORCE_TYPE(upload_timeout_milliseconds, T_FIXNUM);
   enforce_encoded_profile_instance(encoded_profile);
-  ENFORCE_TYPE(code_provenance_file_name, T_STRING);
+  ENFORCE_TYPE(metrics_json, T_STRING);
   ENFORCE_TYPE(tags_as_array, T_ARRAY);
   ENFORCE_TYPE(internal_metadata_json, T_STRING);
   ENFORCE_TYPE(info_json, T_STRING);
+  ENFORCE_TYPE(process_tags, T_STRING);
 
   // Code provenance can be disabled and in that case will be set to nil
   bool have_code_provenance = !NIL_P(code_provenance_data);
   if (have_code_provenance) ENFORCE_TYPE(code_provenance_data, T_STRING);
 
-  uint64_t timeout_milliseconds = NUM2ULONG(upload_timeout_milliseconds);
-
-  int to_compress_length = have_code_provenance ? 1 : 0;
+  int to_compress_length = 1 + (have_code_provenance ? 1 : 0);
   ddog_prof_Exporter_File to_compress[to_compress_length];
   ddog_prof_Exporter_Slice_File files_to_compress_and_export = {.ptr = to_compress, .len = to_compress_length};
 
+  to_compress[0] = (ddog_prof_Exporter_File) {
+    .name = DDOG_CHARSLICE_C("metrics.json"),
+    .file = byte_slice_from_ruby_string(metrics_json),
+  };
+
   if (have_code_provenance) {
-    to_compress[0] = (ddog_prof_Exporter_File) {
-      .name = char_slice_from_ruby_string(code_provenance_file_name),
+    to_compress[1] = (ddog_prof_Exporter_File) {
+      .name = DDOG_CHARSLICE_C("code-provenance.json"),
       .file = byte_slice_from_ruby_string(code_provenance_data),
     };
   }
 
   ddog_CharSlice internal_metadata = char_slice_from_ruby_string(internal_metadata_json);
   ddog_CharSlice info = char_slice_from_ruby_string(info_json);
+  ddog_CharSlice process_tags_slice = char_slice_from_ruby_string(process_tags);
 
   ddog_prof_ProfileExporter_Result exporter_result = create_exporter(exporter_configuration, tags_as_array);
   // Note: Do not add anything that can raise exceptions after this line, as otherwise the exporter memory will leak
@@ -245,28 +242,29 @@ static VALUE _native_do_export(
   VALUE failure_tuple = handle_exporter_failure(exporter_result);
   if (!NIL_P(failure_tuple)) return failure_tuple;
 
-  ddog_VoidResult timeout_result = ddog_prof_Exporter_set_timeout(&exporter_result.ok, timeout_milliseconds);
-  if (timeout_result.tag == DDOG_VOID_RESULT_ERR) {
-    // NOTE: Seems a bit harsh to fail the upload if we can't set a timeout. OTOH, this is only expected to fail
-    // if the exporter is not well built. Because such a situation should already be caught above I think it's
-    // preferable to leave this here as a virtually unreachable exception rather than ignoring it.
-    ddog_prof_Exporter_drop(&exporter_result.ok);
-    return rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&timeout_result.err));
-  }
-
-  return perform_export(
-    &exporter_result.ok,
-    to_ddog_prof_EncodedProfile(encoded_profile),
-    files_to_compress_and_export,
-    internal_metadata,
-    info
-  );
+  return perform_export((call_exporter_without_gvl_arguments) {
+    .exporter = &exporter_result.ok,
+    .profile = to_ddog_prof_EncodedProfile(encoded_profile),
+    .files_to_compress_and_export = files_to_compress_and_export,
+    .internal_metadata = internal_metadata,
+    .info = info,
+    .process_tags = &process_tags_slice
+  });
 }
 
 static void *call_exporter_without_gvl(void *call_args) {
   call_exporter_without_gvl_arguments *args = (call_exporter_without_gvl_arguments*) call_args;
 
-  args->result = ddog_prof_Exporter_send(args->exporter, &args->build_result->ok, args->cancel_token);
+  args->result = ddog_prof_Exporter_send_blocking(
+    args->exporter,
+    args->profile,
+    args->files_to_compress_and_export,
+    /* optional_additional_tags: */ NULL,
+    /* optional_process_tags: */ args->process_tags,
+    &args->internal_metadata,
+    &args->info,
+    args->cancel_token
+  );
   args->send_ran = true;
 
   return NULL; // Unused

data/ext/datadog_profiling_native_extension/libdatadog_helpers.c

@@ -1,6 +1,7 @@
 #include "libdatadog_helpers.h"
 
 #include <ruby.h>
+#include "ruby_helpers.h"
 
 const char *ruby_value_type_to_string(enum ruby_value_type type) {
   return ruby_value_type_to_char_slice(type).ptr;
@@ -41,32 +42,12 @@ ddog_CharSlice ruby_value_type_to_char_slice(enum ruby_value_type type) {
   }
 }
 
-size_t read_ddogerr_string_and_drop(ddog_Error *error, char *string, size_t capacity) {
-  if (capacity == 0 || string == NULL) {
-    // short-circuit, we can't write anything
-    ddog_Error_drop(error);
-    return 0;
-  }
-
-  ddog_CharSlice error_msg_slice = ddog_Error_message(error);
-  size_t error_msg_size = error_msg_slice.len;
-  // Account for extra null char for proper cstring
-  if (error_msg_size >= capacity) {
-    // Error message too big, lets truncate it to capacity - 1 to allow for extra null at end
-    error_msg_size = capacity - 1;
-  }
-  strncpy(string, error_msg_slice.ptr, error_msg_size);
-  string[error_msg_size] = '\0';
-  ddog_Error_drop(error);
-  return error_msg_size;
-}
-
 ddog_prof_ManagedStringId intern_or_raise(ddog_prof_ManagedStringStorage string_storage, ddog_CharSlice string) {
   if (string.len == 0) return (ddog_prof_ManagedStringId) { 0 }; // Id 0 is always an empty string, no need to ask
 
   ddog_prof_ManagedStringStorageInternResult intern_result = ddog_prof_ManagedStringStorage_intern(string_storage, string);
   if (intern_result.tag == DDOG_PROF_MANAGED_STRING_STORAGE_INTERN_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to intern string: %"PRIsVALUE, get_error_details_and_drop(&intern_result.err));
+    raise_error(rb_eRuntimeError, "Failed to intern string: %"PRIsVALUE, get_error_details_and_drop(&intern_result.err));
   }
   return intern_result.ok;
 }
@@ -79,6 +60,6 @@ void intern_all_or_raise(
 ) {
   ddog_prof_MaybeError result = ddog_prof_ManagedStringStorage_intern_all(string_storage, strings, output_ids, output_ids_size);
   if (result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
-    rb_raise(rb_eRuntimeError, "Failed to intern_all: %"PRIsVALUE, get_error_details_and_drop(&result.some));
+    raise_error(rb_eRuntimeError, "Failed to intern_all: %"PRIsVALUE, get_error_details_and_drop(&result.some));
   }
 }

data/ext/datadog_profiling_native_extension/libdatadog_helpers.h

@@ -7,11 +7,6 @@ static inline VALUE ruby_string_from_vec_u8(ddog_Vec_U8 string) {
   return rb_str_new((char *) string.ptr, string.len);
 }
 
-// Utility function to be able to extract an error cstring from a ddog_Error.
-// Returns the amount of characters written to string (which are necessarily
-// bounded by capacity - 1 since the string will be null-terminated).
-size_t read_ddogerr_string_and_drop(ddog_Error *error, char *string, size_t capacity);
-
 // Used for pretty printing this Ruby enum. Returns "T_UNKNOWN_OR_MISSING_RUBY_VALUE_TYPE_ENTRY" for unknown elements.
 // In practice, there's a few types that the profiler will probably never encounter, but I've added all entries of
 // ruby_value_type that Ruby uses so that we can also use this for debugging.

data/ext/datadog_profiling_native_extension/macos_sampler_thread.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+#include <mach/thread_policy.h>
+#include <pthread.h>
+#include <stdio.h>
+
+#include "time_helpers.h"
+
+// On macOS the default scheduler wake latency for a timeshare thread is ~1-2ms,
+// so nanosleep regularly overshoots a 10ms request by ~2ms. Marking the worker
+// thread with THREAD_TIME_CONSTRAINT_POLICY tells the scheduler this thread has
+// a periodic deadline; the kernel then wakes it close to the requested time.
+//
+// This only affects the sampler worker thread. We pair it with a demote call
+// before the thread can be reused by Ruby for unrelated Ruby threads (see the
+// SIGPROF unblock dance in _native_sampling_loop).
+static inline void promote_sampler_thread_to_realtime(uint64_t period_ns) {
+  mach_timebase_info_data_t timebase = (mach_timebase_info_data_t) {};
+  mach_timebase_info(&timebase);
+
+  // ns -> mach ticks: each mach tick is (numer/denom) ns, so divide by that.
+  #define NS_TO_MACH_TICKS(ns) ((uint32_t) (((uint64_t)(ns) * (uint64_t) timebase.denom) / (uint64_t) timebase.numer))
+
+  struct thread_time_constraint_policy policy = {
+    .period      = NS_TO_MACH_TICKS(period_ns),
+    .computation = NS_TO_MACH_TICKS(MICROS_AS_NS(200)),  // 200us upper bound on the work we do per period
+    .constraint  = NS_TO_MACH_TICKS(MILLIS_AS_NS(1)),    // wake us within 1ms of the deadline
+    .preemptible = TRUE,
+  };
+
+  #undef NS_TO_MACH_TICKS
+
+  kern_return_t kr = thread_policy_set(
+    pthread_mach_thread_np(pthread_self()),
+    THREAD_TIME_CONSTRAINT_POLICY,
+    (thread_policy_t) &policy,
+    THREAD_TIME_CONSTRAINT_POLICY_COUNT
+  );
+  if (kr != KERN_SUCCESS) {
+    // Non-fatal: we'll fall back to the default scheduler behavior (overshoot ~2ms).
+    fprintf(stderr, "[ddtrace] Failed to set real-time policy on profiler sampler thread (kr=%d); sample cadence may be imprecise\n", kr);
+  }
+}
+
+static inline void demote_sampler_thread_from_realtime(void) {
+  struct thread_standard_policy policy = {.no_data = 0};
+  thread_policy_set(
+    pthread_mach_thread_np(pthread_self()),
+    THREAD_STANDARD_POLICY,
+    (thread_policy_t) &policy,
+    THREAD_STANDARD_POLICY_COUNT
+  );
+}

data/ext/datadog_profiling_native_extension/native_extension_helpers.rb

@@ -104,19 +104,6 @@ module Datadog
           suggested: CONTACT_SUPPORT,
         )
 
-        # Validation for this check is done in extconf.rb because it relies on mkmf
-        PKG_CONFIG_IS_MISSING = explain_issue(
-          # ----------------------------------------------------------------------------+
-          "the `pkg-config` system tool is missing.",
-          "This issue can usually be fixed by installing one of the following:",
-          "the `pkg-config` package on Homebrew and Debian/Ubuntu-based Linux;",
-          "the `pkgconf` package on Arch and Alpine-based Linux;",
-          "the `pkgconf-pkg-config` package on Fedora/Red Hat-based Linux.",
-          "(Tip: When fixing this, ensure `pkg-config` is installed **before**",
-          "running `bundle install`, and remember to clear any installed gems cache).",
-          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.",

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -76,6 +76,18 @@ rb_nativethread_id_t pthread_id_for(VALUE thread) {
   #endif
 }
 
+size_t sizeof_rb_iseq_t(void) {
+  return sizeof(rb_iseq_t);
+}
+
+VALUE ddtrace_iseq_base_label(const void *iseq) {
+  return rb_iseq_base_label((const rb_iseq_t *)iseq);
+}
+
+VALUE ddtrace_iseq_path(const void *iseq) {
+  return rb_iseq_path((const rb_iseq_t *)iseq);
+}
+
 // Queries if the current thread is the owner of the global VM lock.
 //
 // @ivoanjo: Ruby has a similarly-named `ruby_thread_has_gvl_p` but that API is insufficient for our needs because it can
@@ -444,27 +456,28 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
     // here.
     if (ec == NULL) return 0;
 
+    // Avoid sampling dead threads
+    if (th->status == THREAD_KILLED) return 0;
+
+    const rb_control_frame_t *cfp = ec->cfp;
+
+    // This happens on newly-created threads (we even had a flaky test because of it)
+    if (cfp == NULL) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
+
     // I suspect this won't happen for ddtrace, but just-in-case we've imported a potential fix for
     // https://github.com/ruby/ruby/pull/13643 by assuming that these can be NULL/zero with the cfp being non-NULL yet.
     if (ec->vm_stack == NULL || ec->vm_stack_size == 0) return 0;
 
-    const rb_control_frame_t *cfp = ec->cfp, *end_cfp = RUBY_VM_END_CONTROL_FRAME(ec);
+    const rb_control_frame_t *end_cfp = RUBY_VM_END_CONTROL_FRAME(ec);
     #ifndef NO_JIT_RETURN
       const rb_control_frame_t *top = cfp;
     #endif
     const rb_callable_method_entry_t *cme;
 
-    // Avoid sampling dead threads
-    if (th->status == THREAD_KILLED) return 0;
-
     // `vm_backtrace.c` includes this check in several methods. This happens on newly-created threads, and may
     // also (not entirely sure) happen on dead threads
     if (end_cfp == NULL) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
 
-    // This should not happen for ddtrace (it can only happen when a thread is still being created), but I've imported
-    // it from https://github.com/ruby/ruby/pull/7116 in a "just in case" kind of mindset.
-    if (cfp == NULL) return 0;
-
     // Fix: Skip dummy frame that shows up in main thread.
     //
     // According to a comment in `backtrace_each` (`vm_backtrace.c`), there's two dummy frames that we should ignore
@@ -777,15 +790,11 @@ static inline int ddtrace_imemo_type(VALUE imemo) {
   }
 #endif
 
-#ifdef USE_GVL_PROFILING_3_2_WORKAROUNDS // Ruby 3.2
+#ifndef HAVE_RUBY_THREAD_STORAGE_API
   #include "gvl_profiling_helper.h"
 
-  gvl_profiling_thread thread_from_thread_object(VALUE thread) {
-    return (gvl_profiling_thread) {.thread = thread_struct_from_object(thread)};
-  }
-
   // Hack: In Ruby 3.3+ we attach gvl profiling state to Ruby threads using the
-  // rb_internal_thread_specific_* APIs. These APIs did not exist on Ruby 3.2. On Ruby 3.2 we instead store the
+  // rb_internal_thread_specific_* APIs. These APIs did not exist on Ruby <= 3.2. On Ruby <= 3.2 we instead store the
   // needed data inside the `rb_thread_t` structure, specifically in `stat_insn_usage` as a Ruby FIXNUM.
   //
   // Why `stat_insn_usage`? We needed some per-thread storage, and while looking at the Ruby VM sources I noticed
@@ -793,38 +802,21 @@ static inline int ddtrace_imemo_type(VALUE imemo) {
   // code. There's a comment attached to it "/* statistics data for profiler */" but other than marking this
   // field for GC, I could not find any place in the VM commit history or on GitHub where this has ever been used.
   //
-  // Thus, since this hack is only for 3.2, which presumably will never see this field either removed or used
-  // during its remaining maintenance release period we... kinda take it for our own usage. It's ugly, I know...
-  intptr_t gvl_profiling_state_get(gvl_profiling_thread thread) {
-    if (thread.thread == NULL) return 0;
-
-    VALUE current_value = ((rb_thread_t *)thread.thread)->stat_insn_usage;
-    intptr_t result = current_value == Qnil ? 0 : FIX2LONG(current_value);
-    return result;
-  }
-
-  void gvl_profiling_state_set(gvl_profiling_thread thread, intptr_t value) {
-    if (thread.thread == NULL) return;
-    ((rb_thread_t *)thread.thread)->stat_insn_usage = LONG2FIX(value);
+  // Thus, since this hack is only for Ruby <= 3.2, which presumably will never see this field either removed or used
+  // we... kinda take it for our own usage. It's ugly, I know...
+  //
+  // 64-bit pointers actually use 48-bit virtual addresses (https://muxup.com/2023q4/storing-data-in-pointers),
+  // so we are sure the addresses fit in Fixnums.
+  per_thread_context *get_per_thread_context(VALUE thread) {
+    VALUE current_value = thread_struct_from_object(thread)->stat_insn_usage;
+    return RB_FIXNUM_P(current_value) ? (per_thread_context *) FIX2LONG(current_value) : NULL;
   }
 
-  // Because Ruby 3.2 does not give us the current thread when calling the RUBY_INTERNAL_THREAD_EVENT_READY and
-  // RUBY_INTERNAL_THREAD_EVENT_RESUMED APIs, we need to figure out this info ourselves.
-  //
-  // Specifically, this method was created to be called from a RUBY_INTERNAL_THREAD_EVENT_RESUMED callback --
-  // when it's triggered, we know the thread the code gets executed on is holding the GVL, so we use this
-  // opportunity to initialize our thread-local value.
-  gvl_profiling_thread gvl_profiling_state_maybe_initialize(void) {
-    gvl_profiling_thread current_thread = gvl_waiting_tls;
-
-    if (current_thread.thread == NULL) {
-      // threads.sched.running is the thread currently holding the GVL, which when this gets executed is the
-      // current thread!
-      current_thread = (gvl_profiling_thread) {.thread = (void *) rb_current_ractor()->threads.sched.running};
-      gvl_waiting_tls = current_thread;
+  void set_per_thread_context(VALUE thread, per_thread_context *value) {
+    if (!RB_FIXABLE((intptr_t) value)) {
+      rb_bug("per_thread_context pointer does not fit in a Fixnum: %p", value);
     }
-
-    return current_thread;
+    thread_struct_from_object(thread)->stat_insn_usage = value ? LONG2FIX((intptr_t) value) : Qfalse;
   }
 #endif
 
@@ -879,3 +871,8 @@ bool is_raised_flag_set(VALUE thread) { return thread_struct_from_object(thread)
   VALUE current_fiber_for(DDTRACE_UNUSED VALUE thread) { rb_raise(rb_eRuntimeError, "Not implemented for Ruby < 3.1"); }
   void self_test_current_fiber_for(void) { } // Nothing to do
 #endif
+
+bool pathobj_is_null(VALUE iseq) {
+  const rb_iseq_t *iseq_ptr = (const rb_iseq_t *) iseq;
+  return ISEQ_BODY(iseq_ptr)->location.pathobj == 0;
+}

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -47,6 +47,10 @@ VALUE thread_name_for(VALUE thread);
 
 int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer);
 
+size_t sizeof_rb_iseq_t(void);
+VALUE ddtrace_iseq_base_label(const void *iseq);
+VALUE ddtrace_iseq_path(const void *iseq);
+
 // Returns true if the current thread belongs to the main Ractor or if Ruby has no Ractor support
 bool ddtrace_rb_ractor_main_p(void);
 
@@ -79,3 +83,5 @@ bool is_raised_flag_set(VALUE thread);
 VALUE current_fiber_for(VALUE thread);
 
 void self_test_current_fiber_for(void);
+
+bool pathobj_is_null(VALUE iseq);