ddtrace 1.1.0 → 1.2.0

data/ext/ddtrace_profiling_native_extension/http_transport.c

@@ -0,0 +1,341 @@
+#include <ruby.h>
+#include <ruby/thread.h>
+#include <ddprof/ffi.h>
+#include "libddprof_helpers.h"
+#include "ruby_helpers.h"
+
+// Used to report profiling data to Datadog.
+// This file implements the native bits of the Datadog::Profiling::HttpTransport class
+
+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 http_transport_class = Qnil;
+
+struct call_exporter_without_gvl_arguments {
+  ddprof_ffi_ProfileExporterV3 *exporter;
+  ddprof_ffi_Request *request;
+  ddprof_ffi_CancellationToken *cancel_token;
+  ddprof_ffi_SendResult result;
+  bool send_ran;
+};
+
+inline static ddprof_ffi_ByteSlice byte_slice_from_ruby_string(VALUE string);
+static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration);
+static ddprof_ffi_NewProfileExporterV3Result create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
+static VALUE handle_exporter_failure(ddprof_ffi_NewProfileExporterV3Result exporter_result);
+static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration);
+static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array);
+static void safely_log_failure_to_process_tag(ddprof_ffi_Vec_tag tags, VALUE err_details);
+static VALUE _native_do_export(
+  VALUE self,
+  VALUE exporter_configuration,
+  VALUE upload_timeout_milliseconds,
+  VALUE start_timespec_seconds,
+  VALUE start_timespec_nanoseconds,
+  VALUE finish_timespec_seconds,
+  VALUE finish_timespec_nanoseconds,
+  VALUE pprof_file_name,
+  VALUE pprof_data,
+  VALUE code_provenance_file_name,
+  VALUE code_provenance_data,
+  VALUE tags_as_array
+);
+static void *call_exporter_without_gvl(void *call_args);
+static void interrupt_exporter_call(void *cancel_token);
+
+void http_transport_init(VALUE profiling_module) {
+  http_transport_class = rb_define_class_under(profiling_module, "HttpTransport", rb_cObject);
+
+  rb_define_singleton_method(http_transport_class, "_native_validate_exporter",  _native_validate_exporter, 1);
+  rb_define_singleton_method(http_transport_class, "_native_do_export",  _native_do_export, 11);
+
+  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");
+}
+
+inline static ddprof_ffi_ByteSlice byte_slice_from_ruby_string(VALUE string) {
+  Check_Type(string, T_STRING);
+  ddprof_ffi_ByteSlice byte_slice = {.ptr = (uint8_t *) StringValuePtr(string), .len = RSTRING_LEN(string)};
+  return byte_slice;
+}
+
+static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration) {
+  Check_Type(exporter_configuration, T_ARRAY);
+  ddprof_ffi_NewProfileExporterV3Result exporter_result = create_exporter(exporter_configuration, rb_ary_new());
+
+  VALUE failure_tuple = handle_exporter_failure(exporter_result);
+  if (!NIL_P(failure_tuple)) return failure_tuple;
+
+  // We don't actually need the exporter for now -- we just wanted to validate that we could create it with the
+  // settings we were given
+  ddprof_ffi_NewProfileExporterV3Result_drop(exporter_result);
+
+  return rb_ary_new_from_args(2, ok_symbol, Qnil);
+}
+
+static ddprof_ffi_NewProfileExporterV3Result create_exporter(VALUE exporter_configuration, VALUE tags_as_array) {
+  Check_Type(exporter_configuration, T_ARRAY);
+  Check_Type(tags_as_array, T_ARRAY);
+
+  // This needs to be called BEFORE convert_tags since it can raise an exception and thus cause the ddprof_ffi_Vec_tag
+  // to be leaked.
+  ddprof_ffi_EndpointV3 endpoint = endpoint_from(exporter_configuration);
+
+  ddprof_ffi_Vec_tag tags = convert_tags(tags_as_array);
+
+  ddprof_ffi_NewProfileExporterV3Result exporter_result =
+    ddprof_ffi_ProfileExporterV3_new(DDPROF_FFI_CHARSLICE_C("ruby"), &tags, endpoint);
+
+  ddprof_ffi_Vec_tag_drop(tags);
+
+  return exporter_result;
+}
+
+static VALUE handle_exporter_failure(ddprof_ffi_NewProfileExporterV3Result exporter_result) {
+  if (exporter_result.tag == DDPROF_FFI_NEW_PROFILE_EXPORTER_V3_RESULT_OK) return Qnil;
+
+  VALUE err_details = ruby_string_from_vec_u8(exporter_result.err);
+
+  ddprof_ffi_NewProfileExporterV3Result_drop(exporter_result);
+
+  return rb_ary_new_from_args(2, error_symbol, err_details);
+}
+
+static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration) {
+  Check_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);
+    Check_Type(site, T_STRING);
+    Check_Type(api_key, T_STRING);
+
+    return ddprof_ffi_EndpointV3_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);
+    Check_Type(base_url, T_STRING);
+
+    return ddprof_ffi_EndpointV3_agent(char_slice_from_ruby_string(base_url));
+  }
+}
+
+__attribute__((warn_unused_result))
+static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array) {
+  Check_Type(tags_as_array, T_ARRAY);
+
+  long tags_count = RARRAY_LEN(tags_as_array);
+  ddprof_ffi_Vec_tag tags = ddprof_ffi_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)) {
+      ddprof_ffi_Vec_tag_drop(tags);
+      Check_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))) {
+      ddprof_ffi_Vec_tag_drop(tags);
+      Check_Type(tag_name, T_STRING);
+      Check_Type(tag_value, T_STRING);
+    }
+
+    ddprof_ffi_PushTagResult push_result =
+      ddprof_ffi_Vec_tag_push(&tags, char_slice_from_ruby_string(tag_name), char_slice_from_ruby_string(tag_value));
+
+    if (push_result.tag == DDPROF_FFI_PUSH_TAG_RESULT_ERR) {
+      VALUE err_details = ruby_string_from_vec_u8(push_result.err);
+      ddprof_ffi_PushTagResult_drop(push_result);
+
+      // libddprof 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, err_details);
+    } else {
+      ddprof_ffi_PushTagResult_drop(push_result);
+    }
+  }
+
+  return tags;
+}
+
+static VALUE log_failure_to_process_tag(VALUE err_details) {
+  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(ddprof_ffi_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
+    ddprof_ffi_Vec_tag_drop(tags); // clean up
+    rb_jump_tag(exception_state);  // "Re-raise" exception
+  }
+}
+
+// Note: This function handles a bunch of libddprof 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(
+  ddprof_ffi_NewProfileExporterV3Result valid_exporter_result, // Must be called with a valid exporter result
+  ddprof_ffi_Timespec start,
+  ddprof_ffi_Timespec finish,
+  ddprof_ffi_Slice_file slice_files,
+  ddprof_ffi_Vec_tag *additional_tags,
+  uint64_t timeout_milliseconds
+) {
+  ddprof_ffi_ProfileExporterV3 *exporter = valid_exporter_result.ok;
+  ddprof_ffi_CancellationToken *cancel_token = ddprof_ffi_CancellationToken_new();
+  ddprof_ffi_Request *request =
+    ddprof_ffi_ProfileExporterV3_build(exporter, start, finish, slice_files, additional_tags, timeout_milliseconds);
+
+  // We'll release the Global VM Lock while we're calling send, so that the Ruby VM can continue to work while this
+  // is pending
+  struct call_exporter_without_gvl_arguments args =
+    {.exporter = exporter, .request = request, .cancel_token = cancel_token, .send_ran = false};
+
+  // We use rb_thread_call_without_gvl2 instead of rb_thread_call_without_gvl as the gvl2 variant never raises any
+  // exceptions.
+  //
+  // (With rb_thread_call_without_gvl, if someone calls Thread#kill or something like it on the current thread,
+  // the exception will be raised without us being able to clean up dynamically-allocated stuff, which would leak.)
+  //
+  // Instead, we take care of our own exception checking, and delay the exception raising (`rb_jump_tag` call) until
+  // after we cleaned up any dynamically-allocated resources.
+  //
+  // We run rb_thread_call_without_gvl2 in a loop since an "interrupt" may cause it to return before even running
+  // our code. In such a case, we retry the call -- unless the interrupt was caused by an exception being pending,
+  // and in that case we also give up and break out of the loop.
+  int pending_exception = 0;
+
+  while (!args.send_ran && !pending_exception) {
+    rb_thread_call_without_gvl2(call_exporter_without_gvl, &args, interrupt_exporter_call, cancel_token);
+    if (!args.send_ran) pending_exception = check_if_pending_exception();
+  }
+
+  VALUE ruby_status;
+  VALUE ruby_result;
+
+  if (pending_exception) {
+    // We're in a weird situation that libddprof doesn't quite support. The ddprof_ffi_Request payload is dynamically
+    // allocated and needs to be freed, but libddprof doesn't have an API for dropping a request.
+    //
+    // There's plans to add a `ddprof_ffi_Request_drop`
+    // (https://github.com/DataDog/dd-trace-rb/pull/1923#discussion_r882096221); once that happens, we can use it here.
+    //
+    // As a workaround, we get libddprof to clean up the request by asking for the send to be cancelled, and then calling
+    // it anyway. This will make libddprof free the request and return immediately which gets us the expected effect.
+    interrupt_exporter_call((void *) cancel_token);
+    call_exporter_without_gvl((void *) &args);
+  }
+
+  ddprof_ffi_SendResult result = args.result;
+  bool success = result.tag == DDPROF_FFI_SEND_RESULT_HTTP_RESPONSE;
+
+  ruby_status = success ? ok_symbol : error_symbol;
+  ruby_result = success ? UINT2NUM(result.http_response.code) : ruby_string_from_vec_u8(result.failure);
+
+  // Clean up all dynamically-allocated things
+  ddprof_ffi_SendResult_drop(args.result);
+  ddprof_ffi_CancellationToken_drop(cancel_token);
+  ddprof_ffi_NewProfileExporterV3Result_drop(valid_exporter_result);
+  // The request itself does not need to be freed as libddprof takes care of it.
+
+  // We've cleaned up everything, so if there's an exception to be raised, let's have it
+  if (pending_exception) rb_jump_tag(pending_exception);
+
+  return rb_ary_new_from_args(2, ruby_status, ruby_result);
+}
+
+static VALUE _native_do_export(
+  VALUE self,
+  VALUE exporter_configuration,
+  VALUE upload_timeout_milliseconds,
+  VALUE start_timespec_seconds,
+  VALUE start_timespec_nanoseconds,
+  VALUE finish_timespec_seconds,
+  VALUE finish_timespec_nanoseconds,
+  VALUE pprof_file_name,
+  VALUE pprof_data,
+  VALUE code_provenance_file_name,
+  VALUE code_provenance_data,
+  VALUE tags_as_array
+) {
+  Check_Type(upload_timeout_milliseconds, T_FIXNUM);
+  Check_Type(start_timespec_seconds, T_FIXNUM);
+  Check_Type(start_timespec_nanoseconds, T_FIXNUM);
+  Check_Type(finish_timespec_seconds, T_FIXNUM);
+  Check_Type(finish_timespec_nanoseconds, T_FIXNUM);
+  Check_Type(pprof_file_name, T_STRING);
+  Check_Type(pprof_data, T_STRING);
+  Check_Type(code_provenance_file_name, T_STRING);
+
+  // Code provenance can be disabled and in that case will be set to nil
+  bool have_code_provenance = !NIL_P(code_provenance_data);
+  if (have_code_provenance) Check_Type(code_provenance_data, T_STRING);
+
+  uint64_t timeout_milliseconds = NUM2ULONG(upload_timeout_milliseconds);
+
+  ddprof_ffi_Timespec start =
+    {.seconds = NUM2LONG(start_timespec_seconds), .nanoseconds = NUM2UINT(start_timespec_nanoseconds)};
+  ddprof_ffi_Timespec finish =
+    {.seconds = NUM2LONG(finish_timespec_seconds), .nanoseconds = NUM2UINT(finish_timespec_nanoseconds)};
+
+  int files_to_report = 1 + (have_code_provenance ? 1 : 0);
+  ddprof_ffi_File files[files_to_report];
+  ddprof_ffi_Slice_file slice_files = {.ptr = files, .len = files_to_report};
+
+  files[0] = (ddprof_ffi_File) {
+    .name = char_slice_from_ruby_string(pprof_file_name),
+    .file = byte_slice_from_ruby_string(pprof_data)
+  };
+  if (have_code_provenance) {
+    files[1] = (ddprof_ffi_File) {
+      .name = char_slice_from_ruby_string(code_provenance_file_name),
+      .file = byte_slice_from_ruby_string(code_provenance_data)
+    };
+  }
+
+  ddprof_ffi_Vec_tag *null_additional_tags = NULL;
+
+  ddprof_ffi_NewProfileExporterV3Result exporter_result = create_exporter(exporter_configuration, tags_as_array);
+  // Note: Do not add anything that can raise exceptions after this line, as otherwise the exporter memory will leak
+
+  VALUE failure_tuple = handle_exporter_failure(exporter_result);
+  if (!NIL_P(failure_tuple)) return failure_tuple;
+
+  return perform_export(exporter_result, start, finish, slice_files, null_additional_tags, timeout_milliseconds);
+}
+
+static void *call_exporter_without_gvl(void *call_args) {
+  struct call_exporter_without_gvl_arguments *args = (struct call_exporter_without_gvl_arguments*) call_args;
+
+  args->result = ddprof_ffi_ProfileExporterV3_send(args->exporter, args->request, args->cancel_token);
+  args->send_ran = true;
+
+  return NULL; // Unused
+}
+
+// Called by Ruby when it wants to interrupt call_exporter_without_gvl above, e.g. when the app wants to exit cleanly
+static void interrupt_exporter_call(void *cancel_token) {
+  ddprof_ffi_CancellationToken_cancel((ddprof_ffi_CancellationToken *) cancel_token);
+}

