datadog 2.26.0 → 2.27.0

data/ext/datadog_profiling_native_extension/setup_signal_handler.c

@@ -71,7 +71,7 @@ static void install_sigprof_signal_handler_internal(
       );
     }
 
-    rb_raise(
+    raise_error(
       rb_eRuntimeError,
       "Could not install profiling signal handler (%s): There's a pre-existing SIGPROF signal handler",
       handler_pretty_name
@@ -95,8 +95,14 @@ static inline void toggle_sigprof_signal_handler_for_current_thread(int action)
   sigset_t signals_to_toggle;
   sigemptyset(&signals_to_toggle);
   sigaddset(&signals_to_toggle, SIGPROF);
+
   int error = pthread_sigmask(action, &signals_to_toggle, NULL);
-  if (error) rb_exc_raise(rb_syserr_new_str(error, rb_sprintf("Unexpected failure in pthread_sigmask, action=%d", action)));
+  if (error) {
+    const char *message = (action == SIG_BLOCK) ?
+      "Unexpected failure in pthread_sigmask: action SIG_BLOCK" :
+      "Unexpected failure in pthread_sigmask: action SIG_UNBLOCK";
+    private_raise_syserr(error, message, message);
+  }
 }
 
 void block_sigprof_signal_handler_from_running_in_current_thread(void) {

data/ext/datadog_profiling_native_extension/setup_signal_handler.h

@@ -3,7 +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 remove_sigprof_signal_handler(void);

data/ext/datadog_profiling_native_extension/stack_recorder.c

@@ -349,7 +349,7 @@ static VALUE _native_new(VALUE klass) {
   ddog_prof_ManagedStringStorageNewResult string_storage = ddog_prof_ManagedStringStorage_new();
 
   if (string_storage.tag == DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));
+    raise_error(rb_eRuntimeError, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));
   }
 
   state->string_storage = string_storage.ok;
@@ -383,7 +383,7 @@ static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_Val
     ddog_prof_Profile_with_string_storage(sample_types, NULL /* period is optional */, state->string_storage);
 
   if (slot_one_profile_result.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to initialize slot one profile: %"PRIsVALUE, get_error_details_and_drop(&slot_one_profile_result.err));
+    raise_error(rb_eRuntimeError, "Failed to initialize slot one profile: %"PRIsVALUE, get_error_details_and_drop(&slot_one_profile_result.err));
   }
 
   state->profile_slot_one = (profile_slot) { .profile = slot_one_profile_result.ok, .start_timestamp = start_timestamp };
