datadog 2.4.0 → 2.44.0

data/ext/datadog_profiling_native_extension/heap_recorder.h

@@ -17,7 +17,7 @@
 typedef struct heap_recorder heap_recorder;
 
 // Extra data associated with each live object being tracked.
-typedef struct live_object_data {
+typedef struct {
   // The weight of this object from a sampling perspective.
   //
   // A notion of weight is preserved for each tracked object to allow for an approximate
@@ -34,7 +34,7 @@ typedef struct live_object_data {
 
   // The class of the object that we're tracking.
   // NOTE: This is optional and will be set to NULL if not set.
-  char* class;
+  ddog_prof_ManagedStringId class;
 
   // The GC allocation gen in which we saw this object being allocated.
   //
@@ -59,7 +59,7 @@ typedef struct {
 } heap_recorder_iteration_data;
 
 // Initialize a new heap recorder.
-heap_recorder* heap_recorder_new(void);
+heap_recorder* heap_recorder_new(ddog_prof_ManagedStringStorage string_storage);
 
 // Free a previously initialized heap recorder.
 void heap_recorder_free(heap_recorder *heap_recorder);
@@ -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,29 +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.
-void 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);
+
+// 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.
+void heap_recorder_commit_recordings_may_lose_gvl(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.
@@ -159,10 +177,31 @@ VALUE heap_recorder_state_snapshot(heap_recorder *heap_recorder);
 
 // v--- TEST-ONLY APIs ---v
 
-// Assert internal hashing logic is valid for the provided locations and its
-// corresponding internal representations in heap recorder.
-void heap_recorder_testonly_assert_hash_matches(ddog_prof_Slice_Location locations);
-
 // Returns a Ruby string with a representation of internal data helpful to
 // troubleshoot issues such as unexpected test failures.
 VALUE heap_recorder_testonly_debug(heap_recorder *heap_recorder);
+
+// 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);
+
+// Overrides the GC gen a tracked object is considered to have been allocated in. This lets tests give an object an
+// exact age, instead of relying on an exact number of GCs having run.
+void heap_recorder_testonly_set_object_alloc_gen(heap_recorder *heap_recorder, long record_id, size_t alloc_gen);
+
+// 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/http_transport.c

@@ -4,6 +4,7 @@
 #include "helpers.h"
 #include "libdatadog_helpers.h"
 #include "ruby_helpers.h"
+#include "encoded_profile.h"
 
 // Used to report profiling data to Datadog.
 // This file implements the native bits of the Datadog::Profiling::HttpTransport class
@@ -13,33 +14,26 @@ static VALUE error_symbol = Qnil; // :error in Ruby
 
 static VALUE library_version_string = Qnil;
 
-struct call_exporter_without_gvl_arguments {
-  ddog_prof_Exporter *exporter;
-  ddog_prof_Exporter_Request_BuildResult *build_result;
+typedef struct {
+  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_CancellationToken *cancel_token;
-  ddog_prof_Exporter_SendResult result;
+  ddog_prof_Result_HttpStatus result;
   bool send_ran;
-};
+} call_exporter_without_gvl_arguments;
 
 static inline ddog_ByteSlice byte_slice_from_ruby_string(VALUE string);
 static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration);
-static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
-static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_result);
+static ddog_prof_ProfileExporter_Result create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
+static VALUE handle_exporter_failure(ddog_prof_ProfileExporter_Result exporter_result);
 static VALUE _native_do_export(
   VALUE self,
   VALUE exporter_configuration,
-  VALUE upload_timeout_milliseconds,
-  VALUE start_timespec_seconds,
-  VALUE start_timespec_nanoseconds,
-  VALUE finish_timespec_seconds,
-  VALUE finish_timespec_nanoseconds,
-  VALUE pprof_file_name,
-  VALUE pprof_data,
-  VALUE code_provenance_file_name,
-  VALUE code_provenance_data,
-  VALUE tags_as_array,
-  VALUE internal_metadata_json,
-  VALUE info_json
+  VALUE flush
 );
 static void *call_exporter_without_gvl(void *call_args);
 static void interrupt_exporter_call(void *cancel_token);
@@ -48,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, 13);
+  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"));
@@ -65,14 +59,14 @@ static inline ddog_ByteSlice byte_slice_from_ruby_string(VALUE string) {
 
 static VALUE _native_validate_exporter(DDTRACE_UNUSED VALUE _self, VALUE exporter_configuration) {
   ENFORCE_TYPE(exporter_configuration, T_ARRAY);
-  ddog_prof_Exporter_NewResult exporter_result = create_exporter(exporter_configuration, rb_ary_new());
+  ddog_prof_ProfileExporter_Result exporter_result = create_exporter(exporter_configuration, rb_ary_new());
 
   VALUE failure_tuple = handle_exporter_failure(exporter_result);
   if (!NIL_P(failure_tuple)) return failure_tuple;
 
   // We don't actually need the exporter for now -- we just wanted to validate that we could create it with the
   // settings we were given
-  ddog_prof_Exporter_drop(exporter_result.ok);
+  ddog_prof_Exporter_drop(&exporter_result.ok);
 
   return rb_ary_new_from_args(2, ok_symbol, Qnil);
 }
@@ -84,26 +78,37 @@ static ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration) {
   ENFORCE_TYPE(exporter_working_mode, T_SYMBOL);
   ID working_mode = SYM2ID(exporter_working_mode);
 
-  ID agentless_id = rb_intern("agentless");
-  ID agent_id = rb_intern("agent");
-
-  if (working_mode != agentless_id && working_mode != agent_id) {
-    rb_raise(rb_eArgError, "Failed to initialize transport: Unexpected working mode, expected :agentless or :agent");
-  }
-
-  if (working_mode == agentless_id) {
-    VALUE site = rb_ary_entry(exporter_configuration, 1);
-    VALUE api_key = rb_ary_entry(exporter_configuration, 2);
-
-    return ddog_prof_Endpoint_agentless(char_slice_from_ruby_string(site), char_slice_from_ruby_string(api_key));
-  } else { // agent_id
-    VALUE base_url = rb_ary_entry(exporter_configuration, 1);
-
-    return ddog_prof_Endpoint_agent(char_slice_from_ruby_string(base_url));
+  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);
+
+  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, 3);
+
+    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");
   }
 }
 
