ddtrace 1.5.2 → 1.6.0

data/ext/ddtrace_profiling_native_extension/http_transport.c

@@ -1,6 +1,6 @@
 #include <ruby.h>
 #include <ruby/thread.h>
-#include <ddprof/ffi.h>
+#include <datadog/profiling.h>
 #include "helpers.h"
 #include "libdatadog_helpers.h"
 #include "ruby_helpers.h"
@@ -17,22 +17,23 @@ 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;
+static VALUE library_version_string = Qnil;
 
 struct call_exporter_without_gvl_arguments {
-  ddprof_ffi_ProfileExporterV3 *exporter;
-  ddprof_ffi_Request *request;
-  ddprof_ffi_CancellationToken *cancel_token;
-  ddprof_ffi_SendResult result;
+  ddog_ProfileExporter *exporter;
+  ddog_Request *request;
+  ddog_CancellationToken *cancel_token;
+  ddog_SendResult result;
   bool send_ran;
 };
 
-inline static ddprof_ffi_ByteSlice byte_slice_from_ruby_string(VALUE string);
+inline static ddog_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 ddog_NewProfileExporterResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
+static VALUE handle_exporter_failure(ddog_NewProfileExporterResult 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,
@@ -49,6 +50,7 @@ static VALUE _native_do_export(
 );
 static void *call_exporter_without_gvl(void *call_args);
 static void interrupt_exporter_call(void *cancel_token);
+static VALUE ddtrace_version(void);
 
 void http_transport_init(VALUE profiling_module) {
   http_transport_class = rb_define_class_under(profiling_module, "HttpTransport", rb_cObject);
@@ -61,57 +63,64 @@ void http_transport_init(VALUE profiling_module) {
   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);
 }
 
-inline static ddprof_ffi_ByteSlice byte_slice_from_ruby_string(VALUE string) {
+inline static ddog_ByteSlice byte_slice_from_ruby_string(VALUE string) {
   ENFORCE_TYPE(string, T_STRING);
-  ddprof_ffi_ByteSlice byte_slice = {.ptr = (uint8_t *) StringValuePtr(string), .len = RSTRING_LEN(string)};
+  ddog_ByteSlice byte_slice = {.ptr = (uint8_t *) StringValuePtr(string), .len = RSTRING_LEN(string)};
   return byte_slice;
 }
 
 static VALUE _native_validate_exporter(DDTRACE_UNUSED VALUE _self, VALUE exporter_configuration) {
   ENFORCE_TYPE(exporter_configuration, T_ARRAY);
-  ddprof_ffi_NewProfileExporterV3Result exporter_result = create_exporter(exporter_configuration, rb_ary_new());
+  ddog_NewProfileExporterResult 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);
+  ddog_NewProfileExporterResult_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) {
+static ddog_NewProfileExporterResult 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 ddprof_ffi_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.
-  ddprof_ffi_EndpointV3 endpoint = endpoint_from(exporter_configuration);
+  ddog_Endpoint endpoint = endpoint_from(exporter_configuration);
+
+  ddog_Vec_tag tags = convert_tags(tags_as_array);
 
-  ddprof_ffi_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");
 
-  ddprof_ffi_NewProfileExporterV3Result exporter_result =
-    ddprof_ffi_ProfileExporterV3_new(DDPROF_FFI_CHARSLICE_C("ruby"), &tags, endpoint);
+  ddog_NewProfileExporterResult exporter_result =
+    ddog_ProfileExporter_new(library_name, library_version, profiling_family, &tags, endpoint);
 
-  ddprof_ffi_Vec_tag_drop(tags);
+  ddog_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;
+static VALUE handle_exporter_failure(ddog_NewProfileExporterResult exporter_result) {
+  if (exporter_result.tag == DDOG_NEW_PROFILE_EXPORTER_RESULT_OK) return Qnil;
 
   VALUE err_details = ruby_string_from_vec_u8(exporter_result.err);
 
-  ddprof_ffi_NewProfileExporterV3Result_drop(exporter_result);
+  ddog_NewProfileExporterResult_drop(exporter_result);
 
   return rb_ary_new_from_args(2, error_symbol, err_details);
 }
 
-static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration) {
+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
@@ -126,27 +135,27 @@ static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration) {
     ENFORCE_TYPE(site, T_STRING);
     ENFORCE_TYPE(api_key, T_STRING);
 
-    return ddprof_ffi_EndpointV3_agentless(char_slice_from_ruby_string(site), char_slice_from_ruby_string(api_key));
+    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 ddprof_ffi_EndpointV3_agent(char_slice_from_ruby_string(base_url));
+    return ddog_Endpoint_agent(char_slice_from_ruby_string(base_url));
   }
 }
 
 __attribute__((warn_unused_result))