@@ -393,7 +393,7 @@ static void initialize_profiles(stack_recorder_state *state, ddog_prof_Slice_Val
 
   if (slot_two_profile_result.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {
     // Note: No need to take any special care of slot one, it'll get cleaned up by stack_recorder_typed_data_free
-    rb_raise(rb_eRuntimeError, "Failed to initialize slot two profile: %"PRIsVALUE, get_error_details_and_drop(&slot_two_profile_result.err));
+    raise_error(rb_eRuntimeError, "Failed to initialize slot two profile: %"PRIsVALUE, get_error_details_and_drop(&slot_two_profile_result.err));
   }
 
   state->profile_slot_two = (profile_slot) { .profile = slot_two_profile_result.ok, .start_timestamp = start_timestamp };
@@ -591,7 +591,7 @@ static VALUE _native_serialize(DDTRACE_UNUSED VALUE _self, VALUE recorder_instan
 
   ddog_prof_MaybeError result = args.advance_gen_result;
   if (result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
-    rb_raise(rb_eRuntimeError, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&result.some));
+    raise_error(rb_eRuntimeError, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&result.some));
   }
 
   VALUE start = ruby_time_from(args.slot->start_timestamp);
@@ -658,7 +658,7 @@ void record_sample(VALUE recorder_instance, ddog_prof_Slice_Location locations,
   sampler_unlock_active_profile(active_slot);
 
   if (result.tag == DDOG_PROF_PROFILE_RESULT_ERR) {
-    rb_raise(rb_eArgError, "Failed to record sample: %"PRIsVALUE, get_error_details_and_drop(&result.err));
+    raise_error(rb_eArgError, "Failed to record sample: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
 }
 
@@ -682,7 +682,7 @@ void record_endpoint(VALUE recorder_instance, uint64_t local_root_span_id, ddog_
   sampler_unlock_active_profile(active_slot);
 
   if (result.tag == DDOG_PROF_PROFILE_RESULT_ERR) {
-    rb_raise(rb_eArgError, "Failed to record endpoint: %"PRIsVALUE, get_error_details_and_drop(&result.err));
+    raise_error(rb_eArgError, "Failed to record endpoint: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
 }
 
@@ -824,7 +824,7 @@ static locked_profile_slot sampler_lock_active_profile(stack_recorder_state *sta
   }
 
   // We already tried both multiple times, and we did not succeed. This is not expected to happen. Let's stop sampling.
-  rb_raise(rb_eRuntimeError, "Failed to grab either mutex in sampler_lock_active_profile");
+  raise_error(rb_eRuntimeError, "Failed to grab either mutex in sampler_lock_active_profile");
 }
 
 static void sampler_unlock_active_profile(locked_profile_slot active_slot) {
@@ -889,7 +889,7 @@ static VALUE test_slot_mutex_state(VALUE recorder_instance, int slot) {
     return Qtrue;
   } else {
     ENFORCE_SUCCESS_GVL(error);
-    rb_raise(rb_eRuntimeError, "Failed to raise exception in test_slot_mutex_state; this should never happen");
+    raise_error(rb_eRuntimeError, "Failed to raise exception in test_slot_mutex_state; this should never happen");
   }
 }
 
@@ -941,7 +941,7 @@ static VALUE _native_track_object(DDTRACE_UNUSED VALUE _self, VALUE recorder_ins
 static void reset_profile_slot(profile_slot *slot, ddog_Timespec start_timestamp) {
   ddog_prof_Profile_Result reset_result = ddog_prof_Profile_reset(&slot->profile);
   if (reset_result.tag == DDOG_PROF_PROFILE_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to reset profile: %"PRIsVALUE, get_error_details_and_drop(&reset_result.err));
+    raise_error(rb_eRuntimeError, "Failed to reset profile: %"PRIsVALUE, get_error_details_and_drop(&reset_result.err));
   }
   slot->start_timestamp = start_timestamp;
   slot->stats = (stats_slot) {};
@@ -1056,14 +1056,14 @@ static VALUE _native_test_managed_string_storage_produces_valid_profiles(DDTRACE
   ddog_prof_ManagedStringStorageNewResult string_storage = ddog_prof_ManagedStringStorage_new();
 
   if (string_storage.tag == DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to initialize string storage: %"PRIsVALUE, get_error_details_and_drop(&string_storage.err));
+    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_Profile_NewResult profile = ddog_prof_Profile_with_string_storage(sample_types, NULL, string_storage.ok);
 
   if (profile.tag == DDOG_PROF_PROFILE_NEW_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to initialize profile: %"PRIsVALUE, get_error_details_and_drop(&profile.err));
+    raise_error(rb_eRuntimeError, "Failed to initialize profile: %"PRIsVALUE, get_error_details_and_drop(&profile.err));
   }
 
   ddog_prof_ManagedStringId hello = intern_or_raise(string_storage.ok, DDOG_CHARSLICE_C("hello"));
@@ -1097,7 +1097,7 @@ static VALUE _native_test_managed_string_storage_produces_valid_profiles(DDTRACE
   );
 
   if (result.tag == DDOG_PROF_PROFILE_RESULT_ERR) {
-    rb_raise(rb_eArgError, "Failed to record sample: %"PRIsVALUE, get_error_details_and_drop(&result.err));
+    raise_error(rb_eArgError, "Failed to record sample: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
 
   ddog_Timespec finish_timestamp = system_epoch_now_timespec();
@@ -1105,13 +1105,13 @@ static VALUE _native_test_managed_string_storage_produces_valid_profiles(DDTRACE
   ddog_prof_Profile_SerializeResult serialize_result = ddog_prof_Profile_serialize(&profile.ok, &start_timestamp, &finish_timestamp);
 
   if (serialize_result.tag == DDOG_PROF_PROFILE_SERIALIZE_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to serialize: %"PRIsVALUE, get_error_details_and_drop(&serialize_result.err));
+    raise_error(rb_eRuntimeError, "Failed to serialize: %"PRIsVALUE, get_error_details_and_drop(&serialize_result.err));
   }
 
   ddog_prof_MaybeError advance_gen_result = ddog_prof_ManagedStringStorage_advance_gen(string_storage.ok);
 
   if (advance_gen_result.tag == DDOG_PROF_OPTION_ERROR_SOME_ERROR) {
-    rb_raise(rb_eRuntimeError, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&advance_gen_result.some));
+    raise_error(rb_eRuntimeError, "Failed to advance string storage gen: %"PRIsVALUE, get_error_details_and_drop(&advance_gen_result.some));
   }
 
   VALUE encoded_pprof_1 = from_ddog_prof_EncodedProfile(serialize_result.ok);
@@ -1127,13 +1127,13 @@ static VALUE _native_test_managed_string_storage_produces_valid_profiles(DDTRACE
   );
 
   if (result.tag == DDOG_PROF_PROFILE_RESULT_ERR) {
-    rb_raise(rb_eArgError, "Failed to record sample: %"PRIsVALUE, get_error_details_and_drop(&result.err));
+    raise_error(rb_eArgError, "Failed to record sample: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
 
   serialize_result = ddog_prof_Profile_serialize(&profile.ok, &start_timestamp, &finish_timestamp);
 
   if (serialize_result.tag == DDOG_PROF_PROFILE_SERIALIZE_RESULT_ERR) {
-    rb_raise(rb_eArgError, "Failed to serialize: %"PRIsVALUE, get_error_details_and_drop(&serialize_result.err));
+    raise_error(rb_eArgError, "Failed to serialize: %"PRIsVALUE, get_error_details_and_drop(&serialize_result.err));
   }
 
   VALUE encoded_pprof_2 = from_ddog_prof_EncodedProfile(serialize_result.ok);

data/ext/datadog_profiling_native_extension/unsafe_api_calls_check.c

@@ -3,6 +3,7 @@
 #include <stdbool.h>
 
 #include "datadog_ruby_common.h"
+#include "ruby_helpers.h"
 #include "unsafe_api_calls_check.h"
 #include "extconf.h"
 
@@ -21,7 +22,7 @@ void unsafe_api_calls_check_init(void) {
     check_for_unsafe_api_calls_handle = rb_postponed_job_preregister(unused_flags, check_for_unsafe_api_calls, NULL);
 
    if (check_for_unsafe_api_calls_handle == POSTPONED_JOB_HANDLE_INVALID) {
-     rb_raise(rb_eRuntimeError, "Failed to register check_for_unsafe_api_calls_handle postponed job (got POSTPONED_JOB_HANDLE_INVALID)");
+     raise_error(rb_eRuntimeError, "Failed to register check_for_unsafe_api_calls_handle postponed job (got POSTPONED_JOB_HANDLE_INVALID)");
    }
   #endif
 }

data/ext/datadog_profiling_native_extension/unsafe_api_calls_check.h

@@ -5,8 +5,11 @@
 // Specifically, when the profiler is sampling, we're never supposed to call into Ruby code (e.g. methods
 // implemented using Ruby code) or allocate Ruby objects.
 // That's because those events introduce thread switch points, and really we don't the VM switching between threads
-// in the middle of the profiler sampling.
-// This includes raising exceptions, unless we're trying to stop the profiler, and even then we must be careful.
+// in the middle of the profiler sampling. This includes raising exceptions.
+//
+// Raising exceptions as the very last operation, to stop the profiler is ok, but comes a caveat: raising exceptions
+// will fail the unsafe check. When testing exception paths, you must disable unsafe checking for that test execution.
+// See `allow_exception` usage for how to we disable it for testing today.
 //
 // The above is especially true in situations such as GC profiling or allocation/heap profiling, as in those situations
 // we can even crash the Ruby VM if we switch away at the wrong time.

data/ext/libdatadog_api/crashtracker.c

@@ -2,6 +2,7 @@
 #include <datadog/crashtracker.h>
 
 #include "datadog_ruby_common.h"
+#include "helpers.h"
 
 static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self);
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self);
@@ -41,7 +42,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
   ENFORCE_TYPE(action, T_SYMBOL);
   ENFORCE_TYPE(upload_timeout_seconds, T_FIXNUM);
 
-  if (action != start_action && action != update_on_fork_action) rb_raise(rb_eArgError, "Unexpected action: %+"PRIsVALUE, action);
+  if (action != start_action && action != update_on_fork_action) raise_error(rb_eArgError, "Unexpected action: %+"PRIsVALUE, action);
 
   VALUE version = datadog_gem_version();
 
@@ -49,7 +50,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
   // 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) {
-    rb_raise(rb_eRuntimeError, "Failed to create endpoint from agent_base_url: %"PRIsVALUE, agent_base_url);
+    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);
 
@@ -107,9 +108,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
   ddog_endpoint_drop(endpoint);
   // }} End of exception-free zone to prevent leaks
 
-  if (result.tag == DDOG_VOID_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to start/update the crash tracker: %"PRIsVALUE, get_error_details_and_drop(&result.err));
-  }
+  CHECK_VOID_RESULT("Failed to start/update the crash tracker", result);
 
   return Qtrue;
 }
@@ -117,9 +116,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
 static VALUE _native_stop(DDTRACE_UNUSED VALUE _self) {
   ddog_VoidResult result = ddog_crasht_disable();
 
-  if (result.tag == DDOG_VOID_RESULT_ERR) {
-    rb_raise(rb_eRuntimeError, "Failed to stop the crash tracker: %"PRIsVALUE, get_error_details_and_drop(&result.err));
-  }
+  CHECK_VOID_RESULT("Failed to stop the crash tracker", result);
 
   return Qtrue;
 }

data/ext/libdatadog_api/datadog_ruby_common.c

@@ -1,8 +1,11 @@
 #include "datadog_ruby_common.h"
+#include <stdarg.h>
 
 // IMPORTANT: Currently this file is copy-pasted between extensions. Make sure to update all versions when doing any change!
 
-void raise_unexpected_type(VALUE value, const char *value_name, const char *type_name, const char *file, int line, const char* function_name) {
+static ID telemetry_message_id;
+
+void raise_unexpected_type(VALUE value, const char *value_name, const char *type_name, const char *file, int line, const char *function_name) {
   rb_exc_raise(
     rb_exc_new_str(
       rb_eTypeError,
@@ -18,6 +21,26 @@ void raise_unexpected_type(VALUE value, const char *value_name, const char *type
   );
 }
 
+// Raises an exception with separate telemetry-safe and detailed messages.
+// NOTE: Raising an exception always invokes Ruby code so it requires the GVL and is not compatible with "debug_enter_unsafe_context".
+// @see debug_enter_unsafe_context
+void private_raise_exception(VALUE exception, const char *static_message) {
+  rb_ivar_set(exception, telemetry_message_id, rb_str_new_cstr(static_message));
+  rb_exc_raise(exception);
+}
+
+// Helper for raising pre-formatted exceptions
+void private_raise_error_formatted(VALUE exception_class, const char *detailed_message, const char *static_message) {
+  VALUE exception = rb_exc_new_cstr(exception_class, detailed_message);
+  private_raise_exception(exception, static_message);
+}
+
+// Use `raise_error` the macro instead, as it provides additional argument checks.
+void private_raise_error(VALUE exception_class, const char *fmt, ...) {
+  FORMAT_VA_ERROR_MESSAGE(detailed_message, fmt);
+  private_raise_error_formatted(exception_class, detailed_message, fmt);
+}
+
 VALUE datadog_gem_version(void) {
   VALUE ddtrace_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
   ENFORCE_TYPE(ddtrace_module, T_MODULE);
@@ -78,3 +101,27 @@ ddog_Vec_Tag convert_tags(VALUE tags_as_array) {
 
   return tags;
 }
+
+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;
+}
+
+void datadog_ruby_common_init(void) {
+  telemetry_message_id = rb_intern("@telemetry_message");
+}

data/ext/libdatadog_api/datadog_ruby_common.h

@@ -5,6 +5,9 @@
 #include <ruby.h>
 #include <datadog/common.h>
 
+// Must be called once during initialization
+void datadog_ruby_common_init(void);
+
 // Used to mark symbols to be exported to the outside of the extension.
 // Consider very carefully before tagging a function with this.
 #define DDTRACE_EXPORT __attribute__ ((visibility ("default")))
@@ -32,6 +35,39 @@
 
 NORETURN(void raise_unexpected_type(VALUE value, const char *value_name, const char *type_name, const char *file, int line, const char* function_name));
 
+// Raises an exception of the specified class with the formatted string as its message.
+// This macro ensures that the literal string is sent for telemetry, while the formatted
+// message is the default `Exception#message`.
+// *Ruby exceptions not raised through this function will not be reported via telemetry.*
+#define raise_error(exception_class, fmt, ...) \
+  private_raise_error(exception_class, "" fmt, ##__VA_ARGS__)
+
+NORETURN(
+  void private_raise_error(VALUE exception_class, const char *fmt, ...)
+  __attribute__ ((format (printf, 2, 3)));
+);
+
+// Internal helper for raising pre-formatted exceptions
+NORETURN(
+  void private_raise_error_formatted(VALUE exception_class, const char *detailed_message, const char *static_message)
+);
+
+// Raises an exception with separate telemetry-safe and detailed messages.
+// NOTE: Raising an exception always invokes Ruby code so it requires the GVL and is not compatible with "debug_enter_unsafe_context".
+// @see debug_enter_unsafe_context
+NORETURN(
+  void private_raise_exception(VALUE exception, const char *static_message)
+);
+
+#define MAX_RAISE_MESSAGE_SIZE 256
+
+#define FORMAT_VA_ERROR_MESSAGE(buf, fmt) \
+  char buf[MAX_RAISE_MESSAGE_SIZE]; \
+  va_list buf##_args; \
+  va_start(buf##_args, fmt); \
+  vsnprintf(buf, MAX_RAISE_MESSAGE_SIZE, fmt, buf##_args); \
+  va_end(buf##_args);
+
 // Helper to retrieve Datadog::VERSION::STRING
 VALUE datadog_gem_version(void);
 
@@ -61,3 +97,8 @@ static inline VALUE get_error_details_and_drop(ddog_Error *error) {
   ddog_Error_drop(error);
   return result;
 }
+
+// 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);

data/ext/libdatadog_api/ddsketch.c

@@ -2,6 +2,7 @@
 #include <datadog/ddsketch.h>
 
 #include "datadog_ruby_common.h"
+#include "helpers.h"
 
 static VALUE _native_new(VALUE klass);
 static void ddsketch_free(void *ptr);
@@ -9,7 +10,6 @@ static VALUE native_add(VALUE self, VALUE point);
 static VALUE native_add_with_count(VALUE self, VALUE point, VALUE count);
 static VALUE native_count(VALUE self);
 static VALUE native_encode(VALUE self);
-NORETURN(static void raise_ddsketch_error(const char *message, ddog_VoidResult result));
 
 void ddsketch_init(VALUE core_module) {
   VALUE ddsketch_class = rb_define_class_under(core_module, "DDSketch", rb_cObject);
@@ -48,17 +48,13 @@ static void ddsketch_free(void *ptr) {
   ruby_xfree(ptr);
 }
 
-static void raise_ddsketch_error(const char *message, ddog_VoidResult result) {
-  rb_raise(rb_eRuntimeError, "%s: %"PRIsVALUE, message, get_error_details_and_drop(&result.err));
-}
-
 static VALUE native_add(VALUE self, VALUE point) {
   ddsketch_Handle_DDSketch *state;
   TypedData_Get_Struct(self, ddsketch_Handle_DDSketch, &ddsketch_typed_data, state);
 
   ddog_VoidResult result = ddog_ddsketch_add(state, NUM2DBL(point));
 
-  if (result.tag == DDOG_VOID_RESULT_ERR) raise_ddsketch_error("DDSketch add failed", result);
+  CHECK_VOID_RESULT("DDSketch add failed", result);
 
   return self;
 }
@@ -69,7 +65,7 @@ static VALUE native_add_with_count(VALUE self, VALUE point, VALUE count) {
 
   ddog_VoidResult result = ddog_ddsketch_add_with_count(state, NUM2DBL(point), NUM2DBL(count));
 
-  if (result.tag == DDOG_VOID_RESULT_ERR) raise_ddsketch_error("DDSketch add_with_count failed", result);
+  CHECK_VOID_RESULT("DDSketch add_with_count failed", result);
 
   return self;
 }
@@ -81,7 +77,7 @@ static VALUE native_count(VALUE self) {
   double count_out;
   ddog_VoidResult result = ddog_ddsketch_count(state, &count_out);
 
-  if (result.tag == DDOG_VOID_RESULT_ERR) raise_ddsketch_error("DDSketch count failed", result);
+  CHECK_VOID_RESULT("DDSketch count failed", result);
 
   return DBL2NUM(count_out);
 }

data/ext/libdatadog_api/feature_flags.c

@@ -130,7 +130,7 @@ void feature_flags_init(VALUE core_module) {
 static VALUE configuration_new(VALUE klass, VALUE json_str) {
   struct ddog_ffe_Result_HandleConfiguration result = ddog_ffe_configuration_new(borrow_str(json_str));
   if (result.tag == DDOG_FFE_RESULT_HANDLE_CONFIGURATION_ERR_HANDLE_CONFIGURATION) {
-    rb_raise(feature_flags_error_class, "Failed to create configuration from JSON: %"PRIsVALUE, get_error_details_and_drop(&result.err));
+    raise_error(feature_flags_error_class, "Failed to create configuration from JSON: %"PRIsVALUE, get_error_details_and_drop(&result.err));
   }
   return TypedData_Wrap_Struct(klass, &configuration_data_type, result.ok);
 }
@@ -159,7 +159,7 @@ static ddog_ffe_ExpectedFlagType expected_type_from_value(VALUE expected_type) {
   } else if (id == id_float) {
     return DDOG_FFE_EXPECTED_FLAG_TYPE_FLOAT;
   } else {
-    rb_raise(feature_flags_error_class, "Internal: Unexpected flag type: %"PRIsVALUE, expected_type);
+    raise_error(feature_flags_error_class, "Internal: Unexpected flag type: %"PRIsVALUE, expected_type);
   }
 }
 
@@ -199,7 +199,7 @@ static int evaluation_context_foreach_callback(VALUE key, VALUE value, VALUE arg
   if (builder->attr_count >= builder->attr_capacity) {
     // This should never happen because evaluation_context_from_hash()
     // pre-allocates attr_capacity equal to iterated Hash size.
-    rb_raise(feature_flags_error_class, "Internal: Attribute count exceeded capacity");
+    raise_error(feature_flags_error_class, "Internal: Attribute count exceeded capacity");
   }
 
   ddog_ffe_AttributePair *attr = &builder->attrs[builder->attr_count];
@@ -354,7 +354,7 @@ static VALUE resolution_details_get_raw_value(VALUE self) {
       return Qnil;
     default:
       // This should never happen as we checked for all possible tag values.
-      rb_raise(feature_flags_error_class, "Internal: Unexpected ResolutionDetails value tag");
+      raise_error(feature_flags_error_class, "Internal: Unexpected ResolutionDetails value tag");
   }
 }
 
@@ -387,7 +387,7 @@ static VALUE resolution_details_get_flag_type(VALUE self) {
       return Qnil;
     default:
       // This should never happen as we checked for all possible tag values.
-      rb_raise(feature_flags_error_class, "Internal: Unexpected ResolutionDetails value tag");
+      raise_error(feature_flags_error_class, "Internal: Unexpected ResolutionDetails value tag");
   }
 }
 

data/ext/libdatadog_api/helpers.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "datadog_ruby_common.h"
+
+// Raises a Ruby error if the `ddog_VoidResult` indicates an error.
+// The error message in `result.err` is appended to the provided `message`.
+//
+// @param[in] message (const char *) The error message
+// @param[in] result (ddog_VoidResult) A result to check
+#define CHECK_VOID_RESULT(message, result)                             \
+  do {                                                                         \
+    if (result.tag == DDOG_VOID_RESULT_ERR) {                                 \
+      raise_lib_error(message, result);                                        \
+    }                                                                          \
+  } while (0)
+
+// Raises a Ruby error for the error result.
+// The error message in `result.err` is appended to the provided `message`.
+//
+// @param[in] message (const char *) The error message
+// @param[in] result (struct { ddog_Error res; ... }) Any type of result
+#define raise_lib_error(message, result)                                        \
+  do { \
+    char error_msg[MAX_RAISE_MESSAGE_SIZE];  \
+    read_ddogerr_string_and_drop(&result.err, error_msg, MAX_RAISE_MESSAGE_SIZE); \
+    raise_error(rb_eRuntimeError, message ": %s", error_msg); \
+  } while (0)

data/ext/libdatadog_api/init.c

@@ -10,6 +10,10 @@ void ddsketch_init(VALUE core_module);
 
 void DDTRACE_EXPORT Init_libdatadog_api(void) {
   VALUE datadog_module = rb_define_module("Datadog");
+
+  // MUST be called before all other initialization
+  datadog_ruby_common_init();
+
   VALUE core_module = rb_define_module_under(datadog_module, "Core");
 
   crashtracker_init(core_module);

data/lib/datadog/appsec/api_security/endpoint_collection/rails_collector.rb

@@ -19,7 +19,14 @@ module Datadog
             Enumerator.new do |yielder|
               @routes.each do |route|
                 if route.dispatcher?
-                  yielder.yield RailsRouteSerializer.serialize(route)
+                  if route.verb.include?('|')
+                    # report separate route for each method for multi-method routes
+                    route.verb.split('|').each do |method|
+                      yielder.yield RailsRouteSerializer.serialize(route, method_override: method)
+                    end
+                  else
+                    yielder.yield RailsRouteSerializer.serialize(route)
+                  end
                 elsif mounted_grape_app?(route.app.rack_app)
                   route.app.rack_app.routes.each do |grape_route|
                     yielder.yield GrapeRouteSerializer.serialize(grape_route, path_prefix: route.path.spec.to_s)

data/lib/datadog/appsec/api_security/endpoint_collection/rails_route_serializer.rb

@@ -10,8 +10,15 @@ module Datadog
 
           module_function
 
-          def serialize(route)
-            method = route.verb.empty? ? "*" : route.verb
+          def serialize(route, method_override: nil)
+            method = if method_override
+              method_override
+            elsif route.verb.empty?
+              "*"
+            else
+              route.verb
+            end
+
             path = route.path.spec.to_s.delete_suffix(FORMAT_SUFFIX)
 
             {

data/lib/datadog/appsec/component.rb

@@ -78,7 +78,7 @@ module Datadog
       end
 
       def reconfigure!
-        security_engine.reconfigure!
+        security_engine&.reconfigure!
       end
 
       def shutdown!

data/lib/datadog/appsec/context.rb

@@ -48,11 +48,11 @@ module Datadog
         result
       end
 
-      def run_rasp(type, persistent_data, ephemeral_data, timeout = WAF::LibDDWAF::DDWAF_RUN_TIMEOUT)
+      def run_rasp(type, persistent_data, ephemeral_data, timeout = WAF::LibDDWAF::DDWAF_RUN_TIMEOUT, phase: nil)
         result = @waf_runner.run(persistent_data, ephemeral_data, timeout)
 
-        Metrics::Telemetry.report_rasp(type, result)
-        @metrics.record_rasp(result)
+        Metrics::Telemetry.report_rasp(type, result, phase: phase)
+        @metrics.record_rasp(result, type: type, phase: phase)
 
         result
       end

data/lib/datadog/appsec/contrib/excon/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

@@ -9,7 +9,7 @@ module Datadog
           module_function
 
           def patched?
-            Patcher.instance_variable_get(:@patched)
+            !!Patcher.instance_variable_get(:@patched)
           end
 
           def target_version