datadog 2.28.0 → 2.30.0

data/ext/datadog_profiling_native_extension/heap_recorder.c

@@ -79,6 +79,16 @@ static void object_record_free(heap_recorder*, object_record*);
 static VALUE object_record_inspect(heap_recorder*, object_record*);
 static object_record SKIPPED_RECORD = {0};
 
+// A pending recording is used to defer the object_id call on Ruby 4+
+// where calling rb_obj_id during on_newobj_event is unsafe.
+typedef struct {
+  VALUE object_ref;
+  heap_record *heap_record;
+  live_object_data object_data;
+} pending_recording;
+
+#define MAX_PENDING_RECORDINGS 256
+
 struct heap_recorder {
   // Config
   // Whether the recorder should try to determine approximate sizes for tracked objects.
@@ -130,6 +140,15 @@ struct heap_recorder {
   // Data for a heap recording that was started but not yet ended
   object_record *active_recording;
 
+  // Pending recordings that need to be finalized after on_newobj_event completes.
+  // On Ruby 4+, we can't call rb_obj_id during the newobj event, so we store the
+  // VALUE reference here and finalize it via a postponed job.
+  pending_recording pending_recordings[MAX_PENDING_RECORDINGS];
+  // Temporary storage for the recording in progress, used between start and end
+  VALUE active_deferred_object;
+  live_object_data active_deferred_object_data;
+  uint16_t pending_recordings_count;
+
   // Reusable arrays, implementing a flyweight pattern for things like iteration
   #define REUSABLE_LOCATIONS_SIZE MAX_FRAMES_LIMIT
   ddog_prof_Location *reusable_locations;
@@ -163,6 +182,9 @@ struct heap_recorder {
     double ewma_objects_alive;
     double ewma_objects_dead;
     double ewma_objects_skipped;
+
+    unsigned long deferred_recordings_skipped_buffer_full;
+    unsigned long deferred_recordings_finalized;
   } stats_lifetime;
 };
 
@@ -180,6 +202,7 @@ static int st_object_record_update(st_data_t, st_data_t, st_data_t);
 static int st_object_records_iterate(st_data_t, st_data_t, st_data_t);
 static int st_object_records_debug(st_data_t key, st_data_t value, st_data_t extra);
 static int update_object_record_entry(st_data_t*, st_data_t*, st_data_t, int);
+static void inc_tracked_objects_or_fail(heap_record *heap_record);
 static void commit_recording(heap_recorder *, heap_record *, object_record *active_recording);
 static VALUE end_heap_allocation_recording(VALUE end_heap_allocation_args);
 static void heap_recorder_update(heap_recorder *heap_recorder, bool full_update);
@@ -187,6 +210,7 @@ static inline double ewma_stat(double previous, double current);
 static void unintern_or_raise(heap_recorder *, ddog_prof_ManagedStringId);
 static void unintern_all_or_raise(heap_recorder *recorder, ddog_prof_Slice_ManagedStringId ids);
 static VALUE get_ruby_string_or_raise(heap_recorder*, ddog_prof_ManagedStringId);
+static long obj_id_or_fail(VALUE obj);
 
 // ==========================
 // Heap Recorder External API
@@ -210,6 +234,7 @@ heap_recorder* heap_recorder_new(ddog_prof_ManagedStringStorage string_storage)
   recorder->size_enabled = true;
   recorder->sample_rate = 1; // By default do no sampling on top of what allocation profiling already does
   recorder->string_storage = string_storage;
+  recorder->active_deferred_object = Qnil;
 
   return recorder;
 }
@@ -294,9 +319,9 @@ void heap_recorder_after_fork(heap_recorder *heap_recorder) {
   heap_recorder->stats_lifetime = (struct stats_lifetime) {0};
 }
 