-static ddprof_ffi_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);
-  ddprof_ffi_Vec_tag tags = ddprof_ffi_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)) {
-      ddprof_ffi_Vec_tag_drop(tags);
+      ddog_Vec_tag_drop(tags);
       ENFORCE_TYPE(name_value_pair, T_ARRAY);
     }
 
@@ -155,23 +164,23 @@ static ddprof_ffi_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))) {
-      ddprof_ffi_Vec_tag_drop(tags);
+      ddog_Vec_tag_drop(tags);
       ENFORCE_TYPE(tag_name, T_STRING);
       ENFORCE_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));
+    ddog_PushTagResult 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 == DDPROF_FFI_PUSH_TAG_RESULT_ERR) {
+    if (push_result.tag == DDOG_PUSH_TAG_RESULT_ERR) {
       VALUE err_details = ruby_string_from_vec_u8(push_result.err);
-      ddprof_ffi_PushTagResult_drop(push_result);
+      ddog_PushTagResult_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 {
-      ddprof_ffi_PushTagResult_drop(push_result);
+      ddog_PushTagResult_drop(push_result);
     }
   }
 
@@ -184,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(ddprof_ffi_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
-    ddprof_ffi_Vec_tag_drop(tags); // clean up
+    ddog_Vec_tag_drop(tags); // clean up
     rb_jump_tag(exception_state);  // "Re-raise" exception
   }
 }
@@ -197,17 +206,17 @@ static void safely_log_failure_to_process_tag(ddprof_ffi_Vec_tag tags, VALUE err
 // 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(
-  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,
+  ddog_NewProfileExporterResult 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,
   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);
+  ddog_ProfileExporter *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);
 
   // 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
@@ -236,24 +245,24 @@ static VALUE perform_export(
   }
 
   // Cleanup exporter and token, no longer needed
-  ddprof_ffi_CancellationToken_drop(cancel_token);
-  ddprof_ffi_NewProfileExporterV3Result_drop(valid_exporter_result);
+  ddog_CancellationToken_drop(cancel_token);
+  ddog_NewProfileExporterResult_drop(valid_exporter_result);
 
   if (pending_exception) {
     // If we got here send did not run, so we need to explicitly dispose of the request
-    ddprof_ffi_Request_drop(request);
+    ddog_Request_drop(request);
 
     // Let Ruby propagate the exception. This will not return.
     rb_jump_tag(pending_exception);
   }
 
-  ddprof_ffi_SendResult result = args.result;
-  bool success = result.tag == DDPROF_FFI_SEND_RESULT_HTTP_RESPONSE;
+  ddog_SendResult result = args.result;
+  bool success = result.tag == DDOG_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);
 
-  ddprof_ffi_SendResult_drop(args.result);
+  ddog_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);
@@ -288,29 +297,29 @@ static VALUE _native_do_export(
 
   uint64_t timeout_milliseconds = NUM2ULONG(upload_timeout_milliseconds);
 
-  ddprof_ffi_Timespec start =
+  ddog_Timespec start =
     {.seconds = NUM2LONG(start_timespec_seconds), .nanoseconds = NUM2UINT(start_timespec_nanoseconds)};
-  ddprof_ffi_Timespec finish =
+  ddog_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};
+  ddog_File files[files_to_report];
+  ddog_Slice_file slice_files = {.ptr = files, .len = files_to_report};
 
