datadog 2.29.0 → 2.30.0

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_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/extconf.rb

@@ -40,7 +40,8 @@ append_cflags '-Werror' if ENV['DATADOG_GEM_CI'] == 'true'
 # * by upstream Ruby -- search for gnu99 in the codebase
 # * by msgpack, another datadog gem dependency
 #   (https://github.com/msgpack/msgpack-ruby/blob/18ce08f6d612fe973843c366ac9a0b74c4e50599/ext/msgpack/extconf.rb#L8)
-append_cflags '-std=gnu99'
+# @ivoanjo: We could probably start using C11/gnu11 for non macOS-too but it's somewhat hard to validate so I chickened out for now
+append_cflags RUBY_PLATFORM.include?('darwin') ? '-std=gnu11' : '-std=gnu99'
 
 # Allow defining variables at any point in a function
 append_cflags '-Wno-declaration-after-statement'
@@ -74,30 +75,12 @@ if ENV['DDTRACE_DEBUG'] == 'true'
 end
 
 # If we got here, libdatadog is available and loaded
-ENV['PKG_CONFIG_PATH'] = "#{ENV["PKG_CONFIG_PATH"]}:#{Libdatadog.pkgconfig_folder}"
-Logging.message("[datadog] PKG_CONFIG_PATH set to #{ENV["PKG_CONFIG_PATH"].inspect}\n")
 $stderr.puts("Using libdatadog #{Libdatadog::VERSION} from #{Libdatadog.pkgconfig_folder}")
 
-unless pkg_config('datadog_profiling_with_rpath')
-  Logging.message("[datadog] Ruby detected the pkg-config command is #{$PKGCONFIG.inspect}\n")
-
-  if Datadog::LibdatadogExtconfHelpers.pkg_config_missing?
-    skip_building_extension!('the `pkg-config` system tool is missing')
-  else
-    skip_building_extension!('there was a problem in setting up the `libdatadog` dependency')
-  end
+unless Datadog::LibdatadogExtconfHelpers.configure_libdatadog(extconf_folder: __dir__)
+  skip_building_extension!('there was a problem in setting up the `libdatadog` dependency')
 end
 