-static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array) {
+static ddog_prof_ProfileExporter_Result create_exporter(VALUE exporter_configuration, VALUE tags_as_array) {
   ENFORCE_TYPE(exporter_configuration, T_ARRAY);
   ENFORCE_TYPE(tags_as_array, T_ARRAY);
 
@@ -117,7 +122,7 @@ static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration
   ddog_CharSlice library_version = char_slice_from_ruby_string(library_version_string);
   ddog_CharSlice profiling_family = DDOG_CHARSLICE_C("ruby");
 
-  ddog_prof_Exporter_NewResult exporter_result =
+  ddog_prof_ProfileExporter_Result exporter_result =
     ddog_prof_Exporter_new(library_name, library_version, profiling_family, &tags, endpoint);
 
   ddog_Vec_Tag_drop(tags);
@@ -125,49 +130,30 @@ static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration
   return exporter_result;
 }
 
-static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_result) {
-  return exporter_result.tag == DDOG_PROF_EXPORTER_NEW_RESULT_OK ?
+static void validate_token(ddog_CancellationToken token, const char *file, int 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) {
+  return exporter_result.tag == DDOG_PROF_PROFILE_EXPORTER_RESULT_OK_HANDLE_PROFILE_EXPORTER ?
     Qnil :
     rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&exporter_result.err));
 }
 
 // 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_Exporter *exporter,
-  ddog_Timespec start,
-  ddog_Timespec finish,
-  ddog_prof_Exporter_Slice_File files_to_compress_and_export,
-  ddog_prof_Exporter_Slice_File files_to_export_unmodified,
-  ddog_Vec_Tag *additional_tags,
-  ddog_CharSlice internal_metadata,
-  ddog_CharSlice info
-) {
-  ddog_prof_ProfiledEndpointsStats *endpoints_stats = NULL; // Not in use yet
-  ddog_prof_Exporter_Request_BuildResult build_result = ddog_prof_Exporter_Request_build(
-    exporter,
-    start,
-    finish,
-    files_to_compress_and_export,
-    files_to_export_unmodified,
-    additional_tags,
-    endpoints_stats,
-    &internal_metadata,
-    &info
-  );
+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);
 
