datadog 2.26.0 → 2.27.0

data/ext/datadog_profiling_native_extension/heap_recorder.c

@@ -259,7 +259,7 @@ void heap_recorder_set_sample_rate(heap_recorder *heap_recorder, int sample_rate
   }
 
   if (sample_rate <= 0) {
-    rb_raise(rb_eArgError, "Heap sample rate must be a positive integer value but was %d", sample_rate);
+    raise_error(rb_eArgError, "Heap sample rate must be a positive integer value but was %d", sample_rate);
   }
 
   heap_recorder->sample_rate = sample_rate;
@@ -300,7 +300,7 @@ void start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj
   }
 
   if (heap_recorder->active_recording != NULL) {
-    rb_raise(rb_eRuntimeError, "Detected consecutive heap allocation recording starts without end.");
+    raise_error(rb_eRuntimeError, "Detected consecutive heap allocation recording starts without end.");
   }
 
   if (++heap_recorder->num_recordings_skipped < heap_recorder->sample_rate ||
@@ -323,7 +323,7 @@ void start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj
 
   VALUE ruby_obj_id = rb_obj_id(new_obj);
   if (!FIXNUM_P(ruby_obj_id)) {
-    rb_raise(rb_eRuntimeError, "Detected a bignum object id. These are not supported by heap profiling.");
+    raise_error(rb_eRuntimeError, "Detected a bignum object id. These are not supported by heap profiling.");
   }
 
   heap_recorder->active_recording = object_record_new(
@@ -371,7 +371,7 @@ static VALUE end_heap_allocation_recording(VALUE protect_args) {
 
   if (active_recording == NULL) {
     // Recording ended without having been started?
-    rb_raise(rb_eRuntimeError, "Ended a heap recording that was not 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
@@ -487,14 +487,14 @@ void heap_recorder_prepare_iteration(heap_recorder *heap_recorder) {
 
   if (heap_recorder->object_records_snapshot != NULL) {
     // we could trivially handle this but we raise to highlight and catch unexpected usages.
-    rb_raise(rb_eRuntimeError, "New heap recorder iteration prepared without the previous one having been finished.");
+    raise_error(rb_eRuntimeError, "New heap recorder iteration prepared without the previous one having been finished.");
   }
 
   heap_recorder_update(heap_recorder, /* full_update: */ true);
 
   heap_recorder->object_records_snapshot = st_copy(heap_recorder->object_records);
   if (heap_recorder->object_records_snapshot == NULL) {
-    rb_raise(rb_eRuntimeError, "Failed to create heap snapshot.");
+    raise_error(rb_eRuntimeError, "Failed to create heap snapshot.");
   }
 }
 
@@ -505,7 +505,7 @@ void heap_recorder_finish_iteration(heap_recorder *heap_recorder) {
 
   if (heap_recorder->object_records_snapshot == NULL) {
     // we could trivially handle this but we raise to highlight and catch unexpected usages.
-    rb_raise(rb_eRuntimeError, "Heap recorder iteration finished without having been prepared.");
+    raise_error(rb_eRuntimeError, "Heap recorder iteration finished without having been prepared.");
   }
 
   st_free_table(heap_recorder->object_records_snapshot);
@@ -581,7 +581,7 @@ typedef struct {
 
 VALUE heap_recorder_testonly_debug(heap_recorder *heap_recorder) {
   if (heap_recorder == NULL) {
-    rb_raise(rb_eArgError, "heap_recorder is NULL");
+    raise_error(rb_eArgError, "heap_recorder is NULL");
   }
 
   VALUE debug_str = rb_str_new2("object records:\n");
@@ -733,7 +733,7 @@ static void commit_recording(heap_recorder *heap_recorder, heap_record *heap_rec
   // needed to fully build the object_record.
   active_recording->heap_record = heap_record;
   if (heap_record->num_tracked_objects == UINT32_MAX) {
-    rb_raise(rb_eRuntimeError, "Reached maximum number of tracked objects for heap record");
+    raise_error(rb_eRuntimeError, "Reached maximum number of tracked objects for heap record");
   }
   heap_record->num_tracked_objects++;
 
@@ -741,11 +741,11 @@ static void commit_recording(heap_recorder *heap_recorder, heap_record *heap_rec
   if (existing_error) {
     object_record *existing_record = NULL;
     st_lookup(heap_recorder->object_records, active_recording->obj_id, (st_data_t *) &existing_record);
-    if (existing_record == NULL) rb_raise(rb_eRuntimeError, "Unexpected NULL when reading existing record");
+    if (existing_record == NULL) raise_error(rb_eRuntimeError, "Unexpected NULL when reading existing record");
 
     VALUE existing_inspect = object_record_inspect(heap_recorder, existing_record);
     VALUE new_inspect = object_record_inspect(heap_recorder, active_recording);
-    rb_raise(rb_eRuntimeError, "Object ids are supposed to be unique. We got 2 allocation recordings with "
+    raise_error(rb_eRuntimeError, "Object ids are supposed to be unique. We got 2 allocation recordings with "
       "the same id. previous={%"PRIsVALUE"} new={%"PRIsVALUE"}", existing_inspect, new_inspect);
   }
 }
@@ -781,7 +781,7 @@ static void cleanup_heap_record_if_unused(heap_recorder *heap_recorder, heap_rec
   }
 
   if (!st_delete(heap_recorder->heap_records, (st_data_t*) &heap_record, NULL)) {
-    rb_raise(rb_eRuntimeError, "Attempted to cleanup an untracked heap_record");
+    raise_error(rb_eRuntimeError, "Attempted to cleanup an untracked heap_record");
   };
   heap_record_free(heap_recorder, heap_record);
 }
@@ -791,14 +791,14 @@ static void on_committed_object_record_cleanup(heap_recorder *heap_recorder, obj
   // (See PROF-10656 Datadog-internal for details). Just in case, I've sprinkled a bunch of NULL tests in this function for now.
   // Once we figure out the issue we can get rid of them again.
 
-  if (heap_recorder == NULL) rb_raise(rb_eRuntimeError, "heap_recorder was NULL in on_committed_object_record_cleanup");
-  if (heap_recorder->heap_records == NULL) rb_raise(rb_eRuntimeError, "heap_recorder->heap_records was NULL in on_committed_object_record_cleanup");
-  if (record == NULL) rb_raise(rb_eRuntimeError, "record was NULL in on_committed_object_record_cleanup");
+  if (heap_recorder == NULL) raise_error(rb_eRuntimeError, "heap_recorder was NULL in on_committed_object_record_cleanup");
+  if (heap_recorder->heap_records == NULL) raise_error(rb_eRuntimeError, "heap_recorder->heap_records was NULL in on_committed_object_record_cleanup");
+  if (record == NULL) raise_error(rb_eRuntimeError, "record was NULL in on_committed_object_record_cleanup");
 
   // Starting with the associated heap record. There will now be one less tracked object pointing to it
   heap_record *heap_record = record->heap_record;
 
-  if (heap_record == NULL) rb_raise(rb_eRuntimeError, "heap_record was NULL in on_committed_object_record_cleanup");
+  if (heap_record == NULL) raise_error(rb_eRuntimeError, "heap_record was NULL in on_committed_object_record_cleanup");
 
   heap_record->num_tracked_objects--;
 
@@ -862,7 +862,7 @@ heap_record* heap_record_new(heap_recorder *recorder, ddog_prof_Slice_Location l
   uint16_t frames_len = locations.len;
   if (frames_len > MAX_FRAMES_LIMIT) {
     // This is not expected as MAX_FRAMES_LIMIT is shared with the stacktrace construction mechanism
-    rb_raise(rb_eRuntimeError, "Found stack with more than %d frames (%d)", MAX_FRAMES_LIMIT, frames_len);
+    raise_error(rb_eRuntimeError, "Found stack with more than %d frames (%d)", MAX_FRAMES_LIMIT, frames_len);
   }
   heap_record *stack = calloc(1, sizeof(heap_record) + frames_len * sizeof(heap_frame)); // See "note on calloc vs ruby_xcalloc use" above
   stack->num_tracked_objects = 0;
@@ -933,21 +933,21 @@ static void unintern_or_raise(heap_recorder *recorder, ddog_prof_ManagedStringId
 
   ddog_prof_MaybeError result = ddog_prof_ManagedStringStorage_unintern(recorder->string_storage, id);
   if (result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
-    rb_raise(rb_eRuntimeError, "Failed to unintern id: %"PRIsVALUE, get_error_details_and_drop(&result.some));
+    raise_error(rb_eRuntimeError, "Failed to unintern id: %"PRIsVALUE, get_error_details_and_drop(&result.some));
   }
 }
 
 static void unintern_all_or_raise(heap_recorder *recorder, ddog_prof_Slice_ManagedStringId ids) {
   ddog_prof_MaybeError result = ddog_prof_ManagedStringStorage_unintern_all(recorder->string_storage, ids);
   if (result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
-    rb_raise(rb_eRuntimeError, "Failed to unintern_all: %"PRIsVALUE, get_error_details_and_drop(&result.some));
+    raise_error(rb_eRuntimeError, "Failed to unintern_all: %"PRIsVALUE, get_error_details_and_drop(&result.some));
   }
 }
 
 static VALUE get_ruby_string_or_raise(heap_recorder *recorder, ddog_prof_ManagedStringId id) {
   ddog_StringWrapperResult get_string_result = ddog_prof_ManagedStringStorage_get_string(recorder->string_storage, id);
   if (get_string_result.tag == DDOG_STRING_WRAPPER_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to get string: %"PRIsVALUE, get_error_details_and_drop(&get_string_result.err));
+    raise_error(rb_eRuntimeError, "Failed to get string: %"PRIsVALUE, get_error_details_and_drop(&get_string_result.err));
   }
   VALUE ruby_string = ruby_string_from_vec_u8(get_string_result.ok.message);
   ddog_StringWrapper_drop((ddog_StringWrapper *) &get_string_result.ok);
@@ -962,7 +962,7 @@ static inline double ewma_stat(double previous, double current) {
 
 VALUE heap_recorder_testonly_is_object_recorded(heap_recorder *heap_recorder, VALUE obj_id) {
   if (heap_recorder == NULL) {
-    rb_raise(rb_eArgError, "heap_recorder is NULL");
+    raise_error(rb_eArgError, "heap_recorder is NULL");
   }
 
   // Check if object records contains an object with this object_id
@@ -971,15 +971,15 @@ VALUE heap_recorder_testonly_is_object_recorded(heap_recorder *heap_recorder, VA
 
 void heap_recorder_testonly_reset_last_update(heap_recorder *heap_recorder) {
   if (heap_recorder == NULL) {
-    rb_raise(rb_eArgError, "heap_recorder is NULL");
+    raise_error(rb_eArgError, "heap_recorder is NULL");
   }
 
   heap_recorder->last_update_ns = 0;
 }
 
 void heap_recorder_testonly_benchmark_intern(heap_recorder *heap_recorder, ddog_CharSlice string, int times, bool use_all) {
-  if (heap_recorder == NULL) rb_raise(rb_eArgError, "heap profiling must be enabled");
-  if (times > REUSABLE_FRAME_DETAILS_SIZE) rb_raise(rb_eArgError, "times cannot be > than REUSABLE_FRAME_DETAILS_SIZE");
+  if (heap_recorder == NULL) raise_error(rb_eArgError, "heap profiling must be enabled");
+  if (times > REUSABLE_FRAME_DETAILS_SIZE) raise_error(rb_eArgError, "times cannot be > than REUSABLE_FRAME_DETAILS_SIZE");
 
   if (use_all) {
     ddog_CharSlice *strings = heap_recorder->reusable_char_slices;

data/ext/datadog_profiling_native_extension/http_transport.c

@@ -85,7 +85,7 @@ static ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration) {
 
     return ddog_prof_Endpoint_agent(char_slice_from_ruby_string(base_url));
   } 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 +112,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) {
@@ -128,7 +128,8 @@ static VALUE perform_export(
   ddog_prof_EncodedProfile *profile,
   ddog_prof_Exporter_Slice_File files_to_compress_and_export,
   ddog_CharSlice internal_metadata,
-  ddog_CharSlice info
+  ddog_CharSlice info,
+  ddog_CharSlice *process_tags
 ) {
   ddog_prof_Request_Result build_result = ddog_prof_Exporter_Request_build(
     exporter,
@@ -136,7 +137,7 @@ static VALUE perform_export(
     files_to_compress_and_export,
     /* files_to_export_unmodified: */ ddog_prof_Exporter_Slice_File_empty(),
     /* optional_additional_tags: */ NULL,
-    /* optional_process_tags: */ NULL,
+    /* optional_process_tags: */ process_tags,
     &internal_metadata,
     &info
   );
@@ -212,6 +213,7 @@ static VALUE _native_do_export(
   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);
@@ -219,6 +221,7 @@ static VALUE _native_do_export(
   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);
@@ -239,6 +242,7 @@ static VALUE _native_do_export(
 
   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
@@ -260,7 +264,8 @@ static VALUE _native_do_export(
     to_ddog_prof_EncodedProfile(encoded_profile),
     files_to_compress_and_export,
     internal_metadata,
-    info
+    info,
+    &process_tags_slice
   );
 }
 

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/private_vm_api_access.c

@@ -456,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

data/ext/datadog_profiling_native_extension/profiling.c

@@ -8,6 +8,7 @@
 #include "clock_id.h"
 #include "helpers.h"
 #include "private_vm_api_access.h"
+#include "datadog_ruby_common.h"
 #include "ruby_helpers.h"
 #include "setup_signal_handler.h"
 #include "time_helpers.h"
@@ -50,6 +51,10 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   #endif
 
   VALUE datadog_module = rb_define_module("Datadog");
+
+  // MUST be called before all other initialization
+  datadog_ruby_common_init();
+
   VALUE profiling_module = rb_define_module_under(datadog_module, "Profiling");
   VALUE native_extension_module = rb_define_module_under(profiling_module, "NativeExtension");
 
@@ -99,7 +104,7 @@ static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
 typedef struct {
   VALUE exception_class;
   char *test_message;
-  int test_message_arg;
+  char *test_message_arg;
 } trigger_grab_gvl_and_raise_arguments;
 
 static VALUE _native_grab_gvl_and_raise(DDTRACE_UNUSED VALUE _self, VALUE exception_class, VALUE test_message, VALUE test_message_arg, VALUE release_gvl) {
@@ -109,24 +114,24 @@ static VALUE _native_grab_gvl_and_raise(DDTRACE_UNUSED VALUE _self, VALUE except
 
   args.exception_class = exception_class;
   args.test_message = StringValueCStr(test_message);
-  args.test_message_arg = test_message_arg != Qnil ? NUM2INT(test_message_arg) : -1;
+  args.test_message_arg = test_message_arg != Qnil ? StringValueCStr(test_message_arg) : NULL;
 
   if (RTEST(release_gvl)) {
     rb_thread_call_without_gvl(trigger_grab_gvl_and_raise, &args, NULL, NULL);
   } else {
-    grab_gvl_and_raise(args.exception_class, "%s", args.test_message);
+    private_grab_gvl_and_raise(args.exception_class, 0, args.test_message, args.test_message_arg);
   }
 
-  rb_raise(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise; this should never happen");
+  raise_error(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise; this should never happen");
 }
 
 static void *trigger_grab_gvl_and_raise(void *trigger_args) {
   trigger_grab_gvl_and_raise_arguments *args = (trigger_grab_gvl_and_raise_arguments *) trigger_args;
 
-  if (args->test_message_arg >= 0) {
-    grab_gvl_and_raise(args->exception_class, "%s%d", args->test_message, args->test_message_arg);
+  if (args->test_message_arg != NULL) {
+    private_grab_gvl_and_raise(args->exception_class, 0, args->test_message, args->test_message_arg);
   } else {
-    grab_gvl_and_raise(args->exception_class, "%s", args->test_message);
+    private_grab_gvl_and_raise(args->exception_class, 0, args->test_message, NULL);
   }
 
   return NULL;
@@ -135,7 +140,7 @@ static void *trigger_grab_gvl_and_raise(void *trigger_args) {
 typedef struct {
   int syserr_errno;
   char *test_message;
-  int test_message_arg;
+  char *test_message_arg;
 } trigger_grab_gvl_and_raise_syserr_arguments;
 
 static VALUE _native_grab_gvl_and_raise_syserr(DDTRACE_UNUSED VALUE _self, VALUE syserr_errno, VALUE test_message, VALUE test_message_arg, VALUE release_gvl) {
@@ -145,24 +150,24 @@ static VALUE _native_grab_gvl_and_raise_syserr(DDTRACE_UNUSED VALUE _self, VALUE
 
   args.syserr_errno = NUM2INT(syserr_errno);
   args.test_message = StringValueCStr(test_message);
-  args.test_message_arg = test_message_arg != Qnil ? NUM2INT(test_message_arg) : -1;
+  args.test_message_arg = test_message_arg != Qnil ? StringValueCStr(test_message_arg) : NULL;
 
   if (RTEST(release_gvl)) {
     rb_thread_call_without_gvl(trigger_grab_gvl_and_raise_syserr, &args, NULL, NULL);
   } else {
-    grab_gvl_and_raise_syserr(args.syserr_errno, "%s", args.test_message);
+    private_grab_gvl_and_raise(Qnil, args.syserr_errno, args.test_message, args.test_message_arg);
   }
 
-  rb_raise(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise_syserr; this should never happen");
+  raise_error(rb_eRuntimeError, "Failed to raise exception in _native_grab_gvl_and_raise_syserr; this should never happen");
 }
 
 static void *trigger_grab_gvl_and_raise_syserr(void *trigger_args) {
   trigger_grab_gvl_and_raise_syserr_arguments *args = (trigger_grab_gvl_and_raise_syserr_arguments *) trigger_args;
 
-  if (args->test_message_arg >= 0) {
-    grab_gvl_and_raise_syserr(args->syserr_errno, "%s%d", args->test_message, args->test_message_arg);
+  if (args->test_message_arg != NULL) {
+    private_grab_gvl_and_raise(Qnil, args->syserr_errno, args->test_message, args->test_message_arg);
   } else {
-    grab_gvl_and_raise_syserr(args->syserr_errno, "%s", args->test_message);
+    private_grab_gvl_and_raise(Qnil, args->syserr_errno, args->test_message, NULL);
   }
 
   return NULL;
@@ -248,7 +253,7 @@ static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VA
 
   replace_sigprof_signal_handler_with_empty_handler(holding_the_gvl_signal_handler);
 
-  if (holding_the_gvl_signal_handler_result[0] == Qfalse) rb_raise(rb_eRuntimeError, "Could not signal background_thread");
+  if (holding_the_gvl_signal_handler_result[0] == Qfalse) raise_error(rb_eRuntimeError, "Could not signal background_thread");
 
   VALUE result = rb_hash_new();
   rb_hash_aset(result, ID2SYM(rb_intern("ruby_thread_has_gvl_p")), holding_the_gvl_signal_handler_result[1]);

data/ext/datadog_profiling_native_extension/ruby_helpers.c

@@ -21,74 +21,85 @@ void ruby_helpers_init(void) {
   to_s_id = rb_intern("to_s");
 }
 
-#define MAX_RAISE_MESSAGE_SIZE 256
+// Internal helper for raising pre-formatted syserr exceptions
+static NORETURN(void private_raise_syserr_formatted(int syserr_errno, const char *detailed_message, const char *static_message)) {
+  VALUE exception = rb_syserr_new(syserr_errno, detailed_message);
+  private_raise_exception(exception, static_message);
+}
+
+// Use `raise_syserr` the macro instead, as it provides additional argument checks.
+void private_raise_syserr(int syserr_errno, const char *fmt, ...) {
+  FORMAT_VA_ERROR_MESSAGE(detailed_message, fmt);
+  private_raise_syserr_formatted(syserr_errno, detailed_message, fmt);
+}
 
 typedef struct {
   VALUE exception_class;
+  int syserr_errno;
   char exception_message[MAX_RAISE_MESSAGE_SIZE];
+  char telemetry_message[MAX_RAISE_MESSAGE_SIZE];
 } raise_args;
 
 static void *trigger_raise(void *raise_arguments) {
   raise_args *args = (raise_args *) raise_arguments;
-  rb_raise(args->exception_class, "%s", args->exception_message);
-}
-
-void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...) {
-  raise_args args;
 
-  args.exception_class = exception_class;
-
-  va_list format_string_arguments;
-  va_start(format_string_arguments, format_string);
-  vsnprintf(args.exception_message, MAX_RAISE_MESSAGE_SIZE, format_string, format_string_arguments);
-
-  if (is_current_thread_holding_the_gvl()) {
-    rb_raise(
-      rb_eRuntimeError,
-      "grab_gvl_and_raise called by thread holding the global VM lock. exception_message: '%s'",
-      args.exception_message
+  if (args->syserr_errno) {
+    private_raise_syserr_formatted(
+      args->syserr_errno,
+      args->exception_message,
+      args->telemetry_message
+    );
+  } else {
+    private_raise_error_formatted(
+      args->exception_class,
+      args->exception_message,
+      args->telemetry_message
     );
   }
 
-  rb_thread_call_with_gvl(trigger_raise, &args);
-
-  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise while raising '%s'\n", args.exception_message);
-}
-
-typedef struct {
-  int syserr_errno;
-  char exception_message[MAX_RAISE_MESSAGE_SIZE];
-} syserr_raise_args;
-
-static void *trigger_syserr_raise(void *syserr_raise_arguments) {
-  syserr_raise_args *args = (syserr_raise_args *) syserr_raise_arguments;
-  rb_syserr_fail(args->syserr_errno, args->exception_message);
+  return NULL;
 }
 
-void grab_gvl_and_raise_syserr(int syserr_errno, const char *format_string, ...) {
-  syserr_raise_args args;
+void private_grab_gvl_and_raise(VALUE exception_class, int syserr_errno, const char *format_string, ...) {
+  raise_args args;
 
-  args.syserr_errno = syserr_errno;
+  if (syserr_errno != 0) {
+    args.exception_class = Qnil;
+    args.syserr_errno = syserr_errno;
+  } else {
+    args.exception_class = exception_class;
+    args.syserr_errno = 0;
+  }
 
-  va_list format_string_arguments;
-  va_start(format_string_arguments, format_string);
-  vsnprintf(args.exception_message, MAX_RAISE_MESSAGE_SIZE, format_string, format_string_arguments);
+  FORMAT_VA_ERROR_MESSAGE(formatted_exception_message, format_string);
+  snprintf(args.exception_message, MAX_RAISE_MESSAGE_SIZE, "%s", formatted_exception_message);
+  snprintf(args.telemetry_message, MAX_RAISE_MESSAGE_SIZE, "%s", format_string);
 
   if (is_current_thread_holding_the_gvl()) {
-    rb_raise(
-      rb_eRuntimeError,
-      "grab_gvl_and_raise_syserr called by thread holding the global VM lock. syserr_errno: %d, exception_message: '%s'",
-      syserr_errno,
+    char telemetry_message[MAX_RAISE_MESSAGE_SIZE];
+    snprintf(
+      telemetry_message,
+      MAX_RAISE_MESSAGE_SIZE,
+      "grab_gvl_and_raise called by thread holding the global VM lock: %s",
+      format_string
+    );
+    char exception_message[MAX_RAISE_MESSAGE_SIZE];
+    snprintf(
+      exception_message,
+      MAX_RAISE_MESSAGE_SIZE,
+      "grab_gvl_and_raise called by thread holding the global VM lock: %s",
       args.exception_message
     );
+    VALUE exception = rb_exc_new_cstr(rb_eRuntimeError, exception_message);
+    private_raise_exception(exception, telemetry_message);
   }
 
-  rb_thread_call_with_gvl(trigger_syserr_raise, &args);
+  rb_thread_call_with_gvl(trigger_raise, &args);
 
-  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise_syserr while raising '%s'\n", args.exception_message);
+  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise while raising '%s'\n", args.exception_message);
 }
 
-void raise_syserr(
+void private_raise_enforce_syserr(
   int syserr_errno,
   bool have_gvl,
   const char *expression,
@@ -99,7 +110,7 @@ void raise_syserr(
   if (have_gvl) {
     rb_exc_raise(rb_syserr_new_str(syserr_errno, rb_sprintf("Failure returned by '%s' at %s:%d:in `%s'", expression, file, line, function_name)));
   } else {
-    grab_gvl_and_raise_syserr(syserr_errno, "Failure returned by '%s' at %s:%d:in `%s'", expression, file, line, function_name);
+    private_grab_gvl_and_raise(Qnil, syserr_errno, "Failure returned by '%s' at %s:%d:in `%s'", expression, file, line, function_name);
   }
 }
 

data/ext/datadog_profiling_native_extension/ruby_helpers.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <stdbool.h>
+#include <stdarg.h>
 #include "datadog_ruby_common.h"
 
 // Initialize internal data needed by some ruby helpers. Should be called during start, before any actual
@@ -39,26 +40,37 @@ static inline int check_if_pending_exception(void) {
 
 #define VALUE_COUNT(array) (sizeof(array) / sizeof(VALUE))
 
+// Raises a SysErr exception with the formatted string as its message.
+// See `raise_error` for details about telemetry messages.
+#define raise_syserr(syserr_errno, fmt, ...) \
+  private_raise_syserr(syserr_errno, "" fmt, ##__VA_ARGS__)
+
+#define grab_gvl_and_raise(exception_class, fmt, ...) \
+  private_grab_gvl_and_raise(exception_class, 0, "" fmt, ##__VA_ARGS__)
+
 NORETURN(
-  void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...)
+  void private_raise_syserr(int syserr_errno, const char *fmt, ...)
   __attribute__ ((format (printf, 2, 3)));
 );
+
 NORETURN(
-  void grab_gvl_and_raise_syserr(int syserr_errno, const char *format_string, ...)
-  __attribute__ ((format (printf, 2, 3)));
+  void private_grab_gvl_and_raise(VALUE exception_class, int syserr_errno, const char *format_string, ...)
+  __attribute__ ((format (printf, 3, 4)));
 );
 
+
+
 #define ENFORCE_SUCCESS_GVL(expression) ENFORCE_SUCCESS_HELPER(expression, true)
 #define ENFORCE_SUCCESS_NO_GVL(expression) ENFORCE_SUCCESS_HELPER(expression, false)
 
 #define ENFORCE_SUCCESS_HELPER(expression, have_gvl) \
-  { int result_syserr_errno = expression; if (RB_UNLIKELY(result_syserr_errno)) raise_syserr(result_syserr_errno, have_gvl, ADD_QUOTES(expression), __FILE__, __LINE__, __func__); }
+  { int result_syserr_errno = expression; if (RB_UNLIKELY(result_syserr_errno)) private_raise_enforce_syserr(result_syserr_errno, have_gvl, ADD_QUOTES(expression), __FILE__, __LINE__, __func__); }
 
 #define RUBY_NUM_OR_NIL(val, condition, conv) ((val condition) ? conv(val) : Qnil)
 #define RUBY_AVG_OR_NIL(total, count) ((count == 0) ? Qnil : DBL2NUM(((double) total) / count))
 
 // Called by ENFORCE_SUCCESS_HELPER; should not be used directly
-NORETURN(void raise_syserr(
+NORETURN(void private_raise_enforce_syserr(
   int syserr_errno,
   bool have_gvl,
   const char *expression,