ddtrace 1.7.0 → 1.9.0

data/ext/ddtrace_profiling_native_extension/helpers.h

@@ -10,3 +10,8 @@
 #else
   #define DDTRACE_UNUSED
 #endif
+
+// @ivoanjo: After trying to read through https://stackoverflow.com/questions/3437404/min-and-max-in-c I decided I
+// don't like C and I just implemented this as a function.
+inline static uint64_t uint64_max_of(uint64_t a, uint64_t b) { return a > b ? a : b; }
+inline static uint64_t uint64_min_of(uint64_t a, uint64_t b) { return a > b ? b : a; }

data/ext/ddtrace_profiling_native_extension/http_transport.c

@@ -20,20 +20,20 @@ static VALUE http_transport_class = Qnil;
 static VALUE library_version_string = Qnil;
 
 struct call_exporter_without_gvl_arguments {
-  ddog_ProfileExporter *exporter;
-  ddog_Request *request;
+  ddog_prof_Exporter *exporter;
+  ddog_prof_Exporter_Request *request;
   ddog_CancellationToken *cancel_token;
-  ddog_SendResult result;
+  ddog_prof_Exporter_SendResult result;
   bool send_ran;
 };
 
 inline static ddog_ByteSlice byte_slice_from_ruby_string(VALUE string);
 static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration);
-static ddog_NewProfileExporterResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
-static VALUE handle_exporter_failure(ddog_NewProfileExporterResult exporter_result);
+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 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,
@@ -76,46 +76,46 @@ inline static ddog_ByteSlice byte_slice_from_ruby_string(VALUE string) {
 
 static VALUE _native_validate_exporter(DDTRACE_UNUSED VALUE _self, VALUE exporter_configuration) {
   ENFORCE_TYPE(exporter_configuration, T_ARRAY);
-  ddog_NewProfileExporterResult exporter_result = create_exporter(exporter_configuration, rb_ary_new());
+  ddog_prof_Exporter_NewResult 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
-  ddog_NewProfileExporterResult_drop(exporter_result);
+  ddog_prof_Exporter_NewResult_drop(exporter_result);
 
   return rb_ary_new_from_args(2, ok_symbol, Qnil);
 }
 
-static ddog_NewProfileExporterResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array) {
+static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array) {
   ENFORCE_TYPE(exporter_configuration, T_ARRAY);
   ENFORCE_TYPE(tags_as_array, T_ARRAY);
 
-  // This needs to be called BEFORE convert_tags since it can raise an exception and thus cause the ddog_Vec_tag
+  // 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_Vec_tag tags = convert_tags(tags_as_array);
+  ddog_Vec_Tag tags = convert_tags(tags_as_array);
 
   ddog_CharSlice library_name = DDOG_CHARSLICE_C("dd-trace-rb");
   ddog_CharSlice library_version = char_slice_from_ruby_string(library_version_string);
   ddog_CharSlice profiling_family = DDOG_CHARSLICE_C("ruby");
 
-  ddog_NewProfileExporterResult exporter_result =
-    ddog_ProfileExporter_new(library_name, library_version, profiling_family, &tags, endpoint);
+  ddog_prof_Exporter_NewResult exporter_result =
+    ddog_prof_Exporter_new(library_name, library_version, profiling_family, &tags, endpoint);
 
-  ddog_Vec_tag_drop(tags);
+  ddog_Vec_Tag_drop(tags);
 
   return exporter_result;
 }
 
-static VALUE handle_exporter_failure(ddog_NewProfileExporterResult exporter_result) {
-  if (exporter_result.tag == DDOG_NEW_PROFILE_EXPORTER_RESULT_OK) return Qnil;
+static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_result) {
+  if (exporter_result.tag == DDOG_PROF_EXPORTER_NEW_RESULT_OK) return Qnil;
 
-  VALUE err_details = ruby_string_from_vec_u8(exporter_result.err);
+  VALUE err_details = ruby_string_from_prof_vec_u8(exporter_result.err);
 
-  ddog_NewProfileExporterResult_drop(exporter_result);
+  ddog_prof_Exporter_NewResult_drop(exporter_result);
 
   return rb_ary_new_from_args(2, error_symbol, err_details);
 }
