ddtrace 1.9.0 → 1.10.0

data/ext/ddtrace_profiling_native_extension/collectors_thread_context.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <ruby.h>
+
+void thread_context_collector_sample(
+  VALUE self_instance,
+  long current_monotonic_wall_time_ns,
+  VALUE profiler_overhead_stack_thread
+);
+void thread_context_collector_sample_allocation(VALUE self_instance, unsigned int sample_weight);
+VALUE thread_context_collector_sample_after_gc(VALUE self_instance);
+void thread_context_collector_on_gc_start(VALUE self_instance);
+void thread_context_collector_on_gc_finish(VALUE self_instance);
+VALUE enforce_thread_context_collector_instance(VALUE object);

data/ext/ddtrace_profiling_native_extension/extconf.rb

@@ -1,5 +1,3 @@
-# typed: ignore
-
 # rubocop:disable Style/StderrPuts
 # rubocop:disable Style/GlobalVars
 
@@ -28,7 +26,7 @@ def skip_building_extension!(reason)
   if fail_install_if_missing_extension
     require 'mkmf'
     Logging.message(
-      ' [ddtrace] Failure cause: ' \
+      '[ddtrace] Failure cause: ' \
       "#{Datadog::Profiling::NativeExtensionHelpers::Supported.render_skipped_reason_file(**reason)}\n"
     )
   else
