ddtrace 1.2.0 → 1.4.0

data/ext/ddtrace_profiling_native_extension/http_transport.c

@@ -1,7 +1,8 @@
 #include <ruby.h>
 #include <ruby/thread.h>
 #include <ddprof/ffi.h>
-#include "libddprof_helpers.h"
+#include "helpers.h"
+#include "libdatadog_helpers.h"
 #include "ruby_helpers.h"
 
 // Used to report profiling data to Datadog.
@@ -63,13 +64,13 @@ void http_transport_init(VALUE profiling_module) {
 }
 
 inline static ddprof_ffi_ByteSlice byte_slice_from_ruby_string(VALUE string) {
-  Check_Type(string, T_STRING);
+  ENFORCE_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);
+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());
 
   VALUE failure_tuple = handle_exporter_failure(exporter_result);
@@ -83,8 +84,8 @@ static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration)
 }
 
 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);
+  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
   // to be leaked.
@@ -111,7 +112,7 @@ static VALUE handle_exporter_failure(ddprof_ffi_NewProfileExporterV3Result expor
 }
 
 static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration) {
-  Check_Type(exporter_configuration, T_ARRAY);
+  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
 
@@ -122,13 +123,13 @@ static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration) {
   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);
+    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));
   } else { // agent_id
     VALUE base_url = rb_ary_entry(exporter_configuration, 1);
-    Check_Type(base_url, T_STRING);
+    ENFORCE_TYPE(base_url, T_STRING);
 
     return ddprof_ffi_EndpointV3_agent(char_slice_from_ruby_string(base_url));
   }
@@ -136,7 +137,7 @@ static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration) {
 
 __attribute__((warn_unused_result))
 static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array) {
-  Check_Type(tags_as_array, T_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();
@@ -146,7 +147,7 @@ static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array) {
 
     if (!RB_TYPE_P(name_value_pair, T_ARRAY)) {
       ddprof_ffi_Vec_tag_drop(tags);
-      Check_Type(name_value_pair, T_ARRAY);
+      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
@@ -155,8 +156,8 @@ static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array) {
 
     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);
+      ENFORCE_TYPE(tag_name, T_STRING);
+      ENFORCE_TYPE(tag_value, T_STRING);
     }
 
     ddprof_ffi_PushTagResult push_result =
@@ -166,7 +167,7 @@ static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array) {
       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.
+      // 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 {
@@ -193,7 +194,7 @@ static void safely_log_failure_to_process_tag(ddprof_ffi_Vec_tag tags, VALUE err
   }
 }
 
-// Note: This function handles a bunch of libddprof dynamically-allocated objects, so it MUST not use any Ruby APIs
+// 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
@@ -229,45 +230,37 @@ static VALUE perform_export(
 
   while (!args.send_ran && !pending_exception) {
     rb_thread_call_without_gvl2(call_exporter_without_gvl, &args, interrupt_exporter_call, cancel_token);
+
+    // To make sure we don't leak memory, we never check for pending exceptions if send ran
     if (!args.send_ran) pending_exception = check_if_pending_exception();
   }
 
-  VALUE ruby_status;
-  VALUE ruby_result;
+  // Cleanup exporter and token, no longer needed
+  ddprof_ffi_CancellationToken_drop(cancel_token);
+  ddprof_ffi_NewProfileExporterV3Result_drop(valid_exporter_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);
+    // If we got here send did not run, so we need to explicitly dispose of the request
+    ddprof_ffi_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;
 
-  ruby_status = success ? ok_symbol : error_symbol;
-  ruby_result = success ? UINT2NUM(result.http_response.code) : ruby_string_from_vec_u8(result.failure);
+  VALUE ruby_status = success ? ok_symbol : error_symbol;
+  VALUE ruby_result = success ? UINT2NUM(result.http_response.code) : ruby_string_from_vec_u8(result.err);
 
-  // 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);
+  // 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);
 }
 
 static VALUE _native_do_export(
-  VALUE self,
+  DDTRACE_UNUSED VALUE _self,
   VALUE exporter_configuration,
   VALUE upload_timeout_milliseconds,
   VALUE start_timespec_seconds,
@@ -280,18 +273,18 @@ static VALUE _native_do_export(
   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);
+  ENFORCE_TYPE(upload_timeout_milliseconds, T_FIXNUM);
+  ENFORCE_TYPE(start_timespec_seconds, T_FIXNUM);
+  ENFORCE_TYPE(start_timespec_nanoseconds, T_FIXNUM);
+  ENFORCE_TYPE(finish_timespec_seconds, T_FIXNUM);
+  ENFORCE_TYPE(finish_timespec_nanoseconds, T_FIXNUM);
+  ENFORCE_TYPE(pprof_file_name, T_STRING);
+  ENFORCE_TYPE(pprof_data, T_STRING);
+  ENFORCE_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);
+  if (have_code_provenance) ENFORCE_TYPE(code_provenance_data, T_STRING);
 
   uint64_t timeout_milliseconds = NUM2ULONG(upload_timeout_milliseconds);
 