@@ -145,17 +145,17 @@ static ddog_Endpoint endpoint_from(VALUE exporter_configuration) {
 }
 
 __attribute__((warn_unused_result))
-static ddog_Vec_tag convert_tags(VALUE tags_as_array) {
+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();
+  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);
+      ddog_Vec_Tag_drop(tags);
       ENFORCE_TYPE(name_value_pair, T_ARRAY);
     }
 
@@ -164,23 +164,23 @@ static ddog_Vec_tag convert_tags(VALUE tags_as_array) {
     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);
+      ddog_Vec_Tag_drop(tags);
       ENFORCE_TYPE(tag_name, T_STRING);
       ENFORCE_TYPE(tag_value, T_STRING);
     }
 
-    ddog_PushTagResult push_result =
-      ddog_Vec_tag_push(&tags, char_slice_from_ruby_string(tag_name), char_slice_from_ruby_string(tag_value));
+    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_PUSH_TAG_RESULT_ERR) {
+    if (push_result.tag == DDOG_VEC_TAG_PUSH_RESULT_ERR) {
       VALUE err_details = ruby_string_from_vec_u8(push_result.err);
-      ddog_PushTagResult_drop(push_result);
+      ddog_Vec_Tag_PushResult_drop(push_result);
 
       // 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, err_details);
     } else {
-      ddog_PushTagResult_drop(push_result);
+      ddog_Vec_Tag_PushResult_drop(push_result);
     }
   }
 
@@ -193,12 +193,12 @@ static VALUE log_failure_to_process_tag(VALUE 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) {
+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
+    ddog_Vec_Tag_drop(tags); // clean up
     rb_jump_tag(exception_state);  // "Re-raise" exception
   }
 }
