datadog 2.2.0 → 2.3.0

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -18,6 +18,22 @@ typedef struct {
   rb_nativethread_id_t owner;
 } current_gvl_owner;
 
+typedef struct frame_info {
+  union {
+    struct {
+      VALUE iseq;
+      void *caching_pc; // For caching only
+      int line;
+    } ruby_frame;
+    struct {
+      VALUE caching_cme; // For caching only
+      ID method_id;
+    } native_frame;
+  } as;
+  bool is_ruby_frame : 1;
+  bool same_frame : 1;
+} frame_info;
+
 rb_nativethread_id_t pthread_id_for(VALUE thread);
 bool is_current_thread_holding_the_gvl(void);
 current_gvl_owner gvl_owner(void);
@@ -27,20 +43,10 @@ void ddtrace_thread_list(VALUE result_array);
 bool is_thread_alive(VALUE thread);
 VALUE thread_name_for(VALUE thread);
 
-int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, int *lines, bool* is_ruby_frame);
+int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer);
 // Returns true if the current thread belongs to the main Ractor or if Ruby has no Ractor support
 bool ddtrace_rb_ractor_main_p(void);
 
-// Ruby 3.0 finally added support for showing CFUNC frames (frames for methods written using native code)
-// in stack traces gathered via `rb_profile_frames` (https://github.com/ruby/ruby/pull/3299).
-// To access this information on older Rubies, beyond using our custom `ddtrace_rb_profile_frames` above, we also need
-// to backport the Ruby 3.0+ version of `rb_profile_frame_method_name`.
-#ifdef USE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME
-  VALUE ddtrace_rb_profile_frame_method_name(VALUE frame);
-#else // Ruby > 3.0, just use the stock functionality
-  #define ddtrace_rb_profile_frame_method_name rb_profile_frame_method_name
-#endif
-
 // See comment on `record_placeholder_stack_in_native_code` for a full explanation of what this means (and why we don't just return 0)
 #define PLACEHOLDER_STACK_IN_NATIVE_CODE -1
 

data/ext/datadog_profiling_native_extension/profiling.c

@@ -19,7 +19,6 @@ void collectors_dynamic_sampling_rate_init(VALUE profiling_module);
 void collectors_idle_sampling_helper_init(VALUE profiling_module);
 void collectors_stack_init(VALUE profiling_module);
 void collectors_thread_context_init(VALUE profiling_module);
-void crashtracker_init(VALUE profiling_module);
 void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
 
@@ -54,7 +53,6 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   collectors_idle_sampling_helper_init(profiling_module);
   collectors_stack_init(profiling_module);
   collectors_thread_context_init(profiling_module);
-  crashtracker_init(profiling_module);
   http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
 

data/ext/datadog_profiling_native_extension/ruby_helpers.c

@@ -20,29 +20,6 @@ void ruby_helpers_init(void) {
   to_s_id = rb_intern("to_s");
 }
 
-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,
-      rb_sprintf("wrong argument %"PRIsVALUE" for '%s' (expected a %s) at %s:%d:in `%s'",
-        rb_inspect(value),
-        value_name,
-        type_name,
-        file,
-        line,
-        function_name
-      )
-    )
-  );
-}
-
 #define MAX_RAISE_MESSAGE_SIZE 256
 
 struct raise_arguments {
@@ -255,13 +232,3 @@ VALUE ruby_safe_inspect(VALUE obj) {
     return rb_str_new_cstr("(Not inspectable)");
   }
 }
-
-VALUE ddtrace_version(void) {
-  VALUE ddtrace_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
-  ENFORCE_TYPE(ddtrace_module, T_MODULE);
-  VALUE version_module = rb_const_get(ddtrace_module, rb_intern("VERSION"));
-  ENFORCE_TYPE(version_module, T_MODULE);
-  VALUE version_string = rb_const_get(version_module, rb_intern("STRING"));
-  ENFORCE_TYPE(version_string, T_STRING);
-  return version_string;
-}

data/ext/datadog_profiling_native_extension/ruby_helpers.h

@@ -1,9 +1,7 @@
 #pragma once
 