-  if (build_result.tag == DDOG_PROF_EXPORTER_REQUEST_BUILD_RESULT_ERR) {
-    ddog_prof_Exporter_drop(exporter);
-    return rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&build_result.err));
-  }
+  validate_token(cancel_token_request, __FILE__, __LINE__);
+  validate_token(cancel_token_interrupt, __FILE__, __LINE__);
 
-  ddog_CancellationToken *cancel_token = ddog_CancellationToken_new();
+  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
-  struct call_exporter_without_gvl_arguments args =
-    {.exporter = exporter, .build_result = &build_result, .cancel_token = cancel_token, .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.
   //
@@ -183,126 +169,102 @@ static VALUE perform_export(
   int pending_exception = 0;
 
   while (!args.send_ran && !pending_exception) {
-    rb_thread_call_without_gvl2(call_exporter_without_gvl, &args, interrupt_exporter_call, cancel_token);
+    rb_thread_call_without_gvl2(call_exporter_without_gvl, &args, interrupt_exporter_call, &cancel_token_interrupt);
 
     // To make sure we don't leak memory, we never check for pending exceptions if send ran
     if (!args.send_ran) pending_exception = check_if_pending_exception();
   }
 
   // Cleanup exporter and token, no longer needed
-  ddog_CancellationToken_drop(cancel_token);
-  ddog_prof_Exporter_drop(exporter);
+  ddog_CancellationToken_drop(&cancel_token_request);
+  ddog_CancellationToken_drop(&cancel_token_interrupt);
+  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_Exporter_SendResult result = args.result;
+  ddog_prof_Result_HttpStatus result = args.result;
 
-  return result.tag == DDOG_PROF_EXPORTER_SEND_RESULT_HTTP_RESPONSE ?
-    rb_ary_new_from_args(2, ok_symbol, UINT2NUM(result.http_response.code)) :
+  return result.tag == DDOG_PROF_RESULT_HTTP_STATUS_OK_HTTP_STATUS ?
+    rb_ary_new_from_args(2, ok_symbol, UINT2NUM(result.ok.code)) :
     rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&result.err));
 }
 
 static VALUE _native_do_export(
   DDTRACE_UNUSED VALUE _self,
   VALUE exporter_configuration,
-  VALUE upload_timeout_milliseconds,
-  VALUE start_timespec_seconds,
-  VALUE start_timespec_nanoseconds,
-  VALUE finish_timespec_seconds,
-  VALUE finish_timespec_nanoseconds,
-  VALUE pprof_file_name,
-  VALUE pprof_data,
-  VALUE code_provenance_file_name,
-  VALUE code_provenance_data,
-  VALUE tags_as_array,
-  VALUE internal_metadata_json,
-  VALUE info_json
+  VALUE flush
 ) {
-  ENFORCE_TYPE(upload_timeout_milliseconds, T_FIXNUM);
-  ENFORCE_TYPE(start_timespec_seconds, T_FIXNUM);
-  ENFORCE_TYPE(start_timespec_nanoseconds, T_FIXNUM);
-  ENFORCE_TYPE(finish_timespec_seconds, T_FIXNUM);
-  ENFORCE_TYPE(finish_timespec_nanoseconds, T_FIXNUM);
-  ENFORCE_TYPE(pprof_file_name, T_STRING);
-  ENFORCE_TYPE(pprof_data, T_STRING);
-  ENFORCE_TYPE(code_provenance_file_name, T_STRING);
+  VALUE encoded_profile = rb_funcall(flush, rb_intern("encoded_profile"), 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_encoded_profile_instance(encoded_profile);
+  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);
-
-  ddog_Timespec start =
-    {.seconds = NUM2LONG(start_timespec_seconds), .nanoseconds = NUM2UINT(start_timespec_nanoseconds)};
-  ddog_Timespec finish =
-    {.seconds = NUM2LONG(finish_timespec_seconds), .nanoseconds = NUM2UINT(finish_timespec_nanoseconds)};
-
-  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];
-  int already_compressed_length = 1; // pprof
-  ddog_prof_Exporter_File already_compressed[already_compressed_length];
-
   ddog_prof_Exporter_Slice_File files_to_compress_and_export = {.ptr = to_compress, .len = to_compress_length};