@@ -206,17 +206,18 @@ static void safely_log_failure_to_process_tag(ddog_Vec_tag tags, VALUE err_detai
 // 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(
-  ddog_NewProfileExporterResult valid_exporter_result, // Must be called with a valid exporter result
+  ddog_prof_Exporter_NewResult valid_exporter_result, // Must be called with a valid exporter result
   ddog_Timespec start,
   ddog_Timespec finish,
-  ddog_Slice_file slice_files,
-  ddog_Vec_tag *additional_tags,
+  ddog_prof_Exporter_Slice_File slice_files,
+  ddog_Vec_Tag *additional_tags,
   uint64_t timeout_milliseconds
 ) {
-  ddog_ProfileExporter *exporter = valid_exporter_result.ok;
+  ddog_prof_Exporter *exporter = valid_exporter_result.ok;
   ddog_CancellationToken *cancel_token = ddog_CancellationToken_new();
-  ddog_Request *request =
-    ddog_ProfileExporter_build(exporter, start, finish, slice_files, additional_tags, timeout_milliseconds);
+  ddog_prof_ProfiledEndpointsStats *endpoints_stats = NULL; // Not in use yet
+  ddog_prof_Exporter_Request *request =
+    ddog_prof_Exporter_Request_build(exporter, start, finish, slice_files, additional_tags, endpoints_stats, 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
@@ -246,23 +247,23 @@ static VALUE perform_export(
 
   // Cleanup exporter and token, no longer needed
   ddog_CancellationToken_drop(cancel_token);
-  ddog_NewProfileExporterResult_drop(valid_exporter_result);
+  ddog_prof_Exporter_NewResult_drop(valid_exporter_result);
 
   if (pending_exception) {
     // If we got here send did not run, so we need to explicitly dispose of the request
-    ddog_Request_drop(request);
+    ddog_prof_Exporter_Request_drop(request);
 
     // Let Ruby propagate the exception. This will not return.
     rb_jump_tag(pending_exception);
   }
 
-  ddog_SendResult result = args.result;
-  bool success = result.tag == DDOG_SEND_RESULT_HTTP_RESPONSE;
+  ddog_prof_Exporter_SendResult result = args.result;
+  bool success = result.tag == DDOG_PROF_EXPORTER_SEND_RESULT_HTTP_RESPONSE;
 
   VALUE ruby_status = success ? ok_symbol : error_symbol;
-  VALUE ruby_result = success ? UINT2NUM(result.http_response.code) : ruby_string_from_vec_u8(result.err);
+  VALUE ruby_result = success ? UINT2NUM(result.http_response.code) : ruby_string_from_prof_vec_u8(result.err);
 
-  ddog_SendResult_drop(args.result);
+  ddog_prof_Exporter_SendResult_drop(args.result);
   // The request itself does not need to be freed as libdatadog takes care of it as part of sending.
 
   return rb_ary_new_from_args(2, ruby_status, ruby_result);
@@ -303,23 +304,23 @@ static VALUE _native_do_export(
     {.seconds = NUM2LONG(finish_timespec_seconds), .nanoseconds = NUM2UINT(finish_timespec_nanoseconds)};
 
   int files_to_report = 1 + (have_code_provenance ? 1 : 0);
-  ddog_File files[files_to_report];
-  ddog_Slice_file slice_files = {.ptr = files, .len = files_to_report};
+  ddog_prof_Exporter_File files[files_to_report];
+  ddog_prof_Exporter_Slice_File slice_files = {.ptr = files, .len = files_to_report};
 
-  files[0] = (ddog_File) {
+  files[0] = (ddog_prof_Exporter_File) {
     .name = char_slice_from_ruby_string(pprof_file_name),
     .file = byte_slice_from_ruby_string(pprof_data)
   };
   if (have_code_provenance) {
-    files[1] = (ddog_File) {
+    files[1] = (ddog_prof_Exporter_File) {
       .name = char_slice_from_ruby_string(code_provenance_file_name),
       .file = byte_slice_from_ruby_string(code_provenance_data)
     };
   }
 
-  ddog_Vec_tag *null_additional_tags = NULL;
+  ddog_Vec_Tag *null_additional_tags = NULL;
 
-  ddog_NewProfileExporterResult exporter_result = create_exporter(exporter_configuration, tags_as_array);
+  ddog_prof_Exporter_NewResult 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);
@@ -331,7 +332,7 @@ static VALUE _native_do_export(
 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 = ddog_ProfileExporter_send(args->exporter, args->request, args->cancel_token);
+  args->result = ddog_prof_Exporter_send(args->exporter, args->request, args->cancel_token);
   args->send_ran = true;
 
   return NULL; // Unused

data/ext/ddtrace_profiling_native_extension/libdatadog_helpers.h

@@ -9,6 +9,10 @@ inline static ddog_CharSlice char_slice_from_ruby_string(VALUE string) {
   return char_slice;
 }
 
-inline static VALUE ruby_string_from_vec_u8(ddog_Vec_u8 string) {
+inline static VALUE ruby_string_from_vec_u8(ddog_Vec_U8 string) {
+  return rb_str_new((char *) string.ptr, string.len);
+}
+
+inline static VALUE ruby_string_from_prof_vec_u8(ddog_prof_Vec_U8 string) {
   return rb_str_new((char *) string.ptr, string.len);
 }

data/ext/ddtrace_profiling_native_extension/native_extension_helpers.rb

@@ -2,7 +2,7 @@
 
 # typed: ignore
 
-require 'libdatadog'
+require 'rubygems'
 require 'pathname'
 
 module Datadog
@@ -17,6 +17,8 @@ module Datadog
       # 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'
 
+      LIBDATADOG_VERSION = '~> 1.0.1.1.0'
+
       def self.fail_install_if_missing_extension?
         ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == 'true'
       end
@@ -88,6 +90,7 @@ module Datadog
             not_on_amd64_or_arm64? ||
             on_ruby_2_1? ||
             expected_to_use_mjit_but_mjit_is_disabled? ||
+            libdatadog_not_available? ||
             libdatadog_not_usable?
         end
 
@@ -142,11 +145,6 @@ module Datadog
           '<https://dtdg.co/ruby-profiler-troubleshooting>.'
         ].freeze
 
-        REPORT_ISSUE = [
-          'If you needed to use this, please tell us why on',
-          '<https://github.com/DataDog/dd-trace-rb/issues/new> so we can fix it :)',
-        ].freeze
-
         GET_IN_TOUCH = [
           "Get in touch with us if you're interested in profiling your app!"
         ].freeze
@@ -172,18 +170,31 @@ module Datadog
         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.',
+          'This issue can usually be fixed by installing one of the following:',
+          'the `pkg-config` package on Homebrew and Debian/Ubuntu-based Linux;',
+          'the `pkgconf` package on Arch and Alpine-based Linux;',
+          'the `pkgconf-pkg-config` package on Fedora/Red Hat-based Linux.',
+          suggested: CONTACT_SUPPORT,
+        )
+
+        # Validation for this check is done in extconf.rb because it relies on mkmf
+        COMPILER_ATOMIC_MISSING = explain_issue(
+          'your C compiler is missing support for the <stdatomic.h> header.',
+          'This issue can usually be fixed by upgrading to a later version of your',
+          'operating system image or compiler.',
           suggested: CONTACT_SUPPORT,
         )
 
         private_class_method def self.disabled_via_env?
+          report_disabled = [
+            'If you needed to use this, please tell us why on',
+            '<https://github.com/DataDog/dd-trace-rb/issues/new> so we can fix it :)',
+          ].freeze
+
           disabled_via_env = explain_issue(
             'the `DD_PROFILING_NO_EXTENSION` environment variable is/was set to',
             '`true` during installation.',
-            suggested: REPORT_ISSUE,
+            suggested: report_disabled,
           )
 
           return unless ENV[ENV_NO_EXTENSION].to_s.strip.downcase == 'true'
@@ -246,7 +257,7 @@ module Datadog
             suggested: GET_IN_TOUCH,
           )
 
-          architecture_not_supported unless RUBY_PLATFORM.start_with?('x86_64', 'aarch64')
+          architecture_not_supported unless RUBY_PLATFORM.start_with?('x86_64', 'aarch64', 'arm64')
         end
 
         private_class_method def self.on_ruby_2_1?
@@ -271,6 +282,25 @@ module Datadog
           ruby_without_mjit if CAN_USE_MJIT_HEADER && RbConfig::CONFIG['MJIT_SUPPORT'] != 'yes'
         end
 
+        private_class_method def self.libdatadog_not_available?
+          begin
+            gem 'libdatadog', LIBDATADOG_VERSION
+            require 'libdatadog'
+            nil
+          # rubocop:disable Lint/RescueException
+          rescue Exception => e
+            explain_issue(
+              'there was an exception during loading of the `libdatadog` gem:',
+              e.class.name,
+              *e.message.split("\n"),
+              *Array(e.backtrace),
+              '.',
+              suggested: CONTACT_SUPPORT,
+            )
+          end
+          # rubocop:enable Lint/RescueException
+        end
+
         private_class_method def self.libdatadog_not_usable?
           no_binaries_for_current_platform = explain_issue(
             'the `libdatadog` gem installed on your system is missing binaries for your',

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.c

@@ -50,6 +50,100 @@ rb_nativethread_id_t pthread_id_for(VALUE thread) {
   #endif
 }
 
+// Queries if the current thread is the owner of the global VM lock.
+//
+// @ivoanjo: Ruby has a similarly-named `ruby_thread_has_gvl_p` but that API is insufficient for our needs because it can
+// still return `true` even when a thread DOES NOT HAVE the global VM lock.
+// In particular, looking at the implementation, that API assumes that if a thread is not in a "blocking region" then it
+// will have the GVL which is probably true for the situations that API was designed to be called from BUT this assumption
+// does not hold true when calling `ruby_thread_has_gvl_p` from a signal handler. (Because the thread may have lost the
+// GVL due to a scheduler decision, not because it decided to block.)
+// I have also submitted https://bugs.ruby-lang.org/issues/19172 to discuss this with upstream Ruby developers.
+//
+// Thus we need our own gvl-checking method which actually looks at the gvl structure to determine if it is the owner.
+bool is_current_thread_holding_the_gvl(void) {
+  current_gvl_owner owner = gvl_owner();
+  return owner.valid && pthread_equal(pthread_self(), owner.owner);
+}
+
+#ifndef NO_GVL_OWNER // Ruby < 2.6 doesn't have the owner/running field
+  // NOTE: Reading the owner in this is a racy read, because we're not grabbing the lock that Ruby uses to protect it.
+  //
+  // While we could potentially grab this lock, I (@ivoanjo) think we actually don't need it because:
+  // * In the case where a thread owns the GVL and calls `gvl_owner`, it will always see the correct value. That's
+  //   because every thread sets itself as the owner when it grabs the GVL and unsets itself at the end.
+  //   That means that `is_current_thread_holding_the_gvl` is always accurate.
+  // * In a case where we observe a different thread, then this may change by the time we do something with this value
+  //   anyway. So unless we want to prevent the Ruby scheduler from switching threads, we need to deal with races here.
+  current_gvl_owner gvl_owner(void) {
+    const rb_thread_t *current_owner =
+      #ifndef NO_RB_THREAD_SCHED // Introduced in Ruby 3.2 as a replacement for struct rb_global_vm_lock_struct
+        GET_RACTOR()->threads.sched.running;
+      #elif HAVE_RUBY_RACTOR_H
+        GET_RACTOR()->threads.gvl.owner;
+      #else
+        GET_VM()->gvl.owner;
+      #endif
+
+    if (current_owner == NULL) return (current_gvl_owner) {.valid = false};
+
+    return (current_gvl_owner) {
+      .valid = true,
+      .owner =
+        #ifndef NO_RB_NATIVE_THREAD
+          current_owner->nt->thread_id
+        #else
+          current_owner->thread_id
+        #endif
+    };
+  }
+#else
+  current_gvl_owner gvl_owner(void) {
+    rb_vm_t *vm =
+      #ifndef NO_GET_VM
+        GET_VM();
+      #else
+        thread_struct_from_object(rb_thread_current())->vm;
+      #endif
+
+    // BIG Issue: Ruby < 2.6 did not have the owner field. The really nice thing about the owner field is that it's
+    // "atomic" -- when a thread sets it, it "declares" two things in a single step
+    // * Declaration 1: Someone has the GVL
+    // * Declaration 2: That someone is the specific thread
+    //
+    // Observation 1: On older versions of Ruby, this ownership concept is actually split. Specifically, `gvl.acquired`
+    // is a boolean that represents declaration 1 above, and `vm->running_thread` (or `ruby_current_thread`/
+    // `ruby_current_execution_context_ptr`) represents declaration 2.
+    //
+    // Observation 2: In addition, when a thread releases the GVL, it only sets `gvl.acquired` back to 0 **BUT CRUCIALLY
+    // DOES NOT CHANGE THE OTHER global variables**.
+    //
+    // Observation 1+2 above lead to the following possible race:
+    // * Thread A grabs the GVL (`gvl.acquired == 1`)
+    // * Thread A sets `running_thread` (`gvl.acquired == 1` + `running_thread == Thread A`)
+    // * Thread A releases the GVL (`gvl.acquired == 0` + `running_thread == Thread A`)
+    // * Thread B grabs the GVL (`gvl.acquired == 1` + `running_thread == Thread A`)
+    // * Thread A calls gvl_owner. Due to the current state (`gvl.acquired == 1` + `running_thread == Thread A`), this
+    //   function returns an incorrect result.
+    // * Thread B finally sets `running_thread` (`gvl.acquired == 1` + `running_thread == Thread B`)
+    //
+    // This is especially problematic because we use `gvl_owner` to implement `is_current_thread_holding_the_gvl` which
+    // is called in a signal handler to decide "is it safe for me to call `rb_postponed_job_register_one` or not".
+    // (See constraints in `collectors_cpu_and_wall_time_worker.c` comments for why).
+    //
+    // Thus an incorrect `is_current_thread_holding_the_gvl` result may lead to issues inside `rb_postponed_job_register_one`.
+    //
+    // For this reason we currently do not enable the new Ruby profiler on Ruby 2.5 and below by default, and we print a
+    // warning when customers force-enable it.
+    bool gvl_acquired = vm->gvl.acquired != 0;
+    rb_thread_t *current_owner = vm->running_thread;
+
+    if (!gvl_acquired || current_owner == NULL) return (current_gvl_owner) {.valid = false};
+
+    return (current_gvl_owner) {.valid = true, .owner = current_owner->thread_id};
+  }
+#endif // NO_GVL_OWNER
+
 // Taken from upstream vm_core.h at commit d9cf0388599a3234b9f3c06ddd006cd59a58ab8b (November 2022, Ruby 3.2 trunk)
 // Copyright (C) 2004-2007 Koichi Sasada
 // to support tid_for (see below)
@@ -128,7 +222,12 @@ VALUE ddtrace_thread_list(void) {
     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;
+    rb_vm_t *vm =
+      #ifndef NO_GET_VM
+        GET_VM();
+      #else
+        thread_struct_from_object(rb_thread_current())->vm;
+      #endif
     list_for_each(&vm->living_threads, thread, vmlt_node) {
   #endif
       switch (thread->status) {
@@ -284,9 +383,6 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 // * Add `end_cfp == NULL` and `end_cfp <= cfp` safety checks. These are used in a bunch of places in
 //   `vm_backtrace.c` (`backtrace_each`, `backtrace_size`, `rb_ec_partial_backtrace_object`) but are conspicuously
 //   absent from `rb_profile_frames`. Oversight?
-// * Distinguish between `end_cfp == NULL` (dead thread or some other error, returns 0) and `end_cfp <= cfp`
-//   (alive thread which may just be executing native code and has not pushed anything on the Ruby stack, returns
-//   PLACEHOLDER_STACK_IN_NATIVE_CODE). See comments on `record_placeholder_stack_in_native_code` for more details.
 // * Skip frames where `cfp->iseq && !cfp->pc`. These seem to be internal and are skipped by `backtrace_each` in
 //   `vm_backtrace.c`.
 // * Check thread status and do not sample if thread has been killed.
@@ -294,6 +390,7 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 //   for iseqs created from calls to `eval` and `instance_eval`. This makes it so that `rb_profile_frame_path` on
 //   the `VALUE` returned by rb_profile_frames returns `(eval)` instead of the path of the file where the `eval`
 //   was called from.
+// * Imported fix from https://github.com/ruby/ruby/pull/7116 to avoid sampling threads that are still being created
 //
 // **IMPORTANT: WHEN CHANGING THIS FUNCTION, CONSIDER IF THE SAME CHANGE ALSO NEEDS TO BE MADE TO THE VARIANT FOR
 // RUBY 2.2 AND BELOW WHICH IS ALSO PRESENT ON THIS FILE**
@@ -340,13 +437,17 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
     const rb_control_frame_t *cfp = ec->cfp, *end_cfp = RUBY_VM_END_CONTROL_FRAME(ec);
     const rb_callable_method_entry_t *cme;
 
-    // `vm_backtrace.c` includes this check in several methods, and I think this happens on either dead or newly-created
-    // threads, but I'm not entirely sure
-    if (end_cfp == NULL) return 0;
+    // This should not happen for ddtrace (it can only happen when a thread is still being created), but I've imported
+    // it from https://github.com/ruby/ruby/pull/7116 in a "just in case" kind of mindset.
+    if (cfp == NULL) return 0;
 
     // Avoid sampling dead threads
     if (th->status == THREAD_KILLED) return 0;
 
+    // `vm_backtrace.c` includes this check in several methods. This happens on newly-created threads, and may
+    // also (not entirely sure) happen on dead threads
+    if (end_cfp == NULL) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
+
     // Fix: Skip dummy frame that shows up in main thread.
     //
     // According to a comment in `backtrace_each` (`vm_backtrace.c`), there's two dummy frames that we should ignore
@@ -650,10 +751,8 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 // * Add `end_cfp == NULL` and `end_cfp <= cfp` safety checks. These are used in a bunch of places in
 //   `vm_backtrace.c` (`backtrace_each`, `backtrace_size`, `rb_ec_partial_backtrace_object`) but are conspicuously
 //   absent from `rb_profile_frames`. Oversight?
-// * Distinguish between `end_cfp == NULL` (dead thread or some other error, returns 0) and `end_cfp <= cfp`
-//   (alive thread which may just be executing native code and has not pushed anything on the Ruby stack, returns
-//   PLACEHOLDER_STACK_IN_NATIVE_CODE). See comments on `record_placeholder_stack_in_native_code` for more details.
 // * Check thread status and do not sample if thread has been killed.
+// * Imported fix from https://github.com/ruby/ruby/pull/7116 to avoid sampling threads that are still being created
 //
 // The `rb_profile_frames` function changed quite a bit between Ruby 2.2 and 2.3. Since the change was quite complex
 // I opted not to try to extend support to Ruby 2.2 using the same custom function, and instead I started
@@ -667,13 +766,17 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
     rb_thread_t *th = thread_struct_from_object(thread);
     rb_control_frame_t *cfp = th->cfp, *end_cfp = RUBY_VM_END_CONTROL_FRAME(th);
 
-    // `vm_backtrace.c` includes this check in several methods, and I think this happens on either dead or newly-created
-    // threads, but I'm not entirely sure
-    if (end_cfp == NULL) return 0;
+    // This should not happen for ddtrace (it can only happen when a thread is still being created), but I've imported
+    // it from https://github.com/ruby/ruby/pull/7116 in a "just in case" kind of mindset.
+    if (cfp == NULL) return 0;
 
     // Avoid sampling dead threads
     if (th->status == THREAD_KILLED) return 0;
 
+    // `vm_backtrace.c` includes this check in several methods. This happens on newly-created threads, and may
+    // also (not entirely sure) happen on dead threads
+    if (end_cfp == NULL) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
+
     // Fix: Skip dummy frame that shows up in main thread.
     //
     // According to a comment in `backtrace_each` (`vm_backtrace.c`), there's two dummy frames that we should ignore
@@ -717,15 +820,6 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
 
 #endif // USE_LEGACY_RB_PROFILE_FRAMES
 
-#ifdef NO_THREAD_HAS_GVL
-int ruby_thread_has_gvl_p(void) {
-  // TODO: The CpuAndWallTimeWorker needs this function, but Ruby 2.2 doesn't expose it... For now this placeholder
-  // will enable the profiling native extension to continue to compile on Ruby 2.2, but the CpuAndWallTimeWorker will
-  // not work properly on 2.2. Will be addressed later.
-  return 0;
-}
-#endif // NO_THREAD_HAS_GVL
-
 #ifndef NO_RACTORS
   // This API and definition are exported as a public symbol by the VM BUT the function header is not defined in any public header, so we
   // repeat it here to be able to use in our code.

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.h

@@ -7,11 +7,20 @@
 // without also dragging the incompatible includes
 #ifndef PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES
   #include <ruby/thread_native.h>
+  #include <ruby/vm.h>
 #endif
 
 #include "extconf.h"
 
+// Contains the current gvl owner, and a flag to indicate if it is valid
+typedef struct {
+  bool valid;
+  rb_nativethread_id_t owner;
+} current_gvl_owner;
+
 rb_nativethread_id_t pthread_id_for(VALUE thread);
+bool is_current_thread_holding_the_gvl(void);
+current_gvl_owner gvl_owner(void);
 uint64_t native_thread_id_for(VALUE thread);
 ptrdiff_t stack_depth_for(VALUE thread);
 VALUE ddtrace_thread_list(void);