-#include <ruby.h>
 #include <stdbool.h>
-
-#include "helpers.h"
+#include "datadog_ruby_common.h"
 
 // Initialize internal data needed by some ruby helpers. Should be called during start, before any actual
 // usage of ruby helpers.
@@ -39,27 +37,6 @@ static inline int check_if_pending_exception(void) {
   return pending_exception;
 }
 
-#define ADD_QUOTES_HELPER(x) #x
-#define ADD_QUOTES(x) ADD_QUOTES_HELPER(x)
-
-// Ruby has a Check_Type(value, type) that is roughly equivalent to this BUT Ruby's version is rather cryptic when it fails
-// e.g. "wrong argument type nil (expected String)". This is a replacement that prints more information to help debugging.
-#define ENFORCE_TYPE(value, type) \
-  { if (RB_UNLIKELY(!RB_TYPE_P(value, type))) raise_unexpected_type(value, ADD_QUOTES(value), ADD_QUOTES(type), __FILE__, __LINE__, __func__); }
-
-#define ENFORCE_BOOLEAN(value) \
-  { if (RB_UNLIKELY(value != Qtrue && value != Qfalse)) raise_unexpected_type(value, ADD_QUOTES(value), "true or false", __FILE__, __LINE__, __func__); }
-
-// Called by ENFORCE_TYPE; should not be used directly
-NORETURN(void raise_unexpected_type(
-  VALUE value,
-  const char *value_name,
-  const char *type_name,
-  const char *file,
-  int line,
-  const char *function_name
-));
-
 #define VALUE_COUNT(array) (sizeof(array) / sizeof(VALUE))
 
 NORETURN(
@@ -113,5 +90,3 @@ size_t ruby_obj_memsize_of(VALUE obj);
 // return a string with the result of that call. Elsif the object responds to
 // 'to_s', return a string with the result of that call. Otherwise, return Qnil.
 VALUE ruby_safe_inspect(VALUE obj);
-
-VALUE ddtrace_version(void);

data/ext/datadog_profiling_native_extension/setup_signal_handler.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #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);

data/ext/datadog_profiling_native_extension/stack_recorder.c

@@ -342,6 +342,10 @@ static VALUE _native_new(VALUE klass) {
   // Note: At this point, slot_one_profile and slot_two_profile contain null pointers. Libdatadog validates pointers
   // before using them so it's ok for us to go ahead and create the StackRecorder object.
 
+  // Note: As of this writing, no new Ruby objects get created and stored in the state. If that ever changes, remember
+  // to keep them on the stack and mark them with RB_GC_GUARD -- otherwise it's possible for a GC to run and
+  // since the instance representing the state does not yet exist, such objects will not get marked.
+
   VALUE stack_recorder = TypedData_Wrap_Struct(klass, &stack_recorder_typed_data, state);
 
   // NOTE: We initialize this because we want a new recorder to be operational even without initialization and our
@@ -612,12 +616,20 @@ void record_sample(VALUE recorder_instance, ddog_prof_Slice_Location locations,
   metric_values[position_for[ALLOC_SAMPLES_UNSCALED_VALUE_ID]] = values.alloc_samples_unscaled;
   metric_values[position_for[TIMELINE_VALUE_ID]]      = values.timeline_wall_time_ns;
 
-  if (values.alloc_samples != 0) {
+  if (values.heap_sample) {
     // If we got an allocation sample end the heap allocation recording to commit the heap sample.
     // FIXME: Heap sampling currently has to be done in 2 parts because the construction of locations is happening
     //        very late in the allocation-sampling path (which is shared with the cpu sampling path). This can
     //        be fixed with some refactoring but for now this leads to a less impactful change.
-    end_heap_allocation_recording(state->heap_recorder, locations);
+    //
+    // NOTE: The heap recorder is allowed to raise exceptions if something's wrong. But we also need to handle it
+    // on this side to make sure we properly unlock the active slot mutex on our way out. Otherwise, this would
+    // later lead to deadlocks (since the active slot mutex is not expected to be locked forever).
+    int exception_state = end_heap_allocation_recording_with_rb_protect(state->heap_recorder, locations);
+    if (exception_state) {
+      sampler_unlock_active_profile(active_slot);
+      rb_jump_tag(exception_state);
+    }
   }
 
   ddog_prof_Profile_Result result = ddog_prof_Profile_add(

data/ext/datadog_profiling_native_extension/stack_recorder.h

@@ -9,6 +9,7 @@ typedef struct {
   uint32_t cpu_or_wall_samples;
   uint32_t alloc_samples;
   uint32_t alloc_samples_unscaled;
+  bool heap_sample;
   int64_t timeline_wall_time_ns;
 } sample_values;
 

data/ext/datadog_profiling_native_extension/time_helpers.c

@@ -4,21 +4,6 @@
 #include "ruby_helpers.h"
 #include "time_helpers.h"
 
-// Safety: This function is assumed never to raise exceptions by callers when raise_on_failure == false
-long retrieve_clock_as_ns(clockid_t clock_id, bool raise_on_failure) {
-  struct timespec clock_value;
-
-  if (clock_gettime(clock_id, &clock_value) != 0) {
-    if (raise_on_failure) ENFORCE_SUCCESS_GVL(errno);
-    return 0;
-  }
-
-  return clock_value.tv_nsec + SECONDS_AS_NS(clock_value.tv_sec);
-}
-
-long monotonic_wall_time_now_ns(bool raise_on_failure) { return retrieve_clock_as_ns(CLOCK_MONOTONIC, raise_on_failure); }
-long system_epoch_time_now_ns(bool raise_on_failure)   { return retrieve_clock_as_ns(CLOCK_REALTIME,  raise_on_failure); }
-
 // Design: The monotonic_to_system_epoch_state struct is kept somewhere by the caller, and MUST be initialized to
 // MONOTONIC_TO_SYSTEM_EPOCH_INITIALIZER.
 //

data/ext/datadog_profiling_native_extension/time_helpers.h

@@ -1,12 +1,16 @@
 #pragma once
 
 #include <stdbool.h>
+#include <errno.h>
+#include <time.h>
+
+#include "extconf.h" // Needed for HAVE_CLOCK_MONOTONIC_COARSE
+#include "ruby_helpers.h"
 
 #define SECONDS_AS_NS(value) (value * 1000 * 1000 * 1000L)
 #define MILLIS_AS_NS(value) (value * 1000 * 1000L)
 
-#define RAISE_ON_FAILURE true
-#define DO_NOT_RAISE_ON_FAILURE false
+typedef enum { RAISE_ON_FAILURE, DO_NOT_RAISE_ON_FAILURE } raise_on_failure_setting;
 
 #define INVALID_TIME -1
 
@@ -17,10 +21,36 @@ typedef struct {
 
 #define MONOTONIC_TO_SYSTEM_EPOCH_INITIALIZER {.system_epoch_ns_reference = INVALID_TIME, .delta_to_epoch_ns = INVALID_TIME}
 
-// Safety: This function is assumed never to raise exceptions by callers when raise_on_failure == false
-long monotonic_wall_time_now_ns(bool raise_on_failure);
+static inline long retrieve_clock_as_ns(clockid_t clock_id, raise_on_failure_setting raise_on_failure) {
+  struct timespec clock_value;
+
+  if (clock_gettime(clock_id, &clock_value) != 0) {
+    if (raise_on_failure == RAISE_ON_FAILURE) ENFORCE_SUCCESS_GVL(errno);
+    return 0;
+  }
+
+  return clock_value.tv_nsec + SECONDS_AS_NS(clock_value.tv_sec);
+}
+
+static inline long monotonic_wall_time_now_ns(raise_on_failure_setting raise_on_failure) { return retrieve_clock_as_ns(CLOCK_MONOTONIC, raise_on_failure); }
+static inline long system_epoch_time_now_ns(raise_on_failure_setting raise_on_failure)   { return retrieve_clock_as_ns(CLOCK_REALTIME,  raise_on_failure); }
+
+// Coarse instants use CLOCK_MONOTONIC_COARSE on Linux which is expected to provide resolution in the millisecond range:
+// https://docs.redhat.com/en/documentation/red_hat_enterprise_linux_for_real_time/7/html/reference_guide/sect-posix_clocks#Using_clock_getres_to_compare_clock_resolution
+// We introduce here a separate type for it, so as to make it harder to misuse/more explicit when these timestamps are used
+
+typedef struct coarse_instant {
+  long timestamp_ns;
+} coarse_instant;
+
+static inline coarse_instant to_coarse_instant(long timestamp_ns) { return (coarse_instant) {.timestamp_ns = timestamp_ns}; }
 
-// Safety: This function is assumed never to raise exceptions by callers when raise_on_failure == false
-long system_epoch_time_now_ns(bool raise_on_failure);
+static inline coarse_instant monotonic_coarse_wall_time_now_ns(void) {
+ #ifdef HAVE_CLOCK_MONOTONIC_COARSE // Linux
+    return to_coarse_instant(retrieve_clock_as_ns(CLOCK_MONOTONIC_COARSE, DO_NOT_RAISE_ON_FAILURE));
+  #else // macOS
+    return to_coarse_instant(retrieve_clock_as_ns(CLOCK_MONOTONIC, DO_NOT_RAISE_ON_FAILURE));
+  #endif
+}
 
 long monotonic_to_system_epoch_ns(monotonic_to_system_epoch_state *state, long monotonic_wall_time_ns);

data/ext/{datadog_profiling_native_extension → libdatadog_api}/crashtracker.c

@@ -1,15 +1,25 @@
 #include <ruby.h>
-#include <datadog/common.h>
-#include <libdatadog_helpers.h>
+#include <datadog/profiling.h>
+
+#include "datadog_ruby_common.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);
+static void crashtracker_init(VALUE crashtracking_module);
 
 // Used to report Ruby VM crashes.
 // Once initialized, segfaults will be reported automatically using libdatadog.
 
-void crashtracker_init(VALUE profiling_module) {
-  VALUE crashtracker_class = rb_define_class_under(profiling_module, "Crashtracker", rb_cObject);
+void DDTRACE_EXPORT Init_libdatadog_api(void) {
+  VALUE datadog_module = rb_define_module("Datadog");
+  VALUE core_module = rb_define_module_under(datadog_module, "Core");
+  VALUE crashtracking_module = rb_define_module_under(core_module, "Crashtracking");
+
+  crashtracker_init(crashtracking_module);
+}
+
+void crashtracker_init(VALUE crashtracking_module) {
+  VALUE crashtracker_class = rb_define_class_under(crashtracking_module, "Component", rb_cObject);
 
   rb_define_singleton_method(crashtracker_class, "_native_start_or_update_on_fork", _native_start_or_update_on_fork, -1);
   rb_define_singleton_method(crashtracker_class, "_native_stop", _native_stop, 0);
@@ -38,7 +48,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
 
   if (action != start_action && action != update_on_fork_action) rb_raise(rb_eArgError, "Unexpected action: %+"PRIsVALUE, action);
 
-  VALUE version = ddtrace_version();
+  VALUE version = datadog_gem_version();
   ddog_prof_Endpoint endpoint = endpoint_from(exporter_configuration);
 
   // Tags are heap-allocated, so after here we can't raise exceptions otherwise we'll leak this memory
@@ -59,6 +69,9 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
     .endpoint = endpoint,
     .resolve_frames = DDOG_PROF_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
     .timeout_secs = FIX2INT(upload_timeout_seconds),
+    // Waits for crash tracker to finish reporting the issue before letting the Ruby process die; see
+    // https://github.com/DataDog/libdatadog/pull/477 for details
+    .wait_for_receiver = true,
   };
 
   ddog_prof_CrashtrackerMetadata metadata = {
@@ -83,7 +96,7 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
 
   ddog_prof_CrashtrackerResult result =
     action == start_action ?
-      ddog_prof_Crashtracker_init(config, receiver_config, metadata) :
+      ddog_prof_Crashtracker_init_with_receiver(config, receiver_config, metadata) :
       ddog_prof_Crashtracker_update_on_fork(config, receiver_config, metadata);
 
   // Clean up before potentially raising any exceptions

data/ext/libdatadog_api/datadog_ruby_common.c

@@ -0,0 +1,110 @@
+#include "datadog_ruby_common.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) {
+  rb_exc_raise(
+    rb_exc_new_str(
+      rb_eTypeError,
+      rb_sprintf("wrong argument %"PRIsVALUE" for '%s' (expected a %s) at %s:%d:in `%s'",
+        rb_inspect(value),
+        value_name,
+        type_name,
+        file,
+        line,
+        function_name
+      )
+    )
+  );
+}
+
+VALUE datadog_gem_version(void) {
+  VALUE ddtrace_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
+  ENFORCE_TYPE(ddtrace_module, T_MODULE);
+  VALUE version_module = rb_const_get(ddtrace_module, rb_intern("VERSION"));
+  ENFORCE_TYPE(version_module, T_MODULE);
+  VALUE version_string = rb_const_get(version_module, rb_intern("STRING"));
+  ENFORCE_TYPE(version_string, T_STRING);
+  return version_string;
+}
+
+__attribute__((warn_unused_result))
+ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration) {
+  ENFORCE_TYPE(exporter_configuration, T_ARRAY);
+
+  VALUE exporter_working_mode = rb_ary_entry(exporter_configuration, 0);
+  ENFORCE_TYPE(exporter_working_mode, T_SYMBOL);
+  ID working_mode = SYM2ID(exporter_working_mode);
+
+  ID agentless_id = rb_intern("agentless");
+  ID agent_id = rb_intern("agent");
+
+  if (working_mode != agentless_id && working_mode != agent_id) {
+    rb_raise(rb_eArgError, "Failed to initialize transport: Unexpected working mode, expected :agentless or :agent");
+  }
+
+  if (working_mode == agentless_id) {
+    VALUE site = rb_ary_entry(exporter_configuration, 1);
+    VALUE api_key = rb_ary_entry(exporter_configuration, 2);
+
+    return ddog_prof_Endpoint_agentless(char_slice_from_ruby_string(site), char_slice_from_ruby_string(api_key));
+  } else { // agent_id
+    VALUE base_url = rb_ary_entry(exporter_configuration, 1);
+
+    return ddog_prof_Endpoint_agent(char_slice_from_ruby_string(base_url));
+  }
+}
+
+static VALUE log_failure_to_process_tag(VALUE err_details) {
+  VALUE datadog_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
+  VALUE logger = rb_funcall(datadog_module, rb_intern("logger"), 0);
+
+  return rb_funcall(logger, rb_intern("warn"), 1, rb_sprintf("Failed to convert tag: %"PRIsVALUE, err_details));
+}
+
+__attribute__((warn_unused_result))
+ddog_Vec_Tag convert_tags(VALUE tags_as_array) {
+  ENFORCE_TYPE(tags_as_array, T_ARRAY);
+
+  long tags_count = RARRAY_LEN(tags_as_array);
+  ddog_Vec_Tag tags = ddog_Vec_Tag_new();
+
+  for (long i = 0; i < tags_count; i++) {
+    VALUE name_value_pair = rb_ary_entry(tags_as_array, i);
+
+    if (!RB_TYPE_P(name_value_pair, T_ARRAY)) {
+      ddog_Vec_Tag_drop(tags);
+      ENFORCE_TYPE(name_value_pair, T_ARRAY);
+    }
+
+    // Note: We can index the array without checking its size first because rb_ary_entry returns Qnil if out of bounds
+    VALUE tag_name = rb_ary_entry(name_value_pair, 0);
+    VALUE tag_value = rb_ary_entry(name_value_pair, 1);
+
+    if (!(RB_TYPE_P(tag_name, T_STRING) && RB_TYPE_P(tag_value, T_STRING))) {
+      ddog_Vec_Tag_drop(tags);
+      ENFORCE_TYPE(tag_name, T_STRING);
+      ENFORCE_TYPE(tag_value, T_STRING);
+    }
+
+    ddog_Vec_Tag_PushResult push_result =
+      ddog_Vec_Tag_push(&tags, char_slice_from_ruby_string(tag_name), char_slice_from_ruby_string(tag_value));
+
+    if (push_result.tag == DDOG_VEC_TAG_PUSH_RESULT_ERR) {
+      // libdatadog validates tags and may catch invalid tags that ddtrace didn't actually catch.
+      // We warn users about such tags, and then just ignore them.
+
+      int exception_state;
+      rb_protect(log_failure_to_process_tag, get_error_details_and_drop(&push_result.err), &exception_state);
+
+      // Since we are calling into Ruby code, it may raise an exception. Ensure that dynamically-allocated tags
+      // get cleaned before propagating the exception.
+      if (exception_state) {
+        ddog_Vec_Tag_drop(tags);
+        rb_jump_tag(exception_state);  // "Re-raise" exception
+      }
+    }
+  }
+
+  return tags;
+}

data/ext/libdatadog_api/datadog_ruby_common.h

@@ -0,0 +1,57 @@
+#pragma once
+
+// IMPORTANT: Currently this file is copy-pasted between extensions. Make sure to update all versions when doing any change!
+
+#include <ruby.h>
+#include <datadog/profiling.h>
+
+// 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")))
+
+// Used to mark function arguments that are deliberately left unused
+#ifdef __GNUC__
+  #define DDTRACE_UNUSED  __attribute__((unused))
+#else
+  #define DDTRACE_UNUSED
+#endif
+
+#define ADD_QUOTES_HELPER(x) #x
+#define ADD_QUOTES(x) ADD_QUOTES_HELPER(x)
+
+// Ruby has a Check_Type(value, type) that is roughly equivalent to this BUT Ruby's version is rather cryptic when it fails
+// e.g. "wrong argument type nil (expected String)". This is a replacement that prints more information to help debugging.
+#define ENFORCE_TYPE(value, type) \
+  { if (RB_UNLIKELY(!RB_TYPE_P(value, type))) raise_unexpected_type(value, ADD_QUOTES(value), ADD_QUOTES(type), __FILE__, __LINE__, __func__); }
+
+#define ENFORCE_BOOLEAN(value) \
+  { if (RB_UNLIKELY(value != Qtrue && value != Qfalse)) raise_unexpected_type(value, ADD_QUOTES(value), "true or false", __FILE__, __LINE__, __func__); }
+
+// Called by ENFORCE_TYPE; should not be used directly
+NORETURN(void raise_unexpected_type(VALUE value, const char *value_name, const char *type_name, const char *file, int line, const char* function_name));
+
+// Helper to retrieve Datadog::VERSION::STRING
+VALUE datadog_gem_version(void);
+
+static inline ddog_CharSlice char_slice_from_ruby_string(VALUE string) {
+  ENFORCE_TYPE(string, T_STRING);
+  ddog_CharSlice char_slice = {.ptr = RSTRING_PTR(string), .len = RSTRING_LEN(string)};
+  return char_slice;
+}
+
+__attribute__((warn_unused_result))
+ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration);
+
+__attribute__((warn_unused_result))
+ddog_Vec_Tag convert_tags(VALUE tags_as_array);
+
+static inline VALUE ruby_string_from_error(const ddog_Error *error) {
+  ddog_CharSlice char_slice = ddog_Error_message(error);
+  return rb_str_new(char_slice.ptr, char_slice.len);
+}
+
+static inline VALUE get_error_details_and_drop(ddog_Error *error) {
+  VALUE result = ruby_string_from_error(error);
+  ddog_Error_drop(error);
+  return result;
+}

data/ext/libdatadog_api/extconf.rb

@@ -0,0 +1,108 @@
+# rubocop:disable Style/StderrPuts
+# rubocop:disable Style/GlobalVars
+
+require 'rubygems'
+require_relative '../libdatadog_extconf_helpers'
+
+def skip_building_extension!(reason)
+  $stderr.puts(
+    "WARN: Skipping build of libdatadog_api (#{reason}). Some functionality will not be available."
+  )
+
+  fail_install_if_missing_extension = ENV['DD_FAIL_INSTALL_IF_MISSING_EXTENSION'].to_s.strip.downcase == 'true'
+
+  if fail_install_if_missing_extension
+    require 'mkmf'
+    Logging.message("[datadog] Failure cause: #{reason}")
+  else
+    File.write('Makefile', 'all install clean: # dummy makefile that does nothing')
+  end
+
+  exit
+end
+
+if ENV['DD_NO_EXTENSION'].to_s.strip.downcase == 'true'
+  skip_building_extension!('the `DD_NO_EXTENSION` environment variable is/was set to `true` during installation')
+end
+skip_building_extension!('current Ruby VM is not supported') if RUBY_ENGINE != 'ruby'
+skip_building_extension!('Microsoft Windows is not supported') if Gem.win_platform?
+skip_building_extension!('issue setting up `libdatadog` gem') if Datadog::LibdatadogExtconfHelpers.libdatadog_issue?
+
+require 'mkmf'
+
+# Because we can't control what compiler versions our customers use, shipping with -Werror by default is a no-go.
+# But we can enable it in CI, so that we quickly spot any new warnings that just got introduced.
+append_cflags '-Werror' if ENV['DATADOG_GEM_CI'] == 'true'
+
+# Older gcc releases may not default to C99 and we need to ask for this. This is also used:
+# * 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'
+
+# Allow defining variables at any point in a function
+append_cflags '-Wno-declaration-after-statement'
+
+# If we forget to include a Ruby header, the function call may still appear to work, but then
+# cause a segfault later. Let's ensure that never happens.
+append_cflags '-Werror-implicit-function-declaration'
+
+# Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.
+append_cflags '-Wunused-parameter'
+
+# The native extension is not intended to expose any symbols/functions for other native libraries to use;
+# the sole exception being `Init_libdatadog_api` which needs to be visible for Ruby to call it when
+# it `dlopen`s the library.
+#
+# By setting this compiler flag, we tell it to assume that everything is private unless explicitly stated.
+# For more details see https://gcc.gnu.org/wiki/Visibility
+append_cflags '-fvisibility=hidden'
+
+# Avoid legacy C definitions
+append_cflags '-Wold-style-definition'
+
+# Enable all other compiler warnings
+append_cflags '-Wall'
+append_cflags '-Wextra'
+
+if ENV['DDTRACE_DEBUG'] == 'true'
+  $defs << '-DDD_DEBUG'
+  CONFIG['optflags'] = '-O0'
+  CONFIG['debugflags'] = '-ggdb3'
+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
+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.
+# When requiring, we need to use the exact same string, including the version and the platform.
+EXTENSION_NAME = "libdatadog_api.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}".freeze
+
+create_makefile(EXTENSION_NAME)
+
+# rubocop:enable Style/GlobalVars
+# rubocop:enable Style/StderrPuts

data/ext/libdatadog_api/macos_development.md

@@ -0,0 +1,26 @@
+# Developing on macOS
+
+As of this writing (August 2024), the libdatadog builds on rubygems.org only support Linux.
+
+We don't officially support using libdatadog for Ruby on other platforms yet, but it is possible to use it for local development on macOS.
+(**Note that you don't need these instructions if you develop inside docker.**)
+
+Here's how you can do so:
+
+1. [Install rust](https://www.rust-lang.org/tools/install)
+2. Install `cbindgen`: `cargo install cbindgen`
+3. Clone [libdatadog](https://github.com/datadog/libdatadog)
+4. Create a folder for building into based on your ruby platform:
+
+```
+export DD_RUBY_PLATFORM=`ruby -e 'puts Gem::Platform.local.to_s'`
+mkdir -p my-libdatadog-build/$DD_RUBY_PLATFORM
+```
+
+5. Build libdatadog into this folder: `./build-profiling-ffi.sh my-libdatadog-build/$DD_RUBY_PLATFORM`
+6. Tell the Ruby where to find libdatadog: `export LIBDATADOG_VENDOR_OVERRIDE=/full/path/to/my-libdatadog-build/` (Notice no platform here)
+7. Run `bundle exec rake clean compile`
+
+If you additionally want to run the profiler test suite, also remember to `export DD_PROFILING_MACOS_TESTING=true` and re-run `rake clean compile`.
+
+These instructions can quickly get outdated, so feel free to open an issue if they're not working (and/or ping @ivoanjo).