datadog 2.0.0.beta1 → 2.0.0.rc1

data/ext/datadog_profiling_native_extension/crashtracker.c

@@ -0,0 +1,108 @@
+#include <ruby.h>
+#include <datadog/common.h>
+#include <libdatadog_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);
+
+// 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);
+
+  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);
+}
+
+static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUSED VALUE _self) {
+  VALUE options;
+  rb_scan_args(argc, argv, "0:", &options);
+
+  VALUE exporter_configuration = rb_hash_fetch(options, ID2SYM(rb_intern("exporter_configuration")));
+  VALUE path_to_crashtracking_receiver_binary = rb_hash_fetch(options, ID2SYM(rb_intern("path_to_crashtracking_receiver_binary")));
+  VALUE ld_library_path = rb_hash_fetch(options, ID2SYM(rb_intern("ld_library_path")));
+  VALUE tags_as_array = rb_hash_fetch(options, ID2SYM(rb_intern("tags_as_array")));
+  VALUE action = rb_hash_fetch(options, ID2SYM(rb_intern("action")));
+  VALUE upload_timeout_seconds = rb_hash_fetch(options, ID2SYM(rb_intern("upload_timeout_seconds")));
+
+  VALUE start_action = ID2SYM(rb_intern("start"));
+  VALUE update_on_fork_action = ID2SYM(rb_intern("update_on_fork"));
+
+  ENFORCE_TYPE(exporter_configuration, T_ARRAY);
+  ENFORCE_TYPE(tags_as_array, T_ARRAY);
+  ENFORCE_TYPE(path_to_crashtracking_receiver_binary, T_STRING);
+  ENFORCE_TYPE(ld_library_path, T_STRING);
+  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);
+
+  VALUE version = ddtrace_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
+  // Start of exception-free zone to prevent leaks {{
+  ddog_Vec_Tag tags = convert_tags(tags_as_array);
+
+  ddog_prof_CrashtrackerConfiguration config = {
+    .additional_files = {},
+    // The Ruby VM already uses an alt stack to detect stack overflows so the crash handler must not overwrite it.
+    //
+    // @ivoanjo: Specifically, with `create_alt_stack = true` I saw a segfault, such as Ruby 2.6's bug with
+    // "Process.detach(fork { exit! }).instance_variable_get(:@foo)" being turned into a
+    // "-e:1:in `instance_variable_get': stack level too deep (SystemStackError)" by Ruby.
+    //
+    // The Ruby crash handler also seems to get confused when this option is enabled and
+    // "Process.kill('SEGV', Process.pid)" gets run.
+    .create_alt_stack = false,
+    .endpoint = endpoint,
+    .resolve_frames = DDOG_PROF_STACKTRACE_COLLECTION_ENABLED,
+    .timeout_secs = FIX2INT(upload_timeout_seconds),
+  };
+
+  ddog_prof_CrashtrackerMetadata metadata = {
+    .profiling_library_name = DDOG_CHARSLICE_C("dd-trace-rb"),
+    .profiling_library_version = char_slice_from_ruby_string(version),
+    .family = DDOG_CHARSLICE_C("ruby"),
+    .tags = &tags,
+  };
+
+  ddog_prof_EnvVar ld_library_path_env = {
+    .key = DDOG_CHARSLICE_C("LD_LIBRARY_PATH"),
+    .val = char_slice_from_ruby_string(ld_library_path),
+  };
+
+  ddog_prof_CrashtrackerReceiverConfig receiver_config = {
+    .args = {},
+    .env = {.ptr = &ld_library_path_env, .len = 1},
+    .path_to_receiver_binary = char_slice_from_ruby_string(path_to_crashtracking_receiver_binary),
+    .optional_stderr_filename = {},
+    .optional_stdout_filename = {},
+  };
+
+  ddog_prof_CrashtrackerResult result =
+    action == start_action ?
+      ddog_prof_Crashtracker_init(config, receiver_config, metadata) :
+      ddog_prof_Crashtracker_update_on_fork(config, receiver_config, metadata);
+
+  // Clean up before potentially raising any exceptions
+  ddog_Vec_Tag_drop(tags);
+  // }} End of exception-free zone to prevent leaks
+
+  if (result.tag == DDOG_PROF_CRASHTRACKER_RESULT_ERR) {
+    rb_raise(rb_eRuntimeError, "Failed to start/update the crash tracker: %"PRIsVALUE, get_error_details_and_drop(&result.err));
+  }
+
+  return Qtrue;
+}
+
+static VALUE _native_stop(DDTRACE_UNUSED VALUE _self) {
+  ddog_prof_CrashtrackerResult result = ddog_prof_Crashtracker_shutdown();
+
+  if (result.tag == DDOG_PROF_CRASHTRACKER_RESULT_ERR) {
+    rb_raise(rb_eRuntimeError, "Failed to stop the crash tracker: %"PRIsVALUE, get_error_details_and_drop(&result.err));
+  }
+
+  return Qtrue;
+}

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -126,7 +126,7 @@ if RUBY_PLATFORM.include?('linux')
   # have_library 'pthread'
   # have_func 'pthread_getcpuclockid'
   # ```