-void start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj, unsigned int weight, ddog_CharSlice alloc_class) {
+bool start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj, unsigned int weight, ddog_CharSlice alloc_class) {
   if (heap_recorder == NULL) {
-    return;
+    return false;
   }
 
   if (heap_recorder->active_recording != NULL) {
@@ -316,25 +341,49 @@ void start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj
       || heap_recorder->updating
     ) {
     heap_recorder->active_recording = &SKIPPED_RECORD;
-    return;
+    return false;
   }
 
-  heap_recorder->num_recordings_skipped = 0;
+  bool needs_after_allocation = false;
 
-  VALUE ruby_obj_id = rb_obj_id(new_obj);
-  if (!FIXNUM_P(ruby_obj_id)) {
-    raise_error(rb_eRuntimeError, "Detected a bignum object id. These are not supported by heap profiling.");
+  #ifdef USE_DEFERRED_HEAP_ALLOCATION_RECORDING
+  // Skip if we've hit the pending recordings limit or if there's already a deferred object being recorded
+  if (heap_recorder->pending_recordings_count >= MAX_PENDING_RECORDINGS) {
+    heap_recorder->stats_lifetime.deferred_recordings_skipped_buffer_full++;
+    heap_recorder->active_recording = &SKIPPED_RECORD;
+    return true; // If the buffer is full, we keep asking for a callback (see `needs_after_allocation` below)
+  } else {
+    // The intuition here is: We start by asking for an `after_allocation` callback when the buffer is about to go
+    // from empty -> non-empty, because this is going to be mapped onto a postponed job, so after it gets queued once
+    // it doesn't seem worth it to keep spamming requests.
+    //
+    // Yet, if for some reason the postponed job doesn't flush the pending list (or if e.g. it ran with `during_sample == true` and thus
+    // was skipped) we need to have some mechanism to recover -- and so if the buffer starts accumulating too much we
+    // start always requesting the callback to happen so that we eventually flush the buffer.
+    needs_after_allocation =
+      heap_recorder->pending_recordings_count == 0 || heap_recorder->pending_recordings_count >= (MAX_PENDING_RECORDINGS / 2);
   }
+  #endif
 
-  heap_recorder->active_recording = object_record_new(
-    FIX2LONG(ruby_obj_id),
-    NULL,
-    (live_object_data) {
-      .weight = weight * heap_recorder->sample_rate,
-      .class = intern_or_raise(heap_recorder->string_storage, alloc_class),
-      .alloc_gen = rb_gc_count(),
-    }
-  );
+  heap_recorder->num_recordings_skipped = 0;
+
+  live_object_data object_data = (live_object_data) {
+    .weight = weight * heap_recorder->sample_rate,
+    .class = intern_or_raise(heap_recorder->string_storage, alloc_class),
+    .alloc_gen = rb_gc_count(),
+  };
+
+  #ifdef USE_DEFERRED_HEAP_ALLOCATION_RECORDING
+    // On Ruby 4+, we can't call rb_obj_id during on_newobj_event as it mutates the object.
+    // Instead, we store the VALUE reference and will get the object_id later via a postponed job.
+    // active_deferred_object != Qnil indicates we're in deferred mode.
+    heap_recorder->active_deferred_object = new_obj;
+    heap_recorder->active_deferred_object_data = object_data;
+  #else
+    heap_recorder->active_recording = object_record_new(obj_id_or_fail(new_obj), NULL, object_data);
+  #endif
+
+  return needs_after_allocation;
 }
 
 // end_heap_allocation_recording_with_rb_protect gets called while the stack_recorder is holding one of the profile
@@ -351,7 +400,6 @@ int end_heap_allocation_recording_with_rb_protect(heap_recorder *heap_recorder,
     return 0;
   }
 
-
   int exception_state;
   end_heap_allocation_args args = {
     .heap_recorder = heap_recorder,
@@ -367,26 +415,48 @@ static VALUE end_heap_allocation_recording(VALUE protect_args) {
   heap_recorder *heap_recorder = args->heap_recorder;
   ddog_prof_Slice_Location locations = args->locations;
 
-  object_record *active_recording = heap_recorder->active_recording;
+  #ifdef USE_DEFERRED_HEAP_ALLOCATION_RECORDING
+    if (heap_recorder->active_deferred_object == Qnil) {
+      // Recording ended without having been started?
+      raise_error(rb_eRuntimeError, "Ended a heap recording that was not started");
+    }
+  #else
+    object_record *active_recording = heap_recorder->active_recording;
 
-  if (active_recording == NULL) {
-    // Recording ended without having been started?
-    raise_error(rb_eRuntimeError, "Ended a heap recording that was not started");
-  }
-  // From now on, mark the global active recording as invalid so we can short-circuit at any point
-  // and not end up with a still active recording. the local active_recording still holds the
-  // data required for committing though.
-  heap_recorder->active_recording = NULL;
+    if (active_recording == NULL) {
+      // Recording ended without having been started?
+      raise_error(rb_eRuntimeError, "Ended a heap recording that was not started");
+    }
+    // From now on, mark the global active recording as invalid so we can short-circuit at any point
+    // and not end up with a still active recording. the local active_recording still holds the
+    // data required for committing though.
+    heap_recorder->active_recording = NULL;
 
-  if (active_recording == &SKIPPED_RECORD) { // special marker when we decided to skip due to sampling
-    // Note: Remember to update the short circuit in end_heap_allocation_recording_with_rb_protect if this logic changes
-    return Qnil;
-  }
+    if (active_recording == &SKIPPED_RECORD) {
+      raise_error(
+        rb_eRuntimeError,
+        "BUG: end_heap_allocation_recording should never observe SKIPPED_RECORDING because " \
+        "end_heap_allocation_recording_with_rb_protect is supposed to test for it directly"
+      );
+    }
+  #endif
 
   heap_record *heap_record = get_or_create_heap_record(heap_recorder, locations);
-
-  // And then commit the new allocation.
-  commit_recording(heap_recorder, heap_record, active_recording);
+  inc_tracked_objects_or_fail(heap_record);
+
+  #ifdef USE_DEFERRED_HEAP_ALLOCATION_RECORDING
+    // Commit is delayed, so we need to record all we'll need for it
+    pending_recording *pending = &heap_recorder->pending_recordings[heap_recorder->pending_recordings_count++];
+    pending->object_ref = heap_recorder->active_deferred_object;
+    pending->heap_record = heap_record;
+    pending->object_data = heap_recorder->active_deferred_object_data;
+
+    heap_recorder->active_deferred_object = Qnil;
+    heap_recorder->active_deferred_object_data = (live_object_data) {0};
+  #else
+    // And then commit the new allocation
+    commit_recording(heap_recorder, heap_record, active_recording);
+  #endif
 
   return Qnil;
 }
@@ -399,6 +469,48 @@ void heap_recorder_update_young_objects(heap_recorder *heap_recorder) {
   heap_recorder_update(heap_recorder, /* full_update: */ false);
 }
 
+void heap_recorder_finalize_pending_recordings(heap_recorder *heap_recorder) {
+  if (heap_recorder == NULL) {
+    return; // Nothing to do
+  }
+
+  uint count = heap_recorder->pending_recordings_count;
+  if (count == 0) {
+    return; // Nothing to do
+  }
+
+  heap_recorder->stats_lifetime.deferred_recordings_finalized += count;
+
+  for (uint i = 0; i < count; i++) {
+    pending_recording *pending = &heap_recorder->pending_recordings[i];
+
+    // This is the step we couldn't do during the original sample call -- we're now expected to be called in a context
+    // where it's finally safe to call this
+    long obj_id = obj_id_or_fail(pending->object_ref);
+
+    // Create the object record now that we have the object_id
+    object_record *record = object_record_new(obj_id, pending->heap_record, pending->object_data);
+
+    commit_recording(heap_recorder, pending->heap_record, record);
+  }
+
+  heap_recorder->pending_recordings_count = 0;
+}
+
+// Mark pending recordings to prevent GC from collecting the objects
+// while they're waiting to be finalized
+void heap_recorder_mark_pending_recordings(heap_recorder *heap_recorder) {
+  if (heap_recorder == NULL) {
+    return;
+  }
+
+  for (uint i = 0; i < heap_recorder->pending_recordings_count; i++) {
+    rb_gc_mark(heap_recorder->pending_recordings[i].object_ref);
+  }
+
+  rb_gc_mark(heap_recorder->active_deferred_object);
+}
+
 // NOTE: This function needs and assumes it gets called with the GVL being held.
 //       But importantly **some of the operations inside `st_object_record_update` may cause a thread switch**,
 //       so we can't assume a single update happens in a single "atomic" step -- other threads may get some running time
@@ -547,20 +659,21 @@ bool heap_recorder_for_each_live_object(
 
 VALUE heap_recorder_state_snapshot(heap_recorder *heap_recorder) {
   VALUE arguments[] = {
-    ID2SYM(rb_intern("num_object_records")), /* => */ LONG2NUM(heap_recorder->object_records->num_entries),
-    ID2SYM(rb_intern("num_heap_records")),   /* => */ LONG2NUM(heap_recorder->heap_records->num_entries),
+    ID2SYM(rb_intern("num_object_records")), /* => */ ULONG2NUM(heap_recorder->object_records->num_entries),
+    ID2SYM(rb_intern("num_heap_records")),   /* => */ ULONG2NUM(heap_recorder->heap_records->num_entries),
+    ID2SYM(rb_intern("pending_recordings_count")), /* => */ ULONG2NUM(heap_recorder->pending_recordings_count),
 
     // Stats as of last update
-    ID2SYM(rb_intern("last_update_objects_alive")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_alive),
-    ID2SYM(rb_intern("last_update_objects_dead")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_dead),
-    ID2SYM(rb_intern("last_update_objects_skipped")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_skipped),
-    ID2SYM(rb_intern("last_update_objects_frozen")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_frozen),
+    ID2SYM(rb_intern("last_update_objects_alive")), /* => */ ULONG2NUM(heap_recorder->stats_last_update.objects_alive),
+    ID2SYM(rb_intern("last_update_objects_dead")), /* => */ ULONG2NUM(heap_recorder->stats_last_update.objects_dead),
+    ID2SYM(rb_intern("last_update_objects_skipped")), /* => */ ULONG2NUM(heap_recorder->stats_last_update.objects_skipped),
+    ID2SYM(rb_intern("last_update_objects_frozen")), /* => */ ULONG2NUM(heap_recorder->stats_last_update.objects_frozen),
 
     // Lifetime stats
-    ID2SYM(rb_intern("lifetime_updates_successful")), /* => */ LONG2NUM(heap_recorder->stats_lifetime.updates_successful),
-    ID2SYM(rb_intern("lifetime_updates_skipped_concurrent")), /* => */ LONG2NUM(heap_recorder->stats_lifetime.updates_skipped_concurrent),
-    ID2SYM(rb_intern("lifetime_updates_skipped_gcgen")), /* => */ LONG2NUM(heap_recorder->stats_lifetime.updates_skipped_gcgen),
-    ID2SYM(rb_intern("lifetime_updates_skipped_time")), /* => */ LONG2NUM(heap_recorder->stats_lifetime.updates_skipped_time),
+    ID2SYM(rb_intern("lifetime_updates_successful")), /* => */ ULONG2NUM(heap_recorder->stats_lifetime.updates_successful),
+    ID2SYM(rb_intern("lifetime_updates_skipped_concurrent")), /* => */ ULONG2NUM(heap_recorder->stats_lifetime.updates_skipped_concurrent),
+    ID2SYM(rb_intern("lifetime_updates_skipped_gcgen")), /* => */ ULONG2NUM(heap_recorder->stats_lifetime.updates_skipped_gcgen),
+    ID2SYM(rb_intern("lifetime_updates_skipped_time")), /* => */ ULONG2NUM(heap_recorder->stats_lifetime.updates_skipped_time),
     ID2SYM(rb_intern("lifetime_ewma_young_objects_alive")), /* => */ DBL2NUM(heap_recorder->stats_lifetime.ewma_young_objects_alive),
     ID2SYM(rb_intern("lifetime_ewma_young_objects_dead")), /* => */ DBL2NUM(heap_recorder->stats_lifetime.ewma_young_objects_dead),
       // Note: Here "young" refers to the young update; objects skipped includes non-young objects
@@ -568,15 +681,19 @@ VALUE heap_recorder_state_snapshot(heap_recorder *heap_recorder) {
     ID2SYM(rb_intern("lifetime_ewma_objects_alive")), /* => */ DBL2NUM(heap_recorder->stats_lifetime.ewma_objects_alive),
     ID2SYM(rb_intern("lifetime_ewma_objects_dead")), /* => */ DBL2NUM(heap_recorder->stats_lifetime.ewma_objects_dead),
     ID2SYM(rb_intern("lifetime_ewma_objects_skipped")), /* => */ DBL2NUM(heap_recorder->stats_lifetime.ewma_objects_skipped),
+
+    ID2SYM(rb_intern("lifetime_deferred_recordings_skipped_buffer_full")), /* => */ ULONG2NUM(heap_recorder->stats_lifetime.deferred_recordings_skipped_buffer_full),
+    ID2SYM(rb_intern("lifetime_deferred_recordings_finalized")), /* => */ ULONG2NUM(heap_recorder->stats_lifetime.deferred_recordings_finalized),
   };
   VALUE hash = rb_hash_new();
   for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(hash, arguments[i], arguments[i+1]);
+
   return hash;
 }
 
 typedef struct {
   heap_recorder *recorder;
-  VALUE debug_str;
+  VALUE debug_ary;
 } debug_context;
 
 VALUE heap_recorder_testonly_debug(heap_recorder *heap_recorder) {
@@ -584,13 +701,14 @@ VALUE heap_recorder_testonly_debug(heap_recorder *heap_recorder) {
     raise_error(rb_eArgError, "heap_recorder is NULL");
   }
 
-  VALUE debug_str = rb_str_new2("object records:\n");
-  debug_context context = (debug_context) {.recorder = heap_recorder, .debug_str = debug_str};
+  VALUE debug_ary = rb_ary_new();
+  debug_context context = (debug_context) {.recorder = heap_recorder, .debug_ary = debug_ary};
   st_foreach(heap_recorder->object_records, st_object_records_debug, (st_data_t) &context);
 
-  rb_str_catf(debug_str, "state snapshot: %"PRIsVALUE"\n------\n", heap_recorder_state_snapshot(heap_recorder));
-
-  return debug_str;
+  return rb_ary_new_from_args(2,
+    rb_ary_new_from_args(2, ID2SYM(rb_intern("records")), debug_ary),
+    rb_ary_new_from_args(2, ID2SYM(rb_intern("state")), heap_recorder_state_snapshot(heap_recorder))
+  );
 }
 
 // ==========================
@@ -710,11 +828,10 @@ static int st_object_records_iterate(DDTRACE_UNUSED st_data_t key, st_data_t val
 
 static int st_object_records_debug(DDTRACE_UNUSED st_data_t key, st_data_t value, st_data_t extra) {
   debug_context *context = (debug_context*) extra;
-  VALUE debug_str = context->debug_str;
 
   object_record *record = (object_record*) value;
 
-  rb_str_catf(debug_str, "%"PRIsVALUE"\n", object_record_inspect(context->recorder, record));
+  rb_ary_push(context->debug_ary, object_record_inspect(context->recorder, record));
 
   return ST_CONTINUE;
 }
@@ -728,14 +845,17 @@ static int update_object_record_entry(DDTRACE_UNUSED st_data_t *key, st_data_t *
   return ST_CONTINUE;
 }
 
-static void commit_recording(heap_recorder *heap_recorder, heap_record *heap_record, object_record *active_recording) {
-  // Link the object record with the corresponding heap record. This was the last remaining thing we
-  // needed to fully build the object_record.
-  active_recording->heap_record = heap_record;
+static void inc_tracked_objects_or_fail(heap_record *heap_record) {
   if (heap_record->num_tracked_objects == UINT32_MAX) {
     raise_error(rb_eRuntimeError, "Reached maximum number of tracked objects for heap record");
   }
   heap_record->num_tracked_objects++;
+}
+
+static void commit_recording(heap_recorder *heap_recorder, heap_record *heap_record, object_record *active_recording) {
+  // Link the object record with the corresponding heap record. This was the last remaining thing we
+  // needed to fully build the object_record.
+  active_recording->heap_record = heap_record;
 
   int existing_error = st_update(heap_recorder->object_records, active_recording->obj_id, update_object_record_entry, (st_data_t) active_recording);
   if (existing_error) {
@@ -955,6 +1075,17 @@ static VALUE get_ruby_string_or_raise(heap_recorder *recorder, ddog_prof_Managed
   return ruby_string;
 }
 
+static long obj_id_or_fail(VALUE obj) {
+  VALUE ruby_obj_id = rb_obj_id(obj);
+  if (!FIXNUM_P(ruby_obj_id)) {
+    // Bignum object ids indicate the fixnum range is exhausted - all future IDs will also be bignums.
+    // Heap profiling cannot continue.
+    raise_error(rb_eRuntimeError, "Heap profiling: bignum object id detected. Heap profiling cannot continue.");
+  }
+
+  return FIX2LONG(ruby_obj_id);
+}
+
 static inline double ewma_stat(double previous, double current) {
   double alpha = 0.3;
   return (1 - alpha) * previous + alpha * current;

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,15 +78,31 @@ 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 {
     raise_error(rb_eArgError, "Failed to initialize transport: Unexpected working mode, expected :agentless or :agent");
   }
@@ -123,41 +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_CharSlice *process_tags
-) {
-  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,
-    /* optional_process_tags: */ process_tags,
-    &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.
   //
@@ -182,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 ?
@@ -204,7 +195,6 @@ 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);
@@ -215,7 +205,6 @@ static VALUE _native_do_export(
   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(tags_as_array, T_ARRAY);
@@ -227,8 +216,6 @@ static VALUE _native_do_export(
   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;
   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};
@@ -250,29 +237,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,
-    &process_tags_slice
-  );
+  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/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/profiling.c

@@ -25,6 +25,7 @@ void encoded_profile_init(VALUE profiling_module);
 void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
 void crashtracking_runtime_stacks_init(void);
+void setup_signal_handler_init(VALUE profiling_module);
 
 static VALUE native_working_p(VALUE self);
 static VALUE _native_grab_gvl_and_raise(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message, VALUE test_message_arg, VALUE release_gvl);
@@ -62,6 +63,7 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   rb_funcall(native_extension_module, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("native_working?")));
 
   ruby_helpers_init();
+  setup_signal_handler_init(profiling_module);
   collectors_cpu_and_wall_time_worker_init(profiling_module);
   collectors_discrete_dynamic_sampler_init(profiling_module);
   collectors_dynamic_sampling_rate_init(profiling_module);
@@ -251,7 +253,7 @@ static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VA
 
   ENFORCE_SUCCESS_GVL(pthread_mutex_unlock(&holding_the_gvl_signal_handler_mutex));
 
-  replace_sigprof_signal_handler_with_empty_handler(holding_the_gvl_signal_handler);
+  replace_sigprof_signal_handler_with_empty_handler(holding_the_gvl_signal_handler, true);
 
   if (holding_the_gvl_signal_handler_result[0] == Qfalse) raise_error(rb_eRuntimeError, "Could not signal background_thread");