@@ -67,9 +65,9 @@ $stderr.puts(
 # that may fail on an environment not properly setup for building Ruby extensions.
 require 'mkmf'
 
-Logging.message(" [ddtrace] Using compiler:\n")
+Logging.message("[ddtrace] Using compiler:\n")
 xsystem("#{CONFIG['CC']} -v")
-Logging.message(" [ddtrace] End of compiler information\n")
+Logging.message("[ddtrace] End of compiler information\n")
 
 # mkmf on modern Rubies actually has an append_cflags that does something similar
 # (see https://github.com/ruby/ruby/pull/5760), but as usual we need a bit more boilerplate to deal with legacy Rubies
@@ -125,7 +123,7 @@ if RUBY_PLATFORM.include?('linux')
   # have_library 'pthread'
   # have_func 'pthread_getcpuclockid'
   # ```
-  # but it broke the build on Windows and on older Ruby versions (2.2)
+  # but a) it broke the build on Windows, b) on older Ruby versions (2.2 and below) and c) It's slower to build
   # so instead we just assume that we have the function we need on Linux, and nowhere else
   $defs << '-DHAVE_PTHREAD_GETCPUCLOCKID'
 end
@@ -162,19 +160,10 @@ if RUBY_VERSION < '2.4'
   $defs << '-DUSE_LEGACY_RB_VM_FRAME_METHOD_ENTRY'
 end
 
-# For REALLY OLD Rubies...
-if RUBY_VERSION < '2.3'
-  # ...there was no rb_time_timespec_new function
-  $defs << '-DNO_RB_TIME_TIMESPEC_NEW'
-  # ...the VM changed enough that we need an alternative legacy rb_profile_frames
-  $defs << '-DUSE_LEGACY_RB_PROFILE_FRAMES'
-  # ... you couldn't name threads
-  $defs << '-DNO_THREAD_NAMES'
-end
-
 # If we got here, libdatadog is available and loaded
 ENV['PKG_CONFIG_PATH'] = "#{ENV['PKG_CONFIG_PATH']}:#{Libdatadog.pkgconfig_folder}"
-Logging.message(" [ddtrace] PKG_CONFIG_PATH set to #{ENV['PKG_CONFIG_PATH'].inspect}\n")
+Logging.message("[ddtrace] PKG_CONFIG_PATH set to #{ENV['PKG_CONFIG_PATH'].inspect}\n")
+$stderr.puts("Using libdatadog #{Libdatadog::VERSION} from #{Libdatadog.pkgconfig_folder}")
 
 unless pkg_config('datadog_profiling_with_rpath')
   skip_building_extension!(
@@ -197,7 +186,7 @@ end
 $LDFLAGS += \
   ' -Wl,-rpath,$$$\\\\{ORIGIN\\}/' \
   "#{Datadog::Profiling::NativeExtensionHelpers.libdatadog_folder_relative_to_native_lib_folder}"
-Logging.message(" [ddtrace] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
+Logging.message("[ddtrace] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
 
 # Tag the native extension library with the Ruby version and Ruby platform.
 # This makes it easier for development (avoids "oops I forgot to rebuild when I switched my Ruby") and ensures that

data/ext/ddtrace_profiling_native_extension/http_transport.c

@@ -21,7 +21,7 @@ static VALUE library_version_string = Qnil;
 
 struct call_exporter_without_gvl_arguments {
   ddog_prof_Exporter *exporter;
-  ddog_prof_Exporter_Request *request;
+  ddog_prof_Exporter_Request_BuildResult *build_result;
   ddog_CancellationToken *cancel_token;
   ddog_prof_Exporter_SendResult result;
   bool send_ran;
@@ -83,7 +83,7 @@ static VALUE _native_validate_exporter(DDTRACE_UNUSED VALUE _self, VALUE exporte
 
   // 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_prof_Exporter_NewResult_drop(exporter_result);
+  ddog_prof_Exporter_drop(exporter_result.ok);
 
   return rb_ary_new_from_args(2, ok_symbol, Qnil);
 }
@@ -111,13 +111,9 @@ static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration
 }
 
 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_prof_vec_u8(exporter_result.err);
-
-  ddog_prof_Exporter_NewResult_drop(exporter_result);
-
-  return rb_ary_new_from_args(2, error_symbol, err_details);
+  return exporter_result.tag == DDOG_PROF_EXPORTER_NEW_RESULT_OK ?
+    Qnil :
+    rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&exporter_result.err));
 }
 
 static ddog_Endpoint endpoint_from(VALUE exporter_configuration) {
@@ -173,14 +169,9 @@ static ddog_Vec_Tag convert_tags(VALUE tags_as_array) {
       ddog_Vec_Tag_push(&tags, char_slice_from_ruby_string(tag_name), char_slice_from_ruby_string(tag_value));
 
     if (push_result.tag == DDOG_VEC_TAG_PUSH_RESULT_ERR) {
-      VALUE err_details = ruby_string_from_vec_u8(push_result.err);
-      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_Vec_Tag_PushResult_drop(push_result);
+      safely_log_failure_to_process_tag(tags, get_error_details_and_drop(&push_result.err));
     }
   }
 
@@ -206,23 +197,28 @@ 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_prof_Exporter_NewResult valid_exporter_result, // Must be called with a valid exporter result
+  ddog_prof_Exporter *exporter,
   ddog_Timespec start,
   ddog_Timespec finish,
   ddog_prof_Exporter_Slice_File slice_files,
   ddog_Vec_Tag *additional_tags,
   uint64_t timeout_milliseconds
 ) {
-  ddog_prof_Exporter *exporter = valid_exporter_result.ok;
-  ddog_CancellationToken *cancel_token = ddog_CancellationToken_new();
   ddog_prof_ProfiledEndpointsStats *endpoints_stats = NULL; // Not in use yet
-  ddog_prof_Exporter_Request *request =
+  ddog_prof_Exporter_Request_BuildResult build_result =
     ddog_prof_Exporter_Request_build(exporter, start, finish, slice_files, additional_tags, endpoints_stats, timeout_milliseconds);
 
+  if (build_result.tag == DDOG_PROF_EXPORTER_REQUEST_BUILD_RESULT_ERR) {
+    ddog_prof_Exporter_drop(exporter);
+    return rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&build_result.err));
+  }
+
+  ddog_CancellationToken *cancel_token = ddog_CancellationToken_new();
+
   // 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};