data/ext/ddtrace_profiling_native_extension/{libddprof_helpers.h → libdatadog_helpers.h}

@@ -1,9 +1,10 @@
 #pragma once
 
 #include <ddprof/ffi.h>
+#include "ruby_helpers.h"
 
 inline static ddprof_ffi_CharSlice char_slice_from_ruby_string(VALUE string) {
-  Check_Type(string, T_STRING);
+  ENFORCE_TYPE(string, T_STRING);
   ddprof_ffi_CharSlice char_slice = {.ptr = StringValuePtr(string), .len = RSTRING_LEN(string)};
   return char_slice;
 }

data/ext/ddtrace_profiling_native_extension/native_extension_helpers.rb

@@ -2,7 +2,7 @@
 
 # typed: ignore
 
-require 'libddprof'
+require 'libdatadog'
 require 'pathname'
 
 module Datadog
@@ -22,29 +22,29 @@ module Datadog
       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.
+      # libdatadog 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.
+      # native extension), we need to add a "runpath" -- a list of folders to search for libdatadog.
       #
       # 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**
+      # 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**
       # 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.
+      # (see https://github.com/DataDog/dd-trace-rb/issues/2067) because libdatadog 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
+      # native extension is going to be installed and the folder where libdatadog 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.
+      # the relative path can still be traversed to find libdatadog.
       #
       # 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
@@ -54,16 +54,16 @@ module Datadog
       # 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(
+      def self.libdatadog_folder_relative_to_native_lib_folder(
         current_folder: __dir__,
-        libddprof_pkgconfig_folder: Libddprof.pkgconfig_folder
+        libdatadog_pkgconfig_folder: Libdatadog.pkgconfig_folder
       )
-        return unless libddprof_pkgconfig_folder
+        return unless libdatadog_pkgconfig_folder
 
         profiling_native_lib_folder = "#{current_folder}/../../lib/"
-        libddprof_lib_folder = "#{libddprof_pkgconfig_folder}/../"
+        libdatadog_lib_folder = "#{libdatadog_pkgconfig_folder}/../"
 