-  # but a) it broke the build on Windows, b) on older Ruby versions (2.2 and below) and c) It's slower to build
+  # but it's slower to build
   # so instead we just assume that we have the function we need on Linux, and nowhere else
   $defs << '-DHAVE_PTHREAD_GETCPUCLOCKID'
 end
@@ -163,6 +163,11 @@ $defs << '-DNO_THREAD_TID' if RUBY_VERSION < '3.1'
 # On older Rubies, there was no jit_return member on the rb_control_frame_t struct
 $defs << '-DNO_JIT_RETURN' if RUBY_VERSION < '3.1'
 
+# On older Rubies, rb_gc_force_recycle allowed to free objects in a way that
+# would be invisible to free tracepoints, finalizers and without cleaning
+# obj_to_id_tbl mappings.
+$defs << '-DHAVE_WORKING_RB_GC_FORCE_RECYCLE' if RUBY_VERSION < '3.1'
+
 # On older Rubies, we need to use a backported version of this function. See private_vm_api_access.h for details.
 $defs << '-DUSE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME' if RUBY_VERSION < '3'
 
@@ -175,34 +180,15 @@ $defs << '-DNO_IMEMO_NAME' if RUBY_VERSION < '3'
 # On older Rubies, objects would not move
 $defs << '-DNO_T_MOVED' if RUBY_VERSION < '2.7'
 
+# On older Rubies, there was no RUBY_SEEN_OBJ_ID flag
+$defs << '-DNO_SEEN_OBJ_ID_FLAG' if RUBY_VERSION < '2.7'
+
 # On older Rubies, rb_global_vm_lock_struct did not include the owner field
 $defs << '-DNO_GVL_OWNER' if RUBY_VERSION < '2.6'
 
 # On older Rubies, there was no thread->invoke_arg
 $defs << '-DNO_THREAD_INVOKE_ARG' if RUBY_VERSION < '2.6'
 
-# On older Rubies, we need to use rb_thread_t instead of rb_execution_context_t
-$defs << '-DUSE_THREAD_INSTEAD_OF_EXECUTION_CONTEXT' if RUBY_VERSION < '2.5'
-
-# On older Rubies, extensions can't use GET_VM()
-$defs << '-DNO_GET_VM' if RUBY_VERSION < '2.5'
-
-# On older Rubies...
-if RUBY_VERSION < '2.4'
-  # ...we need to use RUBY_VM_NORMAL_ISEQ_P instead of VM_FRAME_RUBYFRAME_P
-  $defs << '-DUSE_ISEQ_P_INSTEAD_OF_RUBYFRAME_P'
-  # ...we use a legacy copy of rb_vm_frame_method_entry
-  $defs << '-DUSE_LEGACY_RB_VM_FRAME_METHOD_ENTRY'
-end
-
-# On older Rubies, rb_gc_force_recycle allowed to free objects in a way that
-# would be invisible to free tracepoints, finalizers and without cleaning
-# obj_to_id_tbl mappings.
-$defs << '-DHAVE_WORKING_RB_GC_FORCE_RECYCLE' if RUBY_VERSION < '3.1'
-
-# On older Rubies, there was no RUBY_SEEN_OBJ_ID flag
-$defs << '-DNO_SEEN_OBJ_ID_FLAG' if RUBY_VERSION < '2.7'
-
 # 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")

data/ext/datadog_profiling_native_extension/heap_recorder.c

@@ -10,6 +10,13 @@
   #define CAN_APPLY_GC_FORCE_RECYCLE_BUG_WORKAROUND
 #endif
 
+// Minimum age (in GC generations) of heap objects we want to include in heap
+// recorder iterations. Object with age 0 represent objects that have yet to undergo
+// a GC and, thus, may just be noise/trash at instant of iteration and are usually not
+// relevant for heap profiles as the great majority should be trivially reclaimed
+// during the next GC.
+#define ITERATION_MIN_AGE 1
+
 // A compact representation of a stacktrace frame for a heap allocation.
 typedef struct {
   char *name;
@@ -137,6 +144,11 @@ struct heap_recorder {
   // mutation of the data so iteration can occur without acquiring a lock.
   // NOTE: Contrary to object_records, this table has no ownership of its data.
   st_table *object_records_snapshot;
+  // The GC gen/epoch/count in which we prepared the current iteration.
+  //
+  // This enables us to calculate the age of iterated objects in the above snapshot by
+  // comparing it against an object's alloc_gen.
+  size_t iteration_gen;
 
   // Data for a heap recording that was started but not yet ended
   recording active_recording;
@@ -146,6 +158,13 @@ struct heap_recorder {
 
   // Sampling state
   uint num_recordings_skipped;
+
+  struct stats_last_update {
+    size_t objects_alive;
+    size_t objects_dead;
+    size_t objects_skipped;
+    size_t objects_frozen;
+  } stats_last_update;
 };
 static heap_record* get_or_create_heap_record(heap_recorder*, ddog_prof_Slice_Location);
 static void cleanup_heap_record_if_unused(heap_recorder*, heap_record*);
@@ -353,11 +372,16 @@ void heap_recorder_prepare_iteration(heap_recorder *heap_recorder) {
     return;
   }
 
+  heap_recorder->iteration_gen = rb_gc_count();
+
   if (heap_recorder->object_records_snapshot != NULL) {
     // we could trivially handle this but we raise to highlight and catch unexpected usages.
     rb_raise(rb_eRuntimeError, "New heap recorder iteration prepared without the previous one having been finished.");
   }
 
+  // Reset last update stats, we'll be building them from scratch during the st_foreach call below
+  heap_recorder->stats_last_update = (struct stats_last_update) {};
+
   st_foreach(heap_recorder->object_records, st_object_record_update, (st_data_t) heap_recorder);
 
   heap_recorder->object_records_snapshot = st_copy(heap_recorder->object_records);
@@ -413,6 +437,22 @@ bool heap_recorder_for_each_live_object(
   return true;
 }
 
+VALUE heap_recorder_state_snapshot(heap_recorder *heap_recorder) {
+  VALUE arguments[] = {
+    ID2SYM(rb_intern("num_object_records")), /* => */ LONG2NUM(heap_recorder->object_records->num_entries),
+    ID2SYM(rb_intern("num_heap_records")),   /* => */ LONG2NUM(heap_recorder->heap_records->num_entries),
+
+    // Stats as of last update
+    ID2SYM(rb_intern("last_update_objects_alive")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_alive),
+    ID2SYM(rb_intern("last_update_objects_dead")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_dead),
+    ID2SYM(rb_intern("last_update_objects_skipped")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_skipped),
+    ID2SYM(rb_intern("last_update_objects_frozen")), /* => */ LONG2NUM(heap_recorder->stats_last_update.objects_frozen),
+  };
+  VALUE hash = rb_hash_new();
+  for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(hash, arguments[i], arguments[i+1]);
+  return hash;
+}
+
 void heap_recorder_testonly_assert_hash_matches(ddog_prof_Slice_Location locations) {
   heap_stack *stack = heap_stack_new(locations);
   heap_record_key stack_based_key = (heap_record_key) {
@@ -459,6 +499,13 @@ static int st_object_record_entry_free(DDTRACE_UNUSED st_data_t key, st_data_t v
   return ST_DELETE;
 }
 
+// Check to see if an object should not be included in a heap recorder iteration.
+// This centralizes the checking logic to ensure it's equally applied between
+// preparation and iteration codepaths.
+static inline bool should_exclude_from_iteration(object_record *obj_record) {
+  return obj_record->object_data.gen_age < ITERATION_MIN_AGE;
+}
+
 static int st_object_record_update(st_data_t key, st_data_t value, st_data_t extra_arg) {
   long obj_id = (long) key;
   object_record *record = (object_record*) value;
@@ -466,9 +513,24 @@ static int st_object_record_update(st_data_t key, st_data_t value, st_data_t ext
 
   VALUE ref;
 
+  size_t iteration_gen = recorder->iteration_gen;
+  size_t alloc_gen = record->object_data.alloc_gen;
+  // Guard against potential overflows given unsigned types here.
+  record->object_data.gen_age = alloc_gen < iteration_gen ? iteration_gen - alloc_gen : 0;
+
+  if (should_exclude_from_iteration(record)) {
+    // If an object won't be included in the current iteration, there's
+    // no point checking for liveness or updating its size, so exit early.
+    // NOTE: This means that there should be an equivalent check during actual
+    //       iteration otherwise we'd iterate/expose stale object data.
+    recorder->stats_last_update.objects_skipped++;
+    return ST_CONTINUE;
+  }
+
   if (!ruby_ref_from_id(LONG2NUM(obj_id), &ref)) {
     // Id no longer associated with a valid ref. Need to delete this object record!
     on_committed_object_record_cleanup(recorder, record);
+    recorder->stats_last_update.objects_dead++;
     return ST_DELETE;
   }
 
@@ -503,6 +565,7 @@ static int st_object_record_update(st_data_t key, st_data_t value, st_data_t ext
       RB_FL_SET(ref, RUBY_FL_SEEN_OBJ_ID);
 
       on_committed_object_record_cleanup(recorder, record);
+      recorder->stats_last_update.objects_dead++;
       return ST_DELETE;
     }
 
@@ -516,6 +579,11 @@ static int st_object_record_update(st_data_t key, st_data_t value, st_data_t ext
     record->object_data.is_frozen = RB_OBJ_FROZEN(ref);
   }
 
+  recorder->stats_last_update.objects_alive++;
+  if (record->object_data.is_frozen) {
+    recorder->stats_last_update.objects_frozen++;
+  }
+
   return ST_CONTINUE;
 }
 
@@ -525,8 +593,16 @@ static int st_object_records_iterate(DDTRACE_UNUSED st_data_t key, st_data_t val
   const heap_stack *stack = record->heap_record->stack;
   iteration_context *context = (iteration_context*) extra;
 
-  ddog_prof_Location *locations = context->heap_recorder->reusable_locations;
+  const heap_recorder *recorder = context->heap_recorder;
+
+  if (should_exclude_from_iteration(record)) {
+    // Skip objects that should not be included in iteration
+    // NOTE: This matches the short-circuiting condition in st_object_record_update
+    //       and prevents iteration over stale objects.
+    return ST_CONTINUE;
+  }
 
+  ddog_prof_Location *locations = recorder->reusable_locations;
   for (uint16_t i = 0; i < stack->frames_len; i++) {
     const heap_frame *frame = &stack->frames[i];
     ddog_prof_Location *location = &locations[i];
@@ -725,9 +801,10 @@ void object_record_free(object_record *record) {
 
 VALUE object_record_inspect(object_record *record) {
   heap_frame top_frame = record->heap_record->stack->frames[0];
-  VALUE inspect = rb_sprintf("obj_id=%ld weight=%d size=%zu location=%s:%d alloc_gen=%zu ",
-      record->obj_id, record->object_data.weight, record->object_data.size, top_frame.filename,
-      (int) top_frame.line, record->object_data.alloc_gen);
+  live_object_data object_data = record->object_data;
+  VALUE inspect = rb_sprintf("obj_id=%ld weight=%d size=%zu location=%s:%d alloc_gen=%zu gen_age=%zu frozen=%d ",
+      record->obj_id, object_data.weight, object_data.size, top_frame.filename,
+      (int) top_frame.line, object_data.alloc_gen, object_data.gen_age, object_data.is_frozen);
 
   const char *class = record->object_data.class;
   if (class != NULL) {

data/ext/datadog_profiling_native_extension/heap_recorder.h

@@ -27,7 +27,9 @@ typedef struct live_object_data {
   //          could be seen as being representative of 50 objects.
   unsigned int weight;
 
-  // Size of this object on last flush/update.
+  // Size of this object in memory.
+  // NOTE: This only gets updated during heap_recorder_prepare_iteration and only
+  //       for those objects that meet the minimum iteration age requirements.
   size_t size;
 
   // The class of the object that we're tracking.
@@ -39,6 +41,10 @@ typedef struct live_object_data {
   // This enables us to calculate the age of this object in terms of GC executions.
   size_t alloc_gen;
 
+  // The age of this object in terms of GC generations.
+  // NOTE: This only gets updated during heap_recorder_prepare_iteration
+  size_t gen_age;
+
   // Whether this object was previously seen as being frozen. If this is the case,
   // we'll skip any further size updates since frozen objects are supposed to be
   // immutable.
@@ -144,6 +150,11 @@ bool heap_recorder_for_each_live_object(
     bool (*for_each_callback)(heap_recorder_iteration_data data, void* extra_arg),
     void *for_each_callback_extra_arg);
 
+// Return a Ruby hash containing a snapshot of this recorder's interesting state at calling time.
+// WARN: This allocates in the Ruby VM and therefore should not be called without the
+//       VM lock or during GC.
+VALUE heap_recorder_state_snapshot(heap_recorder *heap_recorder);
+
 // v--- TEST-ONLY APIs ---v
 
 // Assert internal hashing logic is valid for the provided locations and its

data/ext/datadog_profiling_native_extension/http_transport.c

@@ -11,11 +11,6 @@
 static VALUE ok_symbol = Qnil; // :ok in Ruby
 static VALUE error_symbol = Qnil; // :error in Ruby
 
-static ID agentless_id; // id of :agentless in Ruby
-static ID agent_id; // id of :agent in Ruby
-
-static ID log_failure_to_process_tag_id; // id of :log_failure_to_process_tag in Ruby
-
 static VALUE library_version_string = Qnil;
 
 struct call_exporter_without_gvl_arguments {
@@ -30,9 +25,6 @@ inline static ddog_ByteSlice byte_slice_from_ruby_string(VALUE string);
 static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration);
 static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
 static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_result);
-static ddog_Endpoint endpoint_from(VALUE exporter_configuration);
-static ddog_Vec_Tag convert_tags(VALUE tags_as_array);
-static void safely_log_failure_to_process_tag(ddog_Vec_Tag tags, VALUE err_details);
 static VALUE _native_do_export(
   VALUE self,
   VALUE exporter_configuration,
@@ -60,9 +52,6 @@ void http_transport_init(VALUE profiling_module) {
 
   ok_symbol = ID2SYM(rb_intern_const("ok"));
   error_symbol = ID2SYM(rb_intern_const("error"));
-  agentless_id = rb_intern_const("agentless");
-  agent_id = rb_intern_const("agent");
-  log_failure_to_process_tag_id = rb_intern_const("log_failure_to_process_tag");
 
   library_version_string = ddtrace_version();
   rb_global_variable(&library_version_string);
@@ -94,7 +83,7 @@ static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration
 
   // This needs to be called BEFORE convert_tags since it can raise an exception and thus cause the ddog_Vec_Tag
   // to be leaked.
-  ddog_Endpoint endpoint = endpoint_from(exporter_configuration);
+  ddog_prof_Endpoint endpoint = endpoint_from(exporter_configuration);
 
   ddog_Vec_Tag tags = convert_tags(tags_as_array);
 
@@ -116,88 +105,6 @@ static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_resul
     rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&exporter_result.err));
 }
 
-static ddog_Endpoint endpoint_from(VALUE exporter_configuration) {
-  ENFORCE_TYPE(exporter_configuration, T_ARRAY);
-
-  ID working_mode = SYM2ID(rb_ary_entry(exporter_configuration, 0)); // SYM2ID verifies its input so we can do this safely
-
-  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);
-    ENFORCE_TYPE(site, T_STRING);
-    ENFORCE_TYPE(api_key, T_STRING);
-
-    return ddog_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);
-    ENFORCE_TYPE(base_url, T_STRING);
-
-    return ddog_Endpoint_agent(char_slice_from_ruby_string(base_url));
-  }
-}
-
-__attribute__((warn_unused_result))
-static 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.
-      safely_log_failure_to_process_tag(tags, get_error_details_and_drop(&push_result.err));
-    }
-  }
-
-  return tags;
-}
-
-static VALUE log_failure_to_process_tag(VALUE err_details) {
-  VALUE datadog_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
-  VALUE profiling_module = rb_const_get(datadog_module, rb_intern("Profiling"));
-  VALUE http_transport_class = rb_const_get(profiling_module, rb_intern("HttpTransport"));
-
-  return rb_funcall(http_transport_class, log_failure_to_process_tag_id, 1, err_details);
-}
-
-// Since we are calling into Ruby code, it may raise an exception. This method ensure that dynamically-allocated tags
-// get cleaned before propagating the exception.
-static void safely_log_failure_to_process_tag(ddog_Vec_Tag tags, VALUE err_details) {
-  int exception_state;
-  rb_protect(log_failure_to_process_tag, err_details, &exception_state);
-
-  if (exception_state) {           // An exception was raised
-    ddog_Vec_Tag_drop(tags); // clean up
-    rb_jump_tag(exception_state);  // "Re-raise" exception
-  }
-}
-
 // Note: This function handles a bunch of libdatadog dynamically-allocated objects, so it MUST not use any Ruby APIs
 // which can raise exceptions, otherwise the objects will be leaked.
 static VALUE perform_export(

data/ext/datadog_profiling_native_extension/libdatadog_helpers.c

@@ -2,6 +2,8 @@
 
 #include <ruby.h>
 
+static VALUE log_failure_to_process_tag(VALUE err_details);
+
 const char *ruby_value_type_to_string(enum ruby_value_type type) {
   return ruby_value_type_to_char_slice(type).ptr;
 }
@@ -60,3 +62,87 @@ size_t read_ddogerr_string_and_drop(ddog_Error *error, char *string, size_t capa
   ddog_Error_drop(error);
   return error_msg_size;
 }
+
+__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);
+    ENFORCE_TYPE(site, T_STRING);
+    ENFORCE_TYPE(api_key, T_STRING);
+
+    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);
+    ENFORCE_TYPE(base_url, T_STRING);
+
+    return ddog_prof_Endpoint_agent(char_slice_from_ruby_string(base_url));
+  }
+}
+
+__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;
+}
+
+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 add tag to profiling request: %"PRIsVALUE, err_details));
+}

data/ext/datadog_profiling_native_extension/libdatadog_helpers.h

@@ -40,3 +40,7 @@ ddog_CharSlice ruby_value_type_to_char_slice(enum ruby_value_type type);
 inline static char* string_from_char_slice(ddog_CharSlice slice) {
   return ruby_strndup(slice.ptr, slice.len);
 }
+
+ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration);
+
+ddog_Vec_Tag convert_tags(VALUE tags_as_array);

data/ext/datadog_profiling_native_extension/native_extension_helpers.rb

@@ -15,7 +15,7 @@ module Datadog
       # The MJIT header was introduced on 2.6 and removed on 3.3; for other Rubies we rely on debase-ruby_core_source
       CAN_USE_MJIT_HEADER = RUBY_VERSION.start_with?('2.6', '2.7', '3.0.', '3.1.', '3.2.')
 
-      LIBDATADOG_VERSION = '~> 6.0.0.2.0'
+      LIBDATADOG_VERSION = '~> 9.0.0.1.0'
 
       def self.fail_install_if_missing_extension?
         ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == 'true'
@@ -86,7 +86,6 @@ module Datadog
             on_macos? ||
             on_unknown_os? ||
             on_unsupported_cpu_arch? ||
-            on_unsupported_ruby_version? ||
             expected_to_use_mjit_but_mjit_is_disabled? ||
             libdatadog_not_available? ||
             libdatadog_not_usable?
@@ -166,7 +165,7 @@ module Datadog
 
         # 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;',
@@ -260,15 +259,6 @@ module Datadog
           architecture_not_supported unless RUBY_PLATFORM.start_with?('x86_64', 'aarch64', 'arm64')
         end
 
-        private_class_method def self.on_unsupported_ruby_version?
-          ruby_version_not_supported = explain_issue(
-            'the profiler only supports Ruby 2.3 or newer.',
-            suggested: UPGRADE_RUBY,
-          )
-
-          ruby_version_not_supported if RUBY_VERSION.start_with?('2.1.', '2.2.')
-        end
-
         # On some Rubies, we require the mjit header to be present. If Ruby was installed without MJIT support, we also skip
         # building the extension.
         private_class_method def self.expected_to_use_mjit_but_mjit_is_disabled?