+    {.exporter = exporter, .build_result = &build_result, .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.
@@ -247,26 +243,23 @@ static VALUE perform_export(
 
   // Cleanup exporter and token, no longer needed
   ddog_CancellationToken_drop(cancel_token);
-  ddog_prof_Exporter_NewResult_drop(valid_exporter_result);
+  ddog_prof_Exporter_drop(exporter);
 
   if (pending_exception) {
     // If we got here send did not run, so we need to explicitly dispose of the request
-    ddog_prof_Exporter_Request_drop(request);
+    ddog_prof_Exporter_Request_drop(&build_result.ok);
 
     // Let Ruby propagate the exception. This will not return.
     rb_jump_tag(pending_exception);
   }
 
-  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_prof_vec_u8(result.err);
+  // The request itself does not need to be freed as libdatadog takes ownership of it as part of sending.
 
-  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.
+  ddog_prof_Exporter_SendResult result = args.result;
 
-  return rb_ary_new_from_args(2, ruby_status, ruby_result);
+  return result.tag == DDOG_PROF_EXPORTER_SEND_RESULT_HTTP_RESPONSE ?
+    rb_ary_new_from_args(2, ok_symbol, UINT2NUM(result.http_response.code)) :
+    rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&result.err));
 }
 
 static VALUE _native_do_export(
@@ -326,13 +319,13 @@ static VALUE _native_do_export(
   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);
+  return perform_export(exporter_result.ok, 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 = ddog_prof_Exporter_send(args->exporter, args->request, args->cancel_token);
+  args->result = ddog_prof_Exporter_send(args->exporter, &args->build_result->ok, args->cancel_token);
   args->send_ran = true;
 
   return NULL; // Unused

data/ext/ddtrace_profiling_native_extension/libdatadog_helpers.h

@@ -13,6 +13,13 @@ 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);
+inline static VALUE ruby_string_from_error(const ddog_Error *error) {
+  ddog_CharSlice char_slice = ddog_Error_message(error);
+  return rb_str_new(char_slice.ptr, char_slice.len);
+}
+
+inline static VALUE get_error_details_and_drop(ddog_Error *error) {
+  VALUE result = ruby_string_from_error(error);
+  ddog_Error_drop(error);
+  return result;
 }

data/ext/ddtrace_profiling_native_extension/native_extension_helpers.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# typed: ignore
-
 require 'rubygems'
 require 'pathname'
 
@@ -17,7 +15,7 @@ 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'
+      LIBDATADOG_VERSION = '~> 2.0.0.1.0'
 
       def self.fail_install_if_missing_extension?
         ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == 'true'
@@ -87,8 +85,8 @@ module Datadog
             on_windows? ||
             on_macos? ||
             on_unknown_os? ||
-            not_on_amd64_or_arm64? ||
-            on_ruby_2_1? ||
+            on_unsupported_cpu_arch? ||
+            on_unsupported_ruby_version? ||
             expected_to_use_mjit_but_mjit_is_disabled? ||
             libdatadog_not_available? ||
             libdatadog_not_usable?
@@ -174,6 +172,8 @@ module Datadog
           '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.',
+          '(Tip: When fixing this, ensure `pkg-config` is installed **before**',
+          'running `bundle install`, and remember to clear any installed gems cache).',
           suggested: CONTACT_SUPPORT,
         )
 
@@ -251,7 +251,7 @@ module Datadog
           unknown_os_not_supported unless RUBY_PLATFORM.include?('darwin') || RUBY_PLATFORM.include?('linux')
         end
 