-  ddog_prof_Exporter_Slice_File files_to_export_unmodified = {.ptr = already_compressed, .len = already_compressed_length};
 
-  already_compressed[0] = (ddog_prof_Exporter_File) {
-    .name = char_slice_from_ruby_string(pprof_file_name),
-    .file = byte_slice_from_ruby_string(pprof_data),
+  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_Vec_Tag *null_additional_tags = NULL;
   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_Exporter_NewResult exporter_result = create_exporter(exporter_configuration, tags_as_array);
+  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
 
   VALUE failure_tuple = handle_exporter_failure(exporter_result);
   if (!NIL_P(failure_tuple)) return failure_tuple;
 
-  ddog_prof_MaybeError timeout_result = ddog_prof_Exporter_set_timeout(exporter_result.ok, timeout_milliseconds);
-  if (timeout_result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
-    // 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.some));
-  }
-
-  return perform_export(
-    exporter_result.ok,
-    start,
-    finish,
-    files_to_compress_and_export,
-    files_to_export_unmodified,
-    null_additional_tags,
-    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) {
-  struct call_exporter_without_gvl_arguments *args = (struct call_exporter_without_gvl_arguments*) call_args;
-
-  args->result = ddog_prof_Exporter_send(args->exporter, &args->build_result->ok, args->cancel_token);
+  call_exporter_without_gvl_arguments *args = (call_exporter_without_gvl_arguments*) call_args;
+
+  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
@@ -310,5 +272,7 @@ static void *call_exporter_without_gvl(void *call_args) {
 
 // Called by Ruby when it wants to interrupt call_exporter_without_gvl above, e.g. when the app wants to exit cleanly
 static void interrupt_exporter_call(void *cancel_token) {
+  // TODO: False here can mean two things: it was already cancelled OR it failed to cancel.
+  // Would be nice to change libdatadog to be able to distinguish between them...
   ddog_CancellationToken_cancel((ddog_CancellationToken *) cancel_token);
 }

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,22 +42,24 @@ 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_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) {
+    raise_error(rb_eRuntimeError, "Failed to intern string: %"PRIsVALUE, get_error_details_and_drop(&intern_result.err));
   }
+  return intern_result.ok;
+}
 
-  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;
+void intern_all_or_raise(
+  ddog_prof_ManagedStringStorage string_storage,
+  ddog_prof_Slice_CharSlice strings,
+  ddog_prof_ManagedStringId *output_ids,
+  uintptr_t output_ids_size
+) {
+  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) {
+    raise_error(rb_eRuntimeError, "Failed to intern_all: %"PRIsVALUE, get_error_details_and_drop(&result.some));
   }
-  strncpy(string, error_msg_slice.ptr, error_msg_size);
-  string[error_msg_size] = '\0';
-  ddog_Error_drop(error);
-  return error_msg_size;
 }

data/ext/datadog_profiling_native_extension/libdatadog_helpers.h

@@ -7,19 +7,17 @@ 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.
 const char *ruby_value_type_to_string(enum ruby_value_type type);
 ddog_CharSlice ruby_value_type_to_char_slice(enum ruby_value_type type);
 
-// Returns a dynamically allocated string from the provided char slice.
-// WARN: The returned string must be explicitly freed with ruby_xfree.
-static inline char* string_from_char_slice(ddog_CharSlice slice) {
-  return ruby_strndup(slice.ptr, slice.len);
-}
+ddog_prof_ManagedStringId intern_or_raise(ddog_prof_ManagedStringStorage string_storage, ddog_CharSlice string);
+
+void intern_all_or_raise(
+  ddog_prof_ManagedStringStorage string_storage,
+  ddog_prof_Slice_CharSlice strings,
+  ddog_prof_ManagedStringId *output_ids,
+  uintptr_t output_ids_size
+);