datadog 2.29.0 → 2.31.0

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");
 

data/ext/datadog_profiling_native_extension/setup_signal_handler.c

@@ -9,26 +9,30 @@
 
 // Used by Collectors::CpuAndWallTimeWorker to setup SIGPROF signal handlers used for cpu/wall-time profiling.
 
+static VALUE existing_signal_handler_exception_class = Qnil;
+
 static void install_sigprof_signal_handler_internal(
   void (*signal_handler_function)(int, siginfo_t *, void *),
   const char *handler_pretty_name,
-  void (*signal_handler_to_replace)(int, siginfo_t *, void *)
+  void (*signal_handler_to_replace)(int, siginfo_t *, void *),
+  bool should_raise_on_failure
 );
 
 void empty_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext) { }
 
 void install_sigprof_signal_handler(void (*signal_handler_function)(int, siginfo_t *, void *), const char *handler_pretty_name) {
-  install_sigprof_signal_handler_internal(signal_handler_function, handler_pretty_name, NULL);
+  install_sigprof_signal_handler_internal(signal_handler_function, handler_pretty_name, NULL, true);
 }
 
-void replace_sigprof_signal_handler_with_empty_handler(void (*expected_existing_handler)(int, siginfo_t *, void *)) {
-  install_sigprof_signal_handler_internal(empty_signal_handler, "empty_signal_handler", expected_existing_handler);
+void replace_sigprof_signal_handler_with_empty_handler(void (*expected_existing_handler)(int, siginfo_t *, void *), bool should_raise_on_failure) {
+  install_sigprof_signal_handler_internal(empty_signal_handler, "empty_signal_handler", expected_existing_handler, should_raise_on_failure);
 }
 
 static void install_sigprof_signal_handler_internal(
   void (*signal_handler_function)(int, siginfo_t *, void *),
   const char *handler_pretty_name,
-  void (*signal_handler_to_replace)(int, siginfo_t *, void *)
+  void (*signal_handler_to_replace)(int, siginfo_t *, void *),
+  bool should_raise_on_failure
 ) {
   struct sigaction existing_signal_handler_config = {.sa_sigaction = NULL};
   struct sigaction signal_handler_config = {
@@ -52,8 +56,7 @@ static void install_sigprof_signal_handler_internal(
   ) { return; }
 
   if (existing_signal_handler_config.sa_handler != NULL || existing_signal_handler_config.sa_sigaction != NULL) {
-    // An unexpected/unknown signal handler already existed. Currently we don't support this situation, so let's just back out
-    // of the installation.
+    // An unexpected/unknown signal handler already existed.
 
     if (sigaction(SIGPROF, &existing_signal_handler_config, NULL) != 0) {
       rb_exc_raise(
@@ -71,8 +74,12 @@ static void install_sigprof_signal_handler_internal(
       );
     }
 
+    // If should_raise_on_failure is false (e.g., during cleanup), just return silently.
+    // This can happen if we failed to install our handler earlier due to a pre-existing handler.
+    if (!should_raise_on_failure) return;
+
     raise_error(
-      rb_eRuntimeError,
+      existing_signal_handler_exception_class,
       "Could not install profiling signal handler (%s): There's a pre-existing SIGPROF signal handler",
       handler_pretty_name
     );
@@ -119,3 +126,12 @@ VALUE is_sigprof_blocked_in_current_thread(void) {
   ENFORCE_SUCCESS_GVL(pthread_sigmask(0, NULL, &current_signals));
   return sigismember(&current_signals, SIGPROF) ? Qtrue : Qfalse;
 }
+
+void setup_signal_handler_init(VALUE profiling_module) {
+  existing_signal_handler_exception_class = rb_define_class_under(
+    profiling_module,
+    "ExistingSignalHandler",
+    rb_eRuntimeError
+  );
+  rb_gc_register_mark_object(existing_signal_handler_exception_class);
+}

data/ext/datadog_profiling_native_extension/setup_signal_handler.h

@@ -3,12 +3,10 @@
 #include <signal.h>
 #include "datadog_ruby_common.h"
 
-
-
 void empty_signal_handler(DDTRACE_UNUSED int _signal, DDTRACE_UNUSED siginfo_t *_info, DDTRACE_UNUSED void *_ucontext);
 
 void install_sigprof_signal_handler(void (*signal_handler_function)(int, siginfo_t *, void *), const char *handler_pretty_name);
-void replace_sigprof_signal_handler_with_empty_handler(void (*expected_existing_handler)(int, siginfo_t *, void *));
+void replace_sigprof_signal_handler_with_empty_handler(void (*expected_existing_handler)(int, siginfo_t *, void *), bool should_raise_on_failure);
 void remove_sigprof_signal_handler(void);
 void block_sigprof_signal_handler_from_running_in_current_thread(void);
 void unblock_sigprof_signal_handler_from_running_in_current_thread(void);

data/ext/datadog_profiling_native_extension/stack_recorder.c

@@ -131,46 +131,32 @@
 static VALUE ok_symbol = Qnil; // :ok in Ruby
 static VALUE error_symbol = Qnil; // :error in Ruby
 
-// Note: Please DO NOT use `VALUE_STRING` anywhere else, instead use `DDOG_CHARSLICE_C`.
-// `VALUE_STRING` is only needed because older versions of gcc (4.9.2, used in our Ruby 2.2 CI test images)
-// tripped when compiling `enabled_value_types` using `-std=gnu99` due to the extra cast that is included in
-// `DDOG_CHARSLICE_C` with the following error:
-//
-// ```
-// compiling ../../../../ext/ddtrace_profiling_native_extension/stack_recorder.c
-// ../../../../ext/ddtrace_profiling_native_extension/stack_recorder.c:23:1: error: initializer element is not constant
-// static const ddog_prof_ValueType enabled_value_types[] = {CPU_TIME_VALUE, CPU_SAMPLES_VALUE, WALL_TIME_VALUE};
-// ^
-// ```
-#define VALUE_STRING(string) {.ptr = "" string, .len = sizeof(string) - 1}
-
-#define CPU_TIME_VALUE          {.type_ = VALUE_STRING("cpu-time"),          .unit = VALUE_STRING("nanoseconds")}
 #define CPU_TIME_VALUE_ID 0
-#define CPU_SAMPLES_VALUE       {.type_ = VALUE_STRING("cpu-samples"),       .unit = VALUE_STRING("count")}
 #define CPU_SAMPLES_VALUE_ID 1
-#define WALL_TIME_VALUE         {.type_ = VALUE_STRING("wall-time"),         .unit = VALUE_STRING("nanoseconds")}
 #define WALL_TIME_VALUE_ID 2
-#define ALLOC_SAMPLES_VALUE     {.type_ = VALUE_STRING("alloc-samples"),     .unit = VALUE_STRING("count")}
 #define ALLOC_SAMPLES_VALUE_ID 3
-#define ALLOC_SAMPLES_UNSCALED_VALUE {.type_ = VALUE_STRING("alloc-samples-unscaled"), .unit = VALUE_STRING("count")}
 #define ALLOC_SAMPLES_UNSCALED_VALUE_ID 4
-#define HEAP_SAMPLES_VALUE      {.type_ = VALUE_STRING("heap-live-samples"), .unit = VALUE_STRING("count")}
 #define HEAP_SAMPLES_VALUE_ID 5
-#define HEAP_SIZE_VALUE         {.type_ = VALUE_STRING("heap-live-size"),    .unit = VALUE_STRING("bytes")}
 #define HEAP_SIZE_VALUE_ID 6
-#define TIMELINE_VALUE          {.type_ = VALUE_STRING("timeline"),          .unit = VALUE_STRING("nanoseconds")}
 #define TIMELINE_VALUE_ID 7
 
-static const ddog_prof_ValueType all_value_types[] =
-  {CPU_TIME_VALUE, CPU_SAMPLES_VALUE, WALL_TIME_VALUE, ALLOC_SAMPLES_VALUE, ALLOC_SAMPLES_UNSCALED_VALUE, HEAP_SAMPLES_VALUE, HEAP_SIZE_VALUE, TIMELINE_VALUE};
+static const ddog_prof_SampleType all_sample_types[] = {
+  DDOG_PROF_SAMPLE_TYPE_CPU_TIME,
+  DDOG_PROF_SAMPLE_TYPE_CPU_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_WALL_TIME,
+  DDOG_PROF_SAMPLE_TYPE_ALLOC_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_ALLOC_SAMPLES_UNSCALED,
+  DDOG_PROF_SAMPLE_TYPE_HEAP_LIVE_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_HEAP_LIVE_SIZE,
+  DDOG_PROF_SAMPLE_TYPE_TIMELINE,
+};
 
-// This array MUST be kept in sync with all_value_types above and is intended to act as a "hashmap" between VALUE_ID and the position it
-// occupies on the all_value_types array.
-// E.g. all_value_types_positions[CPU_TIME_VALUE_ID] => 0, means that CPU_TIME_VALUE was declared at position 0 of all_value_types.
+// This array MUST be kept in sync with all_sample_types above and is intended to act as a "hashmap" between VALUE_ID and the position it
+// occupies on the all_sample_types array.
 static const uint8_t all_value_types_positions[] =
   {CPU_TIME_VALUE_ID, CPU_SAMPLES_VALUE_ID, WALL_TIME_VALUE_ID, ALLOC_SAMPLES_VALUE_ID, ALLOC_SAMPLES_UNSCALED_VALUE_ID, HEAP_SAMPLES_VALUE_ID, HEAP_SIZE_VALUE_ID, TIMELINE_VALUE_ID};
 
-#define ALL_VALUE_TYPES_COUNT (sizeof(all_value_types) / sizeof(ddog_prof_ValueType))
+#define ALL_VALUE_TYPES_COUNT (sizeof(all_sample_types) / sizeof(ddog_prof_SampleType))
 
 // Struct for storing stats related to a profile in a particular slot.
 // These stats will share the same lifetime as the data in that profile slot.
@@ -242,8 +228,8 @@ typedef struct {
 
 static VALUE _native_new(VALUE klass);
 static void initialize_slot_concurrency_control(stack_recorder_state *state);
-static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_ValueType sample_types);
 static void stack_recorder_typed_data_mark(void *data);
+static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_SampleType sample_types);
 static void stack_recorder_typed_data_free(void *data);
 static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self);
 static VALUE _native_serialize(VALUE self, VALUE recorder_instance);
@@ -335,7 +321,7 @@ static VALUE _native_new(VALUE klass) {
 
   state->heap_clean_after_gc_enabled = false;
 
-  ddog_prof_Slice_ValueType sample_types = {.ptr = all_value_types, .len = ALL_VALUE_TYPES_COUNT};
+  ddog_prof_Slice_SampleType sample_types = {.ptr = all_sample_types, .len = ALL_VALUE_TYPES_COUNT};
 
   initialize_slot_concurrency_control(state);
   for (uint8_t i = 0; i < ALL_VALUE_TYPES_COUNT; i++) { state->position_for[i] = all_value_types_positions[i]; }
@@ -379,7 +365,7 @@ static void initialize_slot_concurrency_control(stack_recorder_state *state) {
   state->active_slot = 1;
 }
 
-static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_ValueType sample_types) {
+static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_SampleType sample_types) {
   ddog_Timespec start_timestamp = system_epoch_now_timespec();
 
   ddog_prof_Profile_NewResult slot_one_profile_result =
@@ -468,30 +454,30 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
 
   state->enabled_values_count = requested_values_count;
 
-  ddog_prof_ValueType enabled_value_types[ALL_VALUE_TYPES_COUNT];
+  ddog_prof_SampleType enabled_sample_types[ALL_VALUE_TYPES_COUNT];
   uint8_t next_enabled_pos = 0;
   uint8_t next_disabled_pos = requested_values_count;
 
-  // CPU_SAMPLES_VALUE is always enabled
-  enabled_value_types[next_enabled_pos] = (ddog_prof_ValueType) CPU_SAMPLES_VALUE;
+  // CPU_SAMPLES is always enabled
+  enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_CPU_SAMPLES;
   state->position_for[CPU_SAMPLES_VALUE_ID] = next_enabled_pos++;
 
-  // WALL_TIME_VALUE is always enabled
-  enabled_value_types[next_enabled_pos] = (ddog_prof_ValueType) WALL_TIME_VALUE;
+  // WALL_TIME is always enabled
+  enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_WALL_TIME;
   state->position_for[WALL_TIME_VALUE_ID] = next_enabled_pos++;
 
   if (cpu_time_enabled == Qtrue) {
-    enabled_value_types[next_enabled_pos] = (ddog_prof_ValueType) CPU_TIME_VALUE;
+    enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_CPU_TIME;
     state->position_for[CPU_TIME_VALUE_ID] = next_enabled_pos++;
   } else {
     state->position_for[CPU_TIME_VALUE_ID] = next_disabled_pos++;
   }
 
   if (alloc_samples_enabled == Qtrue) {
-    enabled_value_types[next_enabled_pos] = (ddog_prof_ValueType) ALLOC_SAMPLES_VALUE;
+    enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_ALLOC_SAMPLES;
     state->position_for[ALLOC_SAMPLES_VALUE_ID] = next_enabled_pos++;
 
-    enabled_value_types[next_enabled_pos] = (ddog_prof_ValueType) ALLOC_SAMPLES_UNSCALED_VALUE;
+    enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_ALLOC_SAMPLES_UNSCALED;
     state->position_for[ALLOC_SAMPLES_UNSCALED_VALUE_ID] = next_enabled_pos++;
   } else {
     state->position_for[ALLOC_SAMPLES_VALUE_ID] = next_disabled_pos++;
@@ -499,14 +485,14 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   }
 
   if (heap_samples_enabled == Qtrue) {
-    enabled_value_types[next_enabled_pos] = (ddog_prof_ValueType) HEAP_SAMPLES_VALUE;
+    enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_HEAP_LIVE_SAMPLES;
     state->position_for[HEAP_SAMPLES_VALUE_ID] = next_enabled_pos++;
   } else {
     state->position_for[HEAP_SAMPLES_VALUE_ID] = next_disabled_pos++;
   }
 
   if (heap_size_enabled == Qtrue) {
-    enabled_value_types[next_enabled_pos] = (ddog_prof_ValueType) HEAP_SIZE_VALUE;
+    enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_HEAP_LIVE_SIZE;
     state->position_for[HEAP_SIZE_VALUE_ID] = next_enabled_pos++;
   } else {
     state->position_for[HEAP_SIZE_VALUE_ID] = next_disabled_pos++;
@@ -521,7 +507,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   }
 
   if (timeline_enabled == Qtrue) {
-    enabled_value_types[next_enabled_pos] = (ddog_prof_ValueType) TIMELINE_VALUE;
+    enabled_sample_types[next_enabled_pos] = DDOG_PROF_SAMPLE_TYPE_TIMELINE;
     state->position_for[TIMELINE_VALUE_ID] = next_enabled_pos++;
   } else {
     state->position_for[TIMELINE_VALUE_ID] = next_disabled_pos++;
@@ -530,7 +516,7 @@ static VALUE _native_initialize(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _sel
   ddog_prof_Profile_drop(&state->profile_slot_one.profile);
   ddog_prof_Profile_drop(&state->profile_slot_two.profile);
 
-  ddog_prof_Slice_ValueType sample_types = {.ptr = enabled_value_types, .len = state->enabled_values_count};
+  ddog_prof_Slice_SampleType sample_types = {.ptr = enabled_sample_types, .len = state->enabled_values_count};
   initialize_profiles(state, sample_types);
 
   return Qtrue;
@@ -1079,7 +1065,7 @@ static VALUE _native_test_managed_string_storage_produces_valid_profiles(DDTRACE
     raise_error(rb_eRuntimeError, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));
   }
 
-  ddog_prof_Slice_ValueType sample_types = {.ptr = all_value_types, .len = ALL_VALUE_TYPES_COUNT};
+  ddog_prof_Slice_SampleType sample_types = {.ptr = all_sample_types, .len = ALL_VALUE_TYPES_COUNT};
   ddog_prof_Profile_NewResult profile = ddog_prof_Profile_with_string_storage(sample_types, NULL, string_storage.ok);
 
   if (profile.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {

data/ext/libdatadog_api/crashtracker.c

@@ -51,12 +51,8 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
 
   VALUE version = datadog_gem_version();
 
-  // Tags and endpoint are heap-allocated, so after here we can't raise exceptions otherwise we'll leak this memory
+  // Tags are heap-allocated, so after here we can't raise exceptions otherwise we'll leak this memory
   // Start of exception-free zone to prevent leaks {{
-  ddog_Endpoint *endpoint = ddog_endpoint_from_url(char_slice_from_ruby_string(agent_base_url));
-  if (endpoint == NULL) {
-    raise_error(rb_eRuntimeError, "Failed to create endpoint from agent_base_url: %"PRIsVALUE, agent_base_url);
-  }
   ddog_Vec_Tag tags = convert_tags(tags_as_array);
 
   ddog_crasht_Config config = {
@@ -73,7 +69,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
     // overriding what Ruby set up seems a saner default to keep anyway.
     .create_alt_stack = false,
     .use_alt_stack = true,
-    .endpoint = endpoint,
+    .endpoint = {.url = char_slice_from_ruby_string(agent_base_url)},
     .resolve_frames = DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
     .timeout_ms = FIX2INT(upload_timeout_seconds) * 1000,
   };
@@ -106,11 +102,12 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
       ) :
       ddog_crasht_update_on_fork(config, receiver_config, metadata);
 
-  first_init = false;
+  // We use first_init to know which of [init, reconfigure] needs to be called. BUT if init failed we actually need
+  // to call init next time again, not reconfigure.
+  if (result.tag == DDOG_VOID_RESULT_OK) first_init = false;
 
   // Clean up before potentially raising any exceptions
   ddog_Vec_Tag_drop(tags);
-  ddog_endpoint_drop(endpoint);
   // }} End of exception-free zone to prevent leaks
 
   CHECK_VOID_RESULT("Failed to start/update the crash tracker", result);

data/ext/libdatadog_api/crashtracker_report_exception.c

@@ -1,53 +1,57 @@
 #include <datadog/common.h>
 #include <datadog/crashtracker.h>
 #include <ruby.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <string.h>
 
 #include "datadog_ruby_common.h"
 
-static VALUE _native_report_ruby_exception(VALUE _self, VALUE agent_base_url,
-                                          VALUE message, VALUE frames_data,
-                                          VALUE tags_as_array, VALUE library_version);
+static VALUE _native_report_ruby_exception(VALUE _self, VALUE exception_type,
+                                          VALUE message, VALUE frames_data);
 
 static bool process_crash_frames(VALUE frames_data, ddog_crasht_Handle_StackTrace *stack_trace);
-static bool build_and_send_crash_report(ddog_crasht_Metadata metadata,
-                                        ddog_Endpoint *endpoint,
-                                        VALUE message,
-                                        VALUE frames_data);
 
 void crashtracker_report_exception_init(VALUE crashtracker_class) {
   rb_define_singleton_method(crashtracker_class, "_native_report_ruby_exception",
-                            _native_report_ruby_exception, 5);
+                            _native_report_ruby_exception, 3);
 }
 
-static VALUE _native_report_ruby_exception(DDTRACE_UNUSED VALUE _self, VALUE agent_base_url,
-                                          VALUE message, VALUE frames_data,
-                                          VALUE tags_as_array, VALUE library_version) {
-  ENFORCE_TYPE(agent_base_url, T_STRING);
+static VALUE _native_report_ruby_exception(DDTRACE_UNUSED VALUE _self, VALUE exception_type,
+                                          VALUE message, VALUE frames_data) {
+  ENFORCE_TYPE(exception_type, T_STRING);
   ENFORCE_TYPE(message, T_STRING);
   ENFORCE_TYPE(frames_data, T_ARRAY);
-  ENFORCE_TYPE(tags_as_array, T_ARRAY);
-  ENFORCE_TYPE(library_version, T_STRING);
 
-  ddog_Endpoint *endpoint = ddog_endpoint_from_url(char_slice_from_ruby_string(agent_base_url));
-  if (!endpoint) return Qfalse;
+  // Build stack trace
+  ddog_crasht_StackTrace_NewResult stack_result = ddog_crasht_StackTrace_new();
+  if (stack_result.tag != DDOG_CRASHT_STACK_TRACE_NEW_RESULT_OK) {
+    ddog_Error_drop(&stack_result.err);
+    return Qfalse;
+  }
 
-  ddog_Vec_Tag tags = convert_tags(tags_as_array);
+  ddog_crasht_Handle_StackTrace *stack_trace = &stack_result.ok;
+
+  bool frames_ok = process_crash_frames(frames_data, stack_trace);
+  if (frames_ok) {
+    ddog_VoidResult complete_result = ddog_crasht_StackTrace_set_complete(stack_trace);
+    if (complete_result.tag != DDOG_VOID_RESULT_OK) {
+      ddog_crasht_StackTrace_drop(stack_trace);
+      ddog_Error_drop(&complete_result.err);
+      return Qfalse;
+    }
+  }
 
-  ddog_crasht_Metadata metadata = {
-    .library_name = DDOG_CHARSLICE_C("dd-trace-rb"),
-    .library_version = char_slice_from_ruby_string(library_version),
-    .family = DDOG_CHARSLICE_C("ruby"),
-    .tags = &tags,
-  };
+  // ddog_crasht_report_unhandled_exception takes ownership of stack_trace
+  ddog_VoidResult result = ddog_crasht_report_unhandled_exception(
+    char_slice_from_ruby_string(exception_type),
+    char_slice_from_ruby_string(message),
+    stack_trace
+  );
 
-  bool success = build_and_send_crash_report(metadata, endpoint, message, frames_data);
-  ddog_Vec_Tag_drop(tags);
-  ddog_endpoint_drop(endpoint);
+  if (result.tag != DDOG_VOID_RESULT_OK) {
+    ddog_Error_drop(&result.err);
+    return Qfalse;
+  }
 
-  return success ? Qtrue : Qfalse;
+  return Qtrue;
 }
 
 static bool process_crash_frames(VALUE frames_data, ddog_crasht_Handle_StackTrace *stack_trace) {
@@ -120,117 +124,3 @@ static bool process_crash_frames(VALUE frames_data, ddog_crasht_Handle_StackTrac
 
   return true;
 }
-
-static bool build_and_send_crash_report(ddog_crasht_Metadata metadata,
-                                        ddog_Endpoint *endpoint,
-                                        VALUE message,
-                                        VALUE frames_data) {
-  ddog_crasht_Handle_StackTrace *stack_trace = NULL;
-
-  ddog_crasht_CrashInfoBuilder_NewResult builder_result = ddog_crasht_CrashInfoBuilder_new();
-  if (builder_result.tag != DDOG_CRASHT_CRASH_INFO_BUILDER_NEW_RESULT_OK) {
-    ddog_Error_drop(&builder_result.err);
-    return false;
-  }
-
-  ddog_crasht_Handle_CrashInfoBuilder *builder = &builder_result.ok;
-
-  // Setup builder metadata and configuration
-  ddog_VoidResult metadata_result = ddog_crasht_CrashInfoBuilder_with_metadata(builder, metadata);
-  if (metadata_result.tag != DDOG_VOID_RESULT_OK) {
-    ddog_crasht_CrashInfoBuilder_drop(builder);
-    ddog_Error_drop(&metadata_result.err);
-    return false;
-  }
-
-  ddog_VoidResult kind_result = ddog_crasht_CrashInfoBuilder_with_kind(builder, DDOG_CRASHT_ERROR_KIND_UNHANDLED_EXCEPTION);
-  if (kind_result.tag != DDOG_VOID_RESULT_OK) {
-    ddog_crasht_CrashInfoBuilder_drop(builder);
-    ddog_Error_drop(&kind_result.err);
-    return false;
-  }
-
-  // Send ping first
-  ddog_VoidResult ping_result = ddog_crasht_CrashInfoBuilder_upload_ping_to_endpoint(builder, endpoint);
-  if (ping_result.tag != DDOG_VOID_RESULT_OK) {
-    ddog_crasht_CrashInfoBuilder_drop(builder);
-    ddog_Error_drop(&ping_result.err);
-    return false;
-  }
-
-  ddog_crasht_ProcInfo proc_info = { .pid = (uint32_t)getpid() };
-  ddog_VoidResult proc_info_result = ddog_crasht_CrashInfoBuilder_with_proc_info(builder, proc_info);
-  if (proc_info_result.tag != DDOG_VOID_RESULT_OK) {
-    ddog_crasht_CrashInfoBuilder_drop(builder);
-    ddog_Error_drop(&proc_info_result.err);
-    return false;
-  }
-
-  ddog_VoidResult os_info_result = ddog_crasht_CrashInfoBuilder_with_os_info_this_machine(builder);
-  if (os_info_result.tag != DDOG_VOID_RESULT_OK) {
-    ddog_crasht_CrashInfoBuilder_drop(builder);
-    ddog_Error_drop(&os_info_result.err);
-    return false;
-  }
-
-  ddog_VoidResult message_result = ddog_crasht_CrashInfoBuilder_with_message(builder, char_slice_from_ruby_string(message));
-  if (message_result.tag != DDOG_VOID_RESULT_OK) {
-    ddog_crasht_CrashInfoBuilder_drop(builder);
-    ddog_Error_drop(&message_result.err);
-    return false;
-  }
-
-  // Create and populate stack trace
-  ddog_crasht_StackTrace_NewResult stack_result = ddog_crasht_StackTrace_new();
-  if (stack_result.tag != DDOG_CRASHT_STACK_TRACE_NEW_RESULT_OK) {
-    ddog_crasht_CrashInfoBuilder_drop(builder);
-    ddog_Error_drop(&stack_result.err);
-    return false;
-  }
-
-  stack_trace = &stack_result.ok;
-
-  bool frames_processed_successfully = process_crash_frames(frames_data, stack_trace);
-
-  // Only mark as complete if we successfully processed all frames
-  if (frames_processed_successfully) {
-    ddog_VoidResult complete_result = ddog_crasht_StackTrace_set_complete(stack_trace);
-    if (complete_result.tag != DDOG_VOID_RESULT_OK) {
-      ddog_crasht_StackTrace_drop(stack_trace);
-      ddog_crasht_CrashInfoBuilder_drop(builder);
-      ddog_Error_drop(&complete_result.err);
-      return false;
-    }
-  }
-  // If frames processing failed, we still include the stack trace (which may be empty or partial)
-  // but don't mark it as complete, indicating it's incomplete
-
-  ddog_VoidResult with_stack_result = ddog_crasht_CrashInfoBuilder_with_stack(builder, stack_trace);
-  if (with_stack_result.tag != DDOG_VOID_RESULT_OK) {
-    ddog_crasht_StackTrace_drop(stack_trace);
-    ddog_crasht_CrashInfoBuilder_drop(builder);
-    ddog_Error_drop(&with_stack_result.err);
-    return false;
-  }
-
-  // Builder takes ownership of stack_trace, so we don't need to clean it up anymore
-  stack_trace = NULL;
-
-  // Build and upload crash info
-  ddog_crasht_CrashInfo_NewResult crash_info_result = ddog_crasht_CrashInfoBuilder_build(builder);
-  if (crash_info_result.tag != DDOG_CRASHT_RESULT_HANDLE_CRASH_INFO_OK_HANDLE_CRASH_INFO) {
-    ddog_crasht_CrashInfoBuilder_drop(builder);
-    ddog_Error_drop(&crash_info_result.err);
-    return false;
-  }
-
-  ddog_crasht_Handle_CrashInfo *crash_info = &crash_info_result.ok;
-  ddog_VoidResult upload_result = ddog_crasht_CrashInfo_upload_to_endpoint(crash_info, endpoint);
-  bool success = (upload_result.tag == DDOG_VOID_RESULT_OK);
-  if (!success) {
-    ddog_Error_drop(&upload_result.err);
-  }
-
-  ddog_crasht_CrashInfo_drop(crash_info);
-  return success;
-}

data/ext/libdatadog_api/datadog_ruby_common.c

@@ -122,6 +122,24 @@ size_t read_ddogerr_string_and_drop(ddog_Error *error, char *string, size_t capa
   return error_msg_size;
 }
 
+static void verify_libdatadog_version(void) {
+  rb_eval_string(
+    "require 'libdatadog';"
+    "expected = '" EXPECTED_LIBDATADOG_VERSION "';"
+    "if expected != Libdatadog::VERSION;"
+      "raise(LoadError, <<MSG\n"
+        "The `datadog` gem needs to be reinstalled whenever the `libdatadog` gem version is changed. "
+        "The currently-installed version of `datadog` was built to work with `libdatadog` gem version #{expected} "
+        "but the currently-loaded version of `libdatadog` is #{Libdatadog::VERSION}. "
+        "To fix this, reinstall the `datadog` gem (e.g. `bundle exec gem pristine datadog`) "
+        "or contact Datadog support for help at <https://docs.datadoghq.com/help/>.\n"
+        "MSG\n"
+      ");"
+    "end"
+  );
+}
+
 void datadog_ruby_common_init(void) {
   telemetry_message_id = rb_intern("@telemetry_message");
+  verify_libdatadog_version();
 }

data/ext/libdatadog_api/datadog_ruby_common.h

@@ -102,3 +102,13 @@ static inline VALUE get_error_details_and_drop(ddog_Error *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);
+
+#define IMEMO_MASK 0x0f
+
+// Returns the imemo type of an imemo object.
+// This mask is the same between Ruby 2.5 and 3.3-preview3. Furthermore, the intention of this method is to be used
+// to call `rb_imemo_name` which correctly handles invalid numbers so even if the mask changes in the future, at most
+// we'll get incorrect results (and never a VM crash)
+static inline int ddtrace_imemo_type(VALUE imemo) {
+  return (RBASIC(imemo)->flags >> FL_USHIFT) & IMEMO_MASK;
+}

data/ext/libdatadog_api/di.c

@@ -0,0 +1,79 @@
+#include <stdbool.h>
+
+#include "datadog_ruby_common.h"
+
+// Prototypes for Ruby functions declared in internal Ruby headers.
+VALUE rb_iseqw_new(const void *iseq);
+int rb_objspace_internal_object_p(VALUE obj);
+void rb_objspace_each_objects(
+    int (*callback)(void *start, void *end, size_t stride, void *data),
+    void *data);
+
+#define IMEMO_TYPE_ISEQ 7
+
+// The ID value of the string "mesg" which is used in Ruby source as
+// id_mesg or idMesg, and is used to set and retrieve the exception message
+// from standard library exception classes like NameError.
+static ID id_mesg;
+
+// Returns whether the argument is an IMEMO of type ISEQ.
+static bool ddtrace_imemo_iseq_p(VALUE v) {
+  return rb_objspace_internal_object_p(v) && RB_TYPE_P(v, T_IMEMO) && ddtrace_imemo_type(v) == IMEMO_TYPE_ISEQ;
+}
+
+static int ddtrace_di_os_obj_of_i(void *vstart, void *vend, size_t stride, void *data)
+{
+  VALUE *array = (VALUE *)data;
+
+  VALUE v = (VALUE)vstart;
+  for (; v != (VALUE)vend; v += stride) {
+    if (ddtrace_imemo_iseq_p(v)) {
+      VALUE iseq = rb_iseqw_new((void *) v);
+      rb_ary_push(*array, iseq);
+    }
+  }
+
+  return 0;
+}
+
+/*
+Returns all RubyVM::InstructionSequence objects existing in the current process.
+
+This uses the same approach as ruby/debug's iseq_collector.c:
+https://github.com/ruby/debug/blob/master/ext/debug/iseq_collector.c
+*/
+static VALUE all_iseqs(DDTRACE_UNUSED VALUE _self) {
+  VALUE array = rb_ary_new();
+  rb_objspace_each_objects(ddtrace_di_os_obj_of_i, &array);
+  return array;
+}
+
+/*
+ * call-seq:
+ *   DI.exception_message(exception) -> String | Object
+ *
+ * Returns the exception message associated with the exception via the
+ * exception's constructor.
+ *
+ * This method does not invoke Ruby code and as such will not call
+ * the +message+ method, if one is defined on the exception object.
+ *
+ * Normally, the exception message is a string, however there is no
+ * type enforcement done by Ruby for the messages and objects of arbitrary
+ * classes can be passed to exception constructors and will, subsequently,
+ * be returned by this method.
+ *
+ * @param exception [Exception] The exception object
+ * @return [String | Object] The exception message
+ */
+static VALUE exception_message(DDTRACE_UNUSED VALUE _self, VALUE exception) {
+  return rb_ivar_get(exception, id_mesg);
+}
+
+void di_init(VALUE datadog_module) {
+  id_mesg = rb_intern("mesg");
+
+  VALUE di_module = rb_define_module_under(datadog_module, "DI");
+  rb_define_singleton_method(di_module, "all_iseqs", all_iseqs, 0);
+  rb_define_singleton_method(di_module, "exception_message", exception_message, 1);
+}