-        private_class_method def self.not_on_amd64_or_arm64?
+        private_class_method def self.on_unsupported_cpu_arch?
           architecture_not_supported = explain_issue(
             'your CPU architecture is not supported by the Datadog Continuous Profiler.',
             suggested: GET_IN_TOUCH,
@@ -260,13 +260,13 @@ module Datadog
           architecture_not_supported unless RUBY_PLATFORM.start_with?('x86_64', 'aarch64', 'arm64')
         end
 
-        private_class_method def self.on_ruby_2_1?
+        private_class_method def self.on_unsupported_ruby_version?
           ruby_version_not_supported = explain_issue(
-            'the profiler only supports Ruby 2.2 or newer.',
+            'the profiler only supports Ruby 2.3 or newer.',
             suggested: UPGRADE_RUBY,
           )
 
-          ruby_version_not_supported if RUBY_VERSION.start_with?('2.1.')
+          ruby_version_not_supported if RUBY_VERSION.start_with?('2.1.', '2.2.')
         end
 
         # On some Rubies, we require the mjit header to be present. If Ruby was installed without MJIT support, we also skip

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.c

@@ -204,8 +204,7 @@ ptrdiff_t stack_depth_for(VALUE thread) {
 #endif
 
 // Tries to match rb_thread_list() but that method isn't accessible to extensions
-VALUE ddtrace_thread_list(void) {
-  VALUE result = rb_ary_new();
+void ddtrace_thread_list(VALUE result_array) {
   rb_thread_t *thread = NULL;
 
   // Ruby 3 Safety: Our implementation is inspired by `rb_ractor_thread_list` BUT that method wraps the operations below
@@ -234,32 +233,20 @@ VALUE ddtrace_thread_list(void) {
         case THREAD_RUNNABLE:
         case THREAD_STOPPED:
         case THREAD_STOPPED_FOREVER:
-          rb_ary_push(result, thread->self);
+          rb_ary_push(result_array, thread->self);
         default:
           break;
       }
     }
-
-  return result;
 }
 
 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
+  return thread_struct_from_object(thread)->name;
 }
-#pragma GCC diagnostic pop
 
 // -----------------------------------------------------------------------------
 // The sources below are modified versions of code extracted from the Ruby project.
@@ -290,8 +277,6 @@ VALUE thread_name_for(VALUE thread) {
 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 // SUCH DAMAGE.
 
-#ifndef USE_LEGACY_RB_PROFILE_FRAMES // Modern Rubies
-
 // Taken from upstream vm_core.h at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
 // Copyright (C) 2004-2007 Koichi Sasada
 // to support our custom rb_profile_frames (see below)
@@ -392,9 +377,6 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 //   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**
-//
 // What is rb_profile_frames?
 // `rb_profile_frames` is a Ruby VM debug API added for use by profilers for sampling the stack trace of a Ruby thread.
 // Its main other user is the stackprof profiler: https://github.com/tmm1/stackprof .
@@ -437,10 +419,6 @@ 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;
 
-    // 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;
 
@@ -448,6 +426,10 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
     // also (not entirely sure) happen on dead threads
     if (end_cfp == NULL) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
 
+    // 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;
+
     // 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
@@ -722,104 +704,8 @@ check_method_entry(VALUE obj, int can_be_svar)
       return check_method_entry(ep[-1], TRUE);
   }
 #endif // USE_LEGACY_RB_VM_FRAME_METHOD_ENTRY
-
 #endif // RUBY_MJIT_HEADER
 
-#else // USE_LEGACY_RB_PROFILE_FRAMES, Ruby < 2.3
-
-// Taken from upstream vm_backtrace.c at commit bbda1a027475bf7ce5e1a9583a7b55d0be71c8fe (March 2018, ruby_2_2 branch)
-// Copyright (C) 1993-2012 Yukihiro Matsumoto
-// to support our custom rb_profile_frames (see below)
-// Modifications: None
-inline static int
-calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
-{
-    return rb_iseq_line_no(iseq, pc - iseq->iseq_encoded);
-}
-
-// Taken from upstream vm_backtrace.c at commit bbda1a027475bf7ce5e1a9583a7b55d0be71c8fe (March 2018, ruby_2_2 branch)
-// Copyright (C) 1993-2012 Yukihiro Matsumoto
-// Modifications:
-// * Renamed rb_profile_frames => ddtrace_rb_profile_frames
-// * Add thread argument
-// * Add is_ruby_frame argument
-// * Removed `if (lines)` tests -- require/assume that like `buff`, `lines` is always specified
-// * Added support for getting the name from native methods by getting inspiration from `backtrace_each` in
-//   `vm_backtrace.c`. Note that unlike the `rb_profile_frames` for modern Rubies, this version actually returns the
-//   method name as as `VALUE` containing a Ruby string in the `buff`.
-// * Skip dummy frame that shows up in main thread
-// * 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?
-// * 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
-// 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;
-    // SEE ABOVE FOR THE FUNCTION THAT GETS USED FOR MODERN RUBIES**
-
-    int 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);
-
-    // 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
-    // at the base of every thread's stack.
-    // (see https://github.com/ruby/ruby/blob/4bd38e8120f2fdfdd47a34211720e048502377f1/vm_backtrace.c#L890-L914 )
-    //
-    // One is being pointed to by `RUBY_VM_END_CONTROL_FRAME(ec)`, and so we need to advance to the next one, and
-    // reaching it will be used as a condition to break out of the loop below.
-    //
-    // Note that in `backtrace_each` there's two calls to `RUBY_VM_NEXT_CONTROL_FRAME`, but the loop bounds there
-    // are computed in a different way, so the two calls really are equivalent to one here.
-    end_cfp = RUBY_VM_NEXT_CONTROL_FRAME(end_cfp);
-
-    // See comment on `record_placeholder_stack_in_native_code` for a full explanation of what this means (and why we don't just return 0)
-    if (end_cfp <= cfp) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
-
-    for (i=0; i<limit && cfp != end_cfp;) {
-        if (cfp->iseq && cfp->pc) { /* should be NORMAL_ISEQ */
-            if (start > 0) {
-                start--;
-                continue;
-            }
-
-            /* record frame info */
-            buff[i] = cfp->iseq->self;
-            lines[i] = calc_lineno(cfp->iseq, cfp->pc);
-            is_ruby_frame[i] = true;
-            i++;
-        } else if (RUBYVM_CFUNC_FRAME_P(cfp)) {
-            ID mid = cfp->me->def ? cfp->me->def->original_id : cfp->me->called_id;
-            buff[i] = rb_id2str(mid);
-            lines[i] = 0;
-            is_ruby_frame[i] = false;
-            i++;
-        }
-        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-    }
-
-    return i;
-}
-
-#endif // USE_LEGACY_RB_PROFILE_FRAMES
-
 #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