-        Pathname.new(libddprof_lib_folder).relative_path_from(Pathname.new(profiling_native_lib_folder)).to_s
+        Pathname.new(libdatadog_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
@@ -86,8 +86,9 @@ module Datadog
             on_macos? ||
             on_unknown_os? ||
             not_on_amd64_or_arm64? ||
+            on_ruby_2_1? ||
             expected_to_use_mjit_but_mjit_is_disabled? ||
-            libddprof_not_usable?
+            libdatadog_not_usable?
         end
 
         # This banner will show up in the logs/terminal while compiling the native extension
@@ -137,6 +138,8 @@ module Datadog
         CONTACT_SUPPORT = [
           'For help solving this issue, please contact Datadog support at',
           '<https://docs.datadoghq.com/help/>.',
+          'You can also check out the Continuous Profiler troubleshooting page at',
+          '<https://dtdg.co/ruby-profiler-troubleshooting>.'
         ].freeze
 
         REPORT_ISSUE = [
@@ -148,9 +151,13 @@ module Datadog
           "Get in touch with us if you're interested in profiling your app!"
         ].freeze
 
+        UPGRADE_RUBY = [
+          'Upgrade to a modern Ruby to enable profiling for your app.'
+        ].freeze
+
         # Validation for this check is done in extconf.rb because it relies on mkmf
-        FAILED_TO_CONFIGURE_LIBDDPROF = explain_issue(
-          'there was a problem in setting up the `libddprof` dependency.',
+        FAILED_TO_CONFIGURE_LIBDATADOG = explain_issue(
+          'there was a problem in setting up the `libdatadog` dependency.',
           suggested: CONTACT_SUPPORT,
         )
 
@@ -242,6 +249,15 @@ module Datadog
           architecture_not_supported unless RUBY_PLATFORM.start_with?('x86_64', 'aarch64')
         end
 
+        private_class_method def self.on_ruby_2_1?
+          ruby_version_not_supported = explain_issue(
+            'the profiler only supports Ruby 2.2 or newer.',
+            suggested: UPGRADE_RUBY,
+          )
+
+          ruby_version_not_supported if RUBY_VERSION.start_with?('2.1.')
+        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?
@@ -255,17 +271,17 @@ module Datadog
           ruby_without_mjit if CAN_USE_MJIT_HEADER && RbConfig::CONFIG['MJIT_SUPPORT'] != 'yes'
         end
 
-        private_class_method def self.libddprof_not_usable?
+        private_class_method def self.libdatadog_not_usable?
           no_binaries_for_current_platform = explain_issue(
-            'the `libddprof` gem installed on your system is missing binaries for your',
+            'the `libdatadog` gem installed on your system is missing binaries for your',
             'platform variant.',
             "(Your platform: `#{Gem::Platform.local}`)",
             '(Available binaries: ',
-            "`#{Libddprof.available_binaries.join('`, `')}`)",
+            "`#{Libdatadog.available_binaries.join('`, `')}`)",
             suggested: CONTACT_SUPPORT,
           )
 
-          no_binaries_for_current_platform unless Libddprof.pkgconfig_folder
+          no_binaries_for_current_platform unless Libdatadog.pkgconfig_folder
         end
       end
       # rubocop:enable Metrics/ModuleLength

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.c

@@ -13,7 +13,13 @@
   #include RUBY_MJIT_HEADER
 #else
   // On older Rubies, use a copy of the VM internal headers shipped in the debase-ruby_core_source gem
-  #include <vm_core.h>
+
+  // We can't do anything about warnings in VM headers, so we just use this technique to surpress them.
+  // See https://nelkinda.com/blog/suppress-warnings-in-gcc-and-clang/#d11e364 for details.
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wunused-parameter"
+    #include <vm_core.h>
+  #pragma GCC diagnostic pop
   #include <iseq.h>
 #endif
 
@@ -68,7 +74,6 @@ ptrdiff_t stack_depth_for(VALUE thread) {
   #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();
@@ -103,36 +108,25 @@ VALUE ddtrace_thread_list(void) {
 
   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;
 }
 
+// `thread` gets used on all Rubies except 2.2
+// To avoid getting false "unused argument" warnings in setups where it's not used, we need to do this weird dance
+// with diagnostic stuff. See https://nelkinda.com/blog/suppress-warnings-in-gcc-and-clang/#d11e364 for details.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+VALUE thread_name_for(VALUE thread) {
+  #ifdef NO_THREAD_NAMES
+    return Qnil;
+  #else
+    return thread_struct_from_object(thread)->name;
+  #endif
+}
+#pragma GCC diagnostic pop
+
 // -----------------------------------------------------------------------------
 // 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.
@@ -174,6 +168,12 @@ bool is_thread_alive(VALUE thread) {
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
 // to support our custom rb_profile_frames (see below)
 // Modifications: None
+//
+// `node_id` gets used depending on Ruby VM compilation settings (USE_ISEQ_NODE_ID being defined).
+// To avoid getting false "unused argument" warnings in setups where it's not used, we need to do this weird dance
+// with diagnostic stuff. See https://nelkinda.com/blog/suppress-warnings-in-gcc-and-clang/#d11e364 for details.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 inline static int
 calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
 {
@@ -217,6 +217,7 @@ calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
         return 1;
     }
 }
+#pragma GCC diagnostic pop
 
 // Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
@@ -620,11 +621,11 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 // * Check thread status and do not sample if thread has been killed.
 //
 // 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 and below using the same custom function, and instead I started
+// I opted not to try to extend support to Ruby 2.2 using the same custom function, and instead I started
 // anew from the Ruby 2.2 version of the function, applying some of the same fixes that we have for the modern version.
 int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, int *lines, bool* is_ruby_frame)
 {
-    // **IMPORTANT: THIS IS A CUSTOM RB_PROFILE_FRAMES JUST FOR RUBY 2.2 AND BELOW;
+    // **IMPORTANT: THIS IS A CUSTOM RB_PROFILE_FRAMES JUST FOR RUBY 2.2;
     // SEE ABOVE FOR THE FUNCTION THAT GETS USED FOR MODERN RUBIES**
 
     int i;
@@ -680,3 +681,12 @@ 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

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.h

@@ -6,11 +6,7 @@
 // so we use PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES to be able to include private_vm_api_access.h on that file
 // without also dragging the incompatible includes
 #ifndef PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES
-  #ifdef RUBY_2_1_WORKAROUND
-    #include <thread_native.h>
-  #else
-    #include <ruby/thread_native.h>
-  #endif
+  #include <ruby/thread_native.h>
 #endif
 
 #include "extconf.h"
@@ -19,6 +15,7 @@ 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);
+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);
 