-# See comments on the helper methods being used for why we need to additionally set this.
-# The extremely excessive escaping around ORIGIN below seems to be correct and was determined after a lot of
-# experimentation. We need to get these special characters across a lot of tools untouched...
-extra_relative_rpaths = [
-  Datadog::LibdatadogExtconfHelpers.libdatadog_folder_relative_to_native_lib_folder(current_folder: __dir__),
-  *Datadog::LibdatadogExtconfHelpers.libdatadog_folder_relative_to_ruby_extensions_folders,
-]
-extra_relative_rpaths.each { |folder| $LDFLAGS += " -Wl,-rpath,$$$\\\\{ORIGIN\\}/#{folder.to_str}" }
-Logging.message("[datadog] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
-
 # Tag the native extension library with the Ruby version and Ruby platform.
 # This makes it easier for development (avoids "oops I forgot to rebuild when I switched my Ruby") and ensures that
 # the wrong library is never loaded.

data/ext/libdatadog_extconf_helpers.rb

@@ -10,7 +10,7 @@ module Datadog
   module LibdatadogExtconfHelpers
     # Used to make sure the correct gem version gets loaded, as extconf.rb does not get run with "bundle exec" and thus
     # may see multiple libdatadog versions. See https://github.com/DataDog/dd-trace-rb/pull/2531 for the horror story.
-    LIBDATADOG_VERSION = '~> 25.0.0.1.0'
+    LIBDATADOG_VERSION = '~> 29.0.0.1.0'
 
     # Used as an workaround for a limitation with how dynamic linking works in environments where the datadog gem and
     # libdatadog are moved after the extension gets compiled.
@@ -23,9 +23,9 @@ module Datadog
     # Linux: e.g. `readelf -d datadog_profiling_native_extension.2.7.3_x86_64-linux.so`.
     #
     # In older versions of the datadog gem, we only set as runpath an absolute path to libdatadog.
-    # (This gets set automatically by the call
-    # to `pkg_config('datadog_profiling_with_rpath')` in `extconf.rb`). This worked fine as long as libdatadog was **NOT**
-    # moved from the folder it was present at datadog gem installation/linking time.
+    # (This gets set automatically by the call to `configure_libdatadog` in `extconf.rb`).
+    # This worked fine as long as libdatadog was **NOT** moved from the folder it was present at
+    # datadog gem installation/linking time.
     #
     # Unfortunately, environments such as Heroku and AWS Elastic Beanstalk move gems around in the filesystem after
     # installation. Thus, the profiling native extension could not be loaded in these environments
@@ -47,12 +47,12 @@ module Datadog
     # we could setup when doing a `require`.
     #
     def self.libdatadog_folder_relative_to_native_lib_folder(
-      current_folder:,
+      extconf_folder:,
       libdatadog_pkgconfig_folder: Libdatadog.pkgconfig_folder
     )
       return unless libdatadog_pkgconfig_folder
 
-      native_lib_folder = "#{current_folder}/../../lib/"
+      native_lib_folder = "#{extconf_folder}/../../lib/"
       libdatadog_lib_folder = "#{libdatadog_pkgconfig_folder}/../"
 
       Pathname.new(libdatadog_lib_folder).relative_path_from(Pathname.new(native_lib_folder)).to_s
@@ -104,13 +104,51 @@ module Datadog
       end
     end
 
-    # mkmf sets $PKGCONFIG after the `pkg_config` gets used in extconf.rb. When `pkg_config` is unsuccessful, we use
-    # this helper to decide if we can show more specific error message vs a generic "something went wrong".
-    def self.pkg_config_missing?(command: $PKGCONFIG) # standard:disable Style/GlobalVars
-      pkg_config_available = command && xsystem("#{command} --version")
+    # Directly configures mkmf to link against libdatadog by setting $INCFLAGS, $LDFLAGS, and $libs.
+    #
+    # This replaces the previous use of mkmf's `pkg_config("datadog_profiling_with_rpath")`, removing the need for
+    # the pkg-config system tool to be installed.
+    #
+    # The extconf_folder argument should be the __dir__ of the calling extconf.rb, used to compute relative rpaths.
+    # The logger argument is the mkmf Logging module, dependency-injected to make testing easier.
+    # rubocop:disable Style/GlobalVars
+    def self.configure_libdatadog(
+      extconf_folder:,
+      libdatadog_pkgconfig_folder: Libdatadog.pkgconfig_folder,
+      gem_dir: Gem.dir,
+      logger: Logging
+    )
+      return unless libdatadog_pkgconfig_folder
+
+      # The lib and include folders are at a fixed relative path from pkgconfig_folder
+      libdir = "#{libdatadog_pkgconfig_folder}/../../lib"
+      includedir = "#{libdatadog_pkgconfig_folder}/../../include"
+
+      # Set mkmf global variables
+      $INCFLAGS << " -I#{includedir}"
+      $LDFLAGS << " -L#{libdir} -Wl,-rpath,#{libdir}"
+      $libs << " -ldatadog_profiling"
+
+      # Add extra relative rpaths using $ORIGIN to handle environments where gems are moved after installation.
+      # The excessive escaping is needed to get these special characters through Make and the shell untouched.
+      extra_relative_rpaths = [
+        libdatadog_folder_relative_to_native_lib_folder(
+          extconf_folder: extconf_folder,
+          libdatadog_pkgconfig_folder: libdatadog_pkgconfig_folder,
+        ),
+        *libdatadog_folder_relative_to_ruby_extensions_folders(
+          gem_dir: gem_dir,
+          libdatadog_pkgconfig_folder: libdatadog_pkgconfig_folder,
+        ),
+      ]
+      extra_relative_rpaths.each { |folder| $LDFLAGS << " -Wl,-rpath,$$$\\\\{ORIGIN\\}/#{folder}" }
+
+      logger.message("linking with libdatadog (include=#{includedir}, lib=#{libdir})\n")
+      logger.message("[datadog] $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
 
-      pkg_config_available != true
+      true
     end
+    # rubocop:enable Style/GlobalVars
 
     def self.try_loading_libdatadog
       gem 'libdatadog', LIBDATADOG_VERSION

data/lib/datadog/ai_guard/configuration/settings.rb

@@ -17,6 +17,9 @@ module Datadog
           base.class_eval do
             # AI Guard specific configurations.
             # @public_api
+            #
+            # Steep does not update `self` for this `class_eval` block.
+            # @type self: Datadog::Core::Configuration::Base::_DslContext
             settings :ai_guard do
               # Enable AI Guard.
               #

data/lib/datadog/appsec/contrib/active_record/patcher.rb

@@ -61,6 +61,7 @@ module Datadog
             end
 
             ::ActiveRecord::ConnectionAdapters::SQLite3Adapter.prepend(instrumentation_module)
+            Patcher.instance_variable_set(:@patched, true)
           end
 
           def patch_mysql2_adapter
@@ -73,6 +74,7 @@ module Datadog
             end
 
             ::ActiveRecord::ConnectionAdapters::Mysql2Adapter.prepend(instrumentation_module)
+            Patcher.instance_variable_set(:@patched, true)
           end
 
           def patch_postgresql_adapter
@@ -93,6 +95,7 @@ module Datadog
             end
 
             ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(instrumentation_module)
+            Patcher.instance_variable_set(:@patched, true)
           end
         end
       end

data/lib/datadog/appsec/contrib/devise/integration.rb

@@ -24,7 +24,7 @@ module Datadog
           end
 
           def self.compatible?
-            super && version >= MINIMUM_VERSION
+            !!(super && (version&.>= MINIMUM_VERSION))
           end
 
           def self.auto_instrument?

data/lib/datadog/appsec/contrib/excon/patcher.rb

@@ -20,6 +20,8 @@ module Datadog
             require_relative 'ssrf_detection_middleware'
 
             ::Excon.defaults[:middlewares].insert(0, SSRFDetectionMiddleware)
+
+            Patcher.instance_variable_set(:@patched, true)
           end
         end
       end