@@ -23,7 +23,7 @@ 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);
+void ddtrace_thread_list(VALUE result_array);
 bool is_thread_alive(VALUE thread);
 VALUE thread_name_for(VALUE thread);
 

data/ext/ddtrace_profiling_native_extension/profiling.c

@@ -10,11 +10,11 @@
 #include "time_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_dynamic_sampling_rate_init(VALUE profiling_module);
 void collectors_idle_sampling_helper_init(VALUE profiling_module);
 void collectors_stack_init(VALUE profiling_module);
+void collectors_thread_context_init(VALUE profiling_module);
 void http_transport_init(VALUE profiling_module);
 void stack_recorder_init(VALUE profiling_module);
 
@@ -43,11 +43,11 @@ 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_dynamic_sampling_rate_init(profiling_module);
   collectors_idle_sampling_helper_init(profiling_module);
   collectors_stack_init(profiling_module);
+  collectors_thread_context_init(profiling_module);
   http_transport_init(profiling_module);
   stack_recorder_init(profiling_module);
 

data/ext/ddtrace_profiling_native_extension/ruby_helpers.c

@@ -58,7 +58,7 @@ void grab_gvl_and_raise(VALUE exception_class, const char *format_string, ...) {
 
   rb_thread_call_with_gvl(trigger_raise, &args);
 
-  rb_bug("[DDTRACE] Unexpected: Reached the end of grab_gvl_and_raise while raising '%s'\n", args.exception_message);
+  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise while raising '%s'\n", args.exception_message);
 }
 
 struct syserr_raise_arguments {
@@ -91,7 +91,7 @@ void grab_gvl_and_raise_syserr(int syserr_errno, const char *format_string, ...)
 
   rb_thread_call_with_gvl(trigger_syserr_raise, &args);
 
-  rb_bug("[DDTRACE] Unexpected: Reached the end of grab_gvl_and_raise_syserr while raising '%s'\n", args.exception_message);
+  rb_bug("[ddtrace] Unexpected: Reached the end of grab_gvl_and_raise_syserr while raising '%s'\n", args.exception_message);
 }
 
 void raise_syserr(

data/ext/ddtrace_profiling_native_extension/ruby_helpers.h

@@ -12,7 +12,7 @@ static inline VALUE process_pending_interruptions(DDTRACE_UNUSED VALUE _) {
   return Qnil;
 }
 
-// RB_UNLIKELY is not supported on Ruby 2.2 and 2.3
+// RB_UNLIKELY is not supported on Ruby 2.3
 #ifndef RB_UNLIKELY
   #define RB_UNLIKELY(x) x
 #endif