data/ext/ddtrace_profiling_native_extension/profiling.c

@@ -1,17 +1,17 @@
 #include <ruby.h>
 
 #include "clock_id.h"
+#include "helpers.h"
 
 // Each class/module here is implemented in their separate file
 void collectors_cpu_and_wall_time_init(VALUE profiling_module);
+void collectors_cpu_and_wall_time_worker_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);
 
-#define DDTRACE_EXPORT __attribute__ ((visibility ("default")))
-
 void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
   VALUE datadog_module = rb_define_module("Datadog");
   VALUE profiling_module = rb_define_module_under(datadog_module, "Profiling");
@@ -23,12 +23,13 @@ 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_cpu_and_wall_time_worker_init(profiling_module);
   collectors_stack_init(profiling_module);
   http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
 }
 
-static VALUE native_working_p(VALUE self) {
+static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
   self_test_clock_id();
 
   return Qtrue;

data/ext/ddtrace_profiling_native_extension/ruby_helpers.c

@@ -0,0 +1,25 @@
+#include "ruby_helpers.h"
+
+void raise_unexpected_type(
+  VALUE value,
+  DDTRACE_UNUSED enum ruby_value_type _type,
+  const char *value_name,
+  const char *type_name,
+  const char *file,
+  int line,
+  const char* function_name
+) {
+  rb_exc_raise(
+    rb_exc_new_str(
+      rb_eTypeError,
+      rb_sprintf("wrong argument %"PRIsVALUE" for '%s' (expected a %s) at %s:%d:in `%s'",
+        rb_inspect(value),
+        value_name,
+        type_name,
+        file,
+        line,
+        function_name
+      )
+    )
+  );
+}

data/ext/ddtrace_profiling_native_extension/ruby_helpers.h

@@ -2,13 +2,20 @@
 
 #include <ruby.h>
 
+#include "helpers.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) {
+static inline VALUE process_pending_interruptions(DDTRACE_UNUSED VALUE _) {
   rb_thread_check_ints();
   return Qnil;
 }
 
+// RB_UNLIKELY is not supported on Ruby 2.2 and 2.3
+#ifndef RB_UNLIKELY
+  #define RB_UNLIKELY(x) x
+#endif
+
 // Calls process_pending_interruptions BUT "rescues" any exceptions to be raised, returning them instead as
 // a non-zero `pending_exception`.
 //
@@ -31,3 +38,28 @@ static inline int check_if_pending_exception(void) {
   rb_protect(process_pending_interruptions, Qnil, &pending_exception);
   return pending_exception;
 }
+
+#define ADD_QUOTES_HELPER(x) #x
+#define ADD_QUOTES(x) ADD_QUOTES_HELPER(x)
+
+// Ruby has a Check_Type(value, type) that is roughly equivalent to this BUT Ruby's version is rather cryptic when it fails
+// e.g. "wrong argument type nil (expected String)". This is a replacement that prints more information to help debugging.
+#define ENFORCE_TYPE(value, type) \
+  { if (RB_UNLIKELY(!RB_TYPE_P(value, type))) raise_unexpected_type(value, type, ADD_QUOTES(value), ADD_QUOTES(type), __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,
+  int line,
+  const char* function_name
+));
+
+// This API is 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.
+//
+// Queries if the current thread is the owner of the global VM lock.
+int ruby_thread_has_gvl_p(void);