data/ext/ddtrace_profiling_native_extension/native_extension_helpers.rb

@@ -3,15 +3,69 @@
 # typed: ignore
 
 require 'libddprof'
+require 'pathname'
 
 module Datadog
   module Profiling
+    # Helpers for extconf.rb
     module NativeExtensionHelpers
+      # Can be set when customers want to skip compiling the native extension entirely
       ENV_NO_EXTENSION = 'DD_PROFILING_NO_EXTENSION'
+      # Can be set to force rubygems to fail gem installation when profiling extension could not be built
+      ENV_FAIL_INSTALL_IF_MISSING_EXTENSION = 'DD_PROFILING_FAIL_INSTALL_IF_MISSING_EXTENSION'
 
       # Older Rubies don't have the MJIT header, used by the JIT compiler, so we need to use a different approach
       CAN_USE_MJIT_HEADER = RUBY_VERSION >= '2.6'
 
+      def self.fail_install_if_missing_extension?
+        ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == 'true'
+      end
+
+      # Used as an workaround for a limitation with how dynamic linking works in environments where ddtrace and
+      # libddprof are moved after the extension gets compiled.
+      #
+      # Because the libddpprof native library is installed on a non-standard system path, in order for it to be
+      # found by the system dynamic linker (e.g. what takes care of dlopen(), which is used to load the profiling
+      # native extension), we need to add a "runpath" -- a list of folders to search for libddprof.
+      #
+      # This runpath gets hardcoded at native library linking time. You can look at it using the `readelf` tool in
+      # Linux: e.g. `readelf -d ddtrace_profiling_native_extension.2.7.3_x86_64-linux.so`.
+      #
+      # In ddtrace 1.1.0, we only set as runpath an absolute path to libddprof. (This gets set automatically by the call
+      # to `pkg_config('ddprof_ffi_with_rpath')` in `extconf.rb`). This worked fine as long as libddprof was **NOT**
+      # moved from the folder it was present at ddtrace 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
+      # (see https://github.com/DataDog/dd-trace-rb/issues/2067) because libddprof could not be found.
+      #
+      # To workaround this issue, this method computes the **relative** path between the folder where the profiling
+      # native extension is going to be installed and the folder where libddprof is installed, and returns it
+      # to be set as an additional runpath. (Yes, you can set multiple runpath folders to be searched).
+      #
+      # This way, if both gems are moved together (and it turns out that they are in these environments),
+      # the relative path can still be traversed to find libddprof.
+      #
+      # This is incredibly awful, and it's kinda bizarre how it's not possible to just find these paths at runtime
+      # and set them correctly; rather than needing to set stuff at linking-time and then praying to $deity that
+      # weird moves don't happen.
+      #
+      # As a curiosity, `LD_LIBRARY_PATH` can be used to influence the folders that get searched but **CANNOT BE
+      # SET DYNAMICALLY**, e.g. it needs to be set at the start of the process (Ruby VM) and thus it's not something
+      # we could setup when doing a `require`.
+      #
+      def self.libddprof_folder_relative_to_native_lib_folder(
+        current_folder: __dir__,
+        libddprof_pkgconfig_folder: Libddprof.pkgconfig_folder
+      )
+        return unless libddprof_pkgconfig_folder
+
+        profiling_native_lib_folder = "#{current_folder}/../../lib/"
+        libddprof_lib_folder = "#{libddprof_pkgconfig_folder}/../"
+
+        Pathname.new(libddprof_lib_folder).relative_path_from(Pathname.new(profiling_native_lib_folder)).to_s
+      end
+
       # Used to check if profiler is supported, including user-visible clear messages explaining why their
       # system may not be supported.
       # rubocop:disable Metrics/ModuleLength