-  files[0] = (ddprof_ffi_File) {
+  files[0] = (ddog_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) {
+    files[1] = (ddog_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;
+  ddog_Vec_tag *null_additional_tags = NULL;
 
-  ddprof_ffi_NewProfileExporterV3Result exporter_result = create_exporter(exporter_configuration, tags_as_array);
+  ddog_NewProfileExporterResult 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);
@@ -322,7 +331,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 = ddprof_ffi_ProfileExporterV3_send(args->exporter, args->request, args->cancel_token);
+  args->result = ddog_ProfileExporter_send(args->exporter, args->request, args->cancel_token);
   args->send_ran = true;
 
   return NULL; // Unused
@@ -330,5 +339,15 @@ static void *call_exporter_without_gvl(void *call_args) {
 
 // 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);
+  ddog_CancellationToken_cancel((ddog_CancellationToken *) cancel_token);
+}
+
+static VALUE ddtrace_version(void) {
+  VALUE ddtrace_module = rb_const_get(rb_cObject, rb_intern("DDTrace"));
+  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/ddtrace_profiling_native_extension/libdatadog_helpers.h

@@ -1,14 +1,14 @@
 #pragma once
 
-#include <ddprof/ffi.h>
+#include <datadog/profiling.h>
 #include "ruby_helpers.h"
 
-inline static ddprof_ffi_CharSlice char_slice_from_ruby_string(VALUE string) {
+inline static ddog_CharSlice char_slice_from_ruby_string(VALUE string) {
   ENFORCE_TYPE(string, T_STRING);
-  ddprof_ffi_CharSlice char_slice = {.ptr = StringValuePtr(string), .len = RSTRING_LEN(string)};
+  ddog_CharSlice char_slice = {.ptr = StringValuePtr(string), .len = RSTRING_LEN(string)};
   return char_slice;
 }
 
-inline static VALUE ruby_string_from_vec_u8(ddprof_ffi_Vec_u8 string) {
+inline static VALUE ruby_string_from_vec_u8(ddog_Vec_u8 string) {
   return rb_str_new((char *) string.ptr, string.len);
 }

data/ext/ddtrace_profiling_native_extension/native_extension_helpers.rb

@@ -31,8 +31,9 @@ module Datadog
       # 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 libdatadog. (This gets set automatically by the call
-      # to `pkg_config('ddprof_ffi_with_rpath')` in `extconf.rb`). This worked fine as long as libdatadog was **NOT**
+      # In older versions of ddtrace, we only set as runpath an absolute path to libdatadog.
+      # (This gets set automatically by the call
+      # to `pkg_config('datadog_profiling_with_rpath')` in `extconf.rb`). This worked fine as long as libdatadog 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

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.c

@@ -49,6 +49,40 @@ rb_nativethread_id_t pthread_id_for(VALUE thread) {
   #endif
 }
 
+// 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)
+// Modifications: None
+#if defined(__linux__) || defined(__FreeBSD__)
+# define RB_THREAD_T_HAS_NATIVE_ID
+#endif
+
+uint64_t native_thread_id_for(VALUE thread) {
+  // The tid is only available on Ruby >= 3.1 + Linux (and FreeBSD). It's the same as `gettid()` aka the task id as seen in /proc
+  #if !defined(NO_THREAD_TID) && defined(RB_THREAD_T_HAS_NATIVE_ID)
+    #ifndef NO_RB_NATIVE_THREAD
+      return thread_struct_from_object(thread)->nt->tid;
+    #else
+      return thread_struct_from_object(thread)->tid;
+    #endif
+  #else
+    rb_nativethread_id_t pthread_id = pthread_id_for(thread);
+
+    #ifdef __APPLE__
+      uint64_t result;
+      // On macOS, this gives us the same identifier that shows up in activity monitor
+      int error = pthread_threadid_np(pthread_id, &result);
+      if (error) rb_syserr_fail(error, "Unexpected failure in pthread_threadid_np");
+      return result;
+    #else
+      // Fallback, when we have nothing better (e.g. on Ruby < 3.1 on Linux)
+      // @ivoanjo: In the future we may want to explore some potential hacks to get the actual tid on linux
+      // (e.g. https://stackoverflow.com/questions/558469/how-do-i-get-a-thread-id-from-an-arbitrary-pthread-t )
+      return (uint64_t) pthread_id;
+    #endif
+  #endif
+}
+
 // Returns the stack depth by using the same approach as rb_profile_frames and backtrace_each: get the positions
 // of the end and current frame pointers and subtracting them.
 ptrdiff_t stack_depth_for(VALUE thread) {
@@ -690,3 +724,28 @@ int ruby_thread_has_gvl_p(void) {
   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.
+  bool rb_ractor_main_p_(void);
+  extern struct rb_ractor_struct *ruby_single_main_ractor;
+
+  // Taken from upstream ractor_core.h at commit d9cf0388599a3234b9f3c06ddd006cd59a58ab8b (November 2022, Ruby 3.2 trunk)
+  // to allow us to ensure that we're always operating on the main ractor (if Ruby has ractors)
+  // Modifications:
+  // * None
+  bool ddtrace_rb_ractor_main_p(void)
+  {
+      if (ruby_single_main_ractor) {
+          return true;
+      }
+      else {
+          return rb_ractor_main_p_();
+      }
+  }
+#else
+  // Simplify callers on older Rubies, instead of having them probe if the VM supports Ractors we just tell them that yes
+  // they're always on the main Ractor
+  bool ddtrace_rb_ractor_main_p(void) { return true; }
+#endif // NO_RACTORS

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.h

@@ -12,12 +12,15 @@
 #include "extconf.h"
 
 rb_nativethread_id_t pthread_id_for(VALUE thread);
+uint64_t native_thread_id_for(VALUE thread);
 ptrdiff_t stack_depth_for(VALUE thread);
 VALUE ddtrace_thread_list(void);
 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);
+// 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).

data/ext/ddtrace_profiling_native_extension/profiling.c

@@ -2,6 +2,7 @@
 
 #include "clock_id.h"
 #include "helpers.h"
+#include "private_vm_api_access.h"
 
 // Each class/module here is implemented in their separate file
 void collectors_cpu_and_wall_time_init(VALUE profiling_module);
@@ -11,6 +12,7 @@ void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
 
 static VALUE native_working_p(VALUE self);
+static VALUE _native_ddtrace_rb_ractor_main_p(DDTRACE_UNUSED VALUE _self);
 
 void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
   VALUE datadog_module = rb_define_module("Datadog");
@@ -27,6 +29,10 @@ void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
   collectors_stack_init(profiling_module);
   http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
+
+  // Hosts methods used for testing the native code using RSpec
+  VALUE testing_module = rb_define_module_under(native_extension_module, "Testing");
+  rb_define_singleton_method(testing_module, "_native_ddtrace_rb_ractor_main_p", _native_ddtrace_rb_ractor_main_p, 0);
 }
 
 static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
@@ -34,3 +40,7 @@ static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
 
   return Qtrue;
 }
+
+static VALUE _native_ddtrace_rb_ractor_main_p(DDTRACE_UNUSED VALUE _self) {
+  return ddtrace_rb_ractor_main_p() ? Qtrue : Qfalse;
+}

data/ext/ddtrace_profiling_native_extension/ruby_helpers.c

@@ -2,7 +2,6 @@
 
 void raise_unexpected_type(
   VALUE value,
-  DDTRACE_UNUSED enum ruby_value_type _type,
   const char *value_name,
   const char *type_name,
   const char *file,

data/ext/ddtrace_profiling_native_extension/ruby_helpers.h

@@ -45,12 +45,14 @@ static inline int check_if_pending_exception(void) {
 // 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, type, ADD_QUOTES(value), ADD_QUOTES(type), __FILE__, __LINE__, __func__); }
+  { 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,
-  enum ruby_value_type type,
   const char *value_name,
   const char *type_name,
   const char *file,