@@ -37,15 +91,30 @@ module Datadog
         end
 
         # This banner will show up in the logs/terminal while compiling the native extension
-        def self.failure_banner_for(reason:, suggested:)
-          prettify_lines = proc { |lines| lines.map { |line| "| #{line.ljust(76)} |" }.join("\n") }
+        def self.failure_banner_for(reason:, suggested:, fail_install:)
+          prettify_lines = proc { |lines| Array(lines).map { |line| "| #{line.ljust(76)} |" }.join("\n") }
+          outcome =
+            if fail_install
+              [
+                'Failing installation immediately because the ',
+                "`#{ENV_FAIL_INSTALL_IF_MISSING_EXTENSION}` environment variable is set",
+                'to `true`.',
+                'When contacting support, please include the <mkmf.log> file that is shown ',
+                'below.',
+              ]
+            else
+              [
+                'The Datadog Continuous Profiler will not be available,',
+                'but all other ddtrace features will work fine!',
+              ]
+            end
+
           %(
 +------------------------------------------------------------------------------+
 | Could not compile the Datadog Continuous Profiler because                    |
 #{prettify_lines.call(reason)}
 |                                                                              |
-| The Datadog Continuous Profiler will not be available,                       |
-| but all other ddtrace features will work fine!                               |
+#{prettify_lines.call(outcome)}
 |                                                                              |
 #{prettify_lines.call(suggested)}
 +------------------------------------------------------------------------------+
@@ -57,6 +126,14 @@ module Datadog
           [*reason, *suggested].join(' ')
         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) # rubocop:disable Style/GlobalVars
+          pkg_config_available = command && xsystem("#{command} --version")
+
+          pkg_config_available != true
+        end
+
         CONTACT_SUPPORT = [
           'For help solving this issue, please contact Datadog support at',
           '<https://docs.datadoghq.com/help/>.',
@@ -84,6 +161,17 @@ module Datadog
           suggested: CONTACT_SUPPORT,
         )
 
+        # Validation for this check is done in extconf.rb because it relies on mkmf
+        PKG_CONFIG_IS_MISSING = explain_issue(
+          #+-----------------------------------------------------------------------------+
+          'the `pkg-config` system tool is missing.',
+          'This issue can usually be fixed by installing:',
+          '1. the `pkg-config` package on Homebrew and Debian/Ubuntu-based Linux;',
+          '2. the `pkgconf` package on Arch and Alpine-based Linux;',
+          '3. the `pkgconf-pkg-config` package on Fedora/Red Hat-based Linux.',
+          suggested: CONTACT_SUPPORT,
+        )
+
         private_class_method def self.disabled_via_env?
           disabled_via_env = explain_issue(
             'the `DD_PROFILING_NO_EXTENSION` environment variable is/was set to',

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.c

@@ -35,7 +35,12 @@ static inline rb_thread_t *thread_struct_from_object(VALUE thread) {
 }
 
 rb_nativethread_id_t pthread_id_for(VALUE thread) {
-  return thread_struct_from_object(thread)->thread_id;
+  // struct rb_native_thread was introduced in Ruby 3.2 (preview2): https://github.com/ruby/ruby/pull/5836
+  #ifndef NO_RB_NATIVE_THREAD
+    return thread_struct_from_object(thread)->nt->thread_id;
+  #else
+    return thread_struct_from_object(thread)->thread_id;
+  #endif
 }
 
 // Returns the stack depth by using the same approach as rb_profile_frames and backtrace_each: get the positions
@@ -58,6 +63,76 @@ ptrdiff_t stack_depth_for(VALUE thread) {
   return end_cfp <= cfp ? 0 : end_cfp - cfp - 1;
 }
 
+// This was renamed in Ruby 3.2
+#if !defined(ccan_list_for_each) && defined(list_for_each)
+  #define ccan_list_for_each list_for_each
+#endif
+
+#ifndef USE_LEGACY_LIVING_THREADS_ST // Ruby > 2.1
+// Tries to match rb_thread_list() but that method isn't accessible to extensions
+VALUE ddtrace_thread_list(void) {
+  VALUE result = rb_ary_new();
+  rb_thread_t *thread = NULL;
+
+  // Ruby 3 Safety: Our implementation is inspired by `rb_ractor_thread_list` BUT that method wraps the operations below
+  // with `RACTOR_LOCK` and `RACTOR_UNLOCK`.
+  //
+  // This initially made me believe that one MUST grab the ractor lock (which is different from the ractor-scoped Global
+  // VM Lock) in able to iterate the `threads.set`. This turned out not to be the case: upon further study of the VM
+  // codebase in 3.2-master, 3.1 and 3.0, there's quite a few places where `threads.set` is accessed without grabbing
+  // the ractor lock: `ractor_mark` (ractor.c), `thgroup_list` (thread.c), `rb_check_deadlock` (thread.c), etc.
+  //
+  // I suspect the design in `rb_ractor_thread_list` may be done that way to perhaps in the future expose it to be
+  // called from a different Ractor, but I'm not sure...
+  #ifdef HAVE_RUBY_RACTOR_H
+    rb_ractor_t *current_ractor = GET_RACTOR();
+    ccan_list_for_each(&current_ractor->threads.set, thread, lt_node) {
+  #else
+    rb_vm_t *vm = thread_struct_from_object(rb_thread_current())->vm;
+    list_for_each(&vm->living_threads, thread, vmlt_node) {
+  #endif
+      switch (thread->status) {
+        case THREAD_RUNNABLE:
+        case THREAD_STOPPED:
+        case THREAD_STOPPED_FOREVER:
+          rb_ary_push(result, thread->self);
+        default:
+          break;
+      }
+    }
+
+  return result;
+}
+#else // USE_LEGACY_LIVING_THREADS_ST
+static int ddtrace_thread_list_each(st_data_t thread_object, st_data_t _value, void *result_object);
+
+// Alternative ddtrace_thread_list implementation for Ruby 2.1. In this Ruby version, living threads were stored in a
+// hashmap (st) instead of a list.
+VALUE ddtrace_thread_list() {
+  VALUE result = rb_ary_new();
+  st_foreach(thread_struct_from_object(rb_thread_current())->vm->living_threads, ddtrace_thread_list_each, result);
+  return result;
+}
+
+static int ddtrace_thread_list_each(st_data_t thread_object, st_data_t _value, void *result_object) {
+  VALUE result = (VALUE) result_object;
+  rb_thread_t *thread = thread_struct_from_object((VALUE) thread_object);
+  switch (thread->status) {
+    case THREAD_RUNNABLE:
+    case THREAD_STOPPED:
+    case THREAD_STOPPED_FOREVER:
+      rb_ary_push(result, thread->self);
+    default:
+      break;
+  }
+  return ST_CONTINUE;
+}
+#endif // USE_LEGACY_LIVING_THREADS_ST
+
+bool is_thread_alive(VALUE thread) {
+  return thread_struct_from_object(thread)->status != THREAD_KILLED;
+}
+
 // -----------------------------------------------------------------------------
 // The sources below are modified versions of code extracted from the Ruby project.
 // Each function is annotated with its origin, why we imported it, and the changes made.

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.h

@@ -17,6 +17,9 @@
 
 rb_nativethread_id_t pthread_id_for(VALUE thread);
 ptrdiff_t stack_depth_for(VALUE thread);
+VALUE ddtrace_thread_list(void);
+bool is_thread_alive(VALUE thread);
+
 int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, int *lines, bool* is_ruby_frame);
 
 // Ruby 3.0 finally added support for showing CFUNC frames (frames for methods written using native code)

data/ext/ddtrace_profiling_native_extension/profiling.c

@@ -3,7 +3,9 @@
 #include "clock_id.h"
 
 // Each class/module here is implemented in their separate file
+void collectors_cpu_and_wall_time_init(VALUE profiling_module);
 void collectors_stack_init(VALUE profiling_module);
+void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
 
 static VALUE native_working_p(VALUE self);
@@ -20,7 +22,9 @@ void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
 
   rb_define_singleton_method(native_extension_module, "clock_id_for", clock_id_for, 1); // from clock_id.h
 
+  collectors_cpu_and_wall_time_init(profiling_module);
   collectors_stack_init(profiling_module);
+  http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
 }
 

data/ext/ddtrace_profiling_native_extension/ruby_helpers.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <ruby.h>
+
+// Processes any pending interruptions, including exceptions to be raised.
+// If there's an exception to be raised, it raises it. In that case, this function does not return.
+static inline VALUE process_pending_interruptions(VALUE _unused) {
+  rb_thread_check_ints();
+  return Qnil;
+}
+
+// Calls process_pending_interruptions BUT "rescues" any exceptions to be raised, returning them instead as
+// a non-zero `pending_exception`.
+//
+// Thus, if there's a non-zero `pending_exception`, the caller MUST call `rb_jump_tag(pending_exception)` after any
+// needed clean-ups.
+//
+// Usage example:
+//
+// ```c
+// foo = ruby_xcalloc(...);
+// pending_exception = check_if_pending_exception();
+// if (pending_exception) {
+//   ruby_xfree(foo);
+//   rb_jump_tag(pending_exception); // Re-raises exception
+// }
+// ```
+__attribute__((warn_unused_result))
+static inline int check_if_pending_exception(void) {
+  int pending_exception;
+  rb_protect(process_pending_interruptions, Qnil, &pending_exception);
+  return pending_exception;
+}