ddtrace 0.54.2 → 1.2.0

data/ext/ddtrace_profiling_loader/ddtrace_profiling_loader.c

@@ -0,0 +1,118 @@
+#include <stdbool.h>
+#include <dlfcn.h>
+#include <ruby.h>
+
+// Why this exists:
+//
+// The Datadog::Profiling::Loader exists because when Ruby loads a native extension (using `require`), it uses
+// `dlopen(..., RTLD_LAZY | RTLD_GLOBAL)` (https://github.com/ruby/ruby/blob/67950a4c0a884bdb78d9beb4405ebf7459229b21/dln.c#L362).
+// This means that every symbol exposed directly or indirectly by that native extension becomes visible to every other
+// extension in the Ruby process. This can cause issues, see https://github.com/rubyjs/mini_racer/pull/179.
+//
+// Instead of `RTLD_LAZY | RTLD_GLOBAL`, we want to call `dlopen` with `RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND` when
+// loading the profiling native extension, to avoid leaking any unintended symbols (`RTLD_LOCAL`) and avoid picking
+// up other's symbols (`RTLD_DEEPBIND`).
+//
+// But Ruby's extension loading mechanism is not configurable -- there's no way to tell it to use different flags when
+// calling `dlopen`. To get around this, this file (ddtrace_profiling_loader.c) introduces another extension
+// (profiling loader) which has only a single responsibility: mimic Ruby's extension loading mechanism, but when calling
+// `dlopen` use a different set of flags.
+// This idea was shamelessly stolen from @lloeki's work in https://github.com/rubyjs/mini_racer/pull/179, big thanks!
+//
+// Extra note: Currently (May 2022), that we know of, the profiling native extension only exposes one potentially
+// problematic symbol: `rust_eh_personality` (coming from libddprof/libdatadog).
+// Future versions of Rust have been patched not to expose this
+// (see https://github.com/rust-lang/rust/pull/95604#issuecomment-1108563434) so we may want to revisit the need
+// for this loader in the future, and perhaps delete it if we no longer require its services :)
+
+#ifndef RTLD_DEEPBIND
+  #define RTLD_DEEPBIND 0
+#endif
+
+static VALUE ok_symbol = Qnil; // :ok in Ruby
+static VALUE error_symbol = Qnil; // :error in Ruby
+
+static VALUE _native_load(VALUE self, VALUE ruby_path, VALUE ruby_init_name);
+static bool failed_to_load(void *handle, VALUE *failure_details);
+static bool incompatible_library(void *handle, VALUE *failure_details);
+static bool failed_to_initialize(void *handle, char *init_name, VALUE *failure_details);
+static void set_failure_from_dlerror(VALUE *failure_details);
+static void unload_failed_library(void *handle);
+
+#define DDTRACE_EXPORT __attribute__ ((visibility ("default")))
+
+void DDTRACE_EXPORT Init_ddtrace_profiling_loader(void) {
+  VALUE datadog_module = rb_define_module("Datadog");
+  VALUE profiling_module = rb_define_module_under(datadog_module, "Profiling");
+  VALUE loader_module = rb_define_module_under(profiling_module, "Loader");
+  rb_define_singleton_method(loader_module, "_native_load", _native_load, 2);
+
+  ok_symbol = ID2SYM(rb_intern_const("ok"));
+  error_symbol = ID2SYM(rb_intern_const("error"));
+}
+
+static VALUE _native_load(VALUE self, VALUE ruby_path, VALUE ruby_init_name) {
+  Check_Type(ruby_path, T_STRING);
+  Check_Type(ruby_init_name, T_STRING);
+
+  char *path = StringValueCStr(ruby_path);
+  char *init_name = StringValueCStr(ruby_init_name);
+
+  void *handle = dlopen(path, RTLD_LAZY | RTLD_LOCAL | RTLD_DEEPBIND);
+
+  VALUE failure_details = Qnil;
+
+  if (
+    failed_to_load(handle, &failure_details) ||
+    incompatible_library(handle, &failure_details) ||
+    failed_to_initialize(handle, init_name, &failure_details)
+  ) {
+    return rb_ary_new_from_args(2, error_symbol, failure_details);
+  }
+
+  return rb_ary_new_from_args(2, ok_symbol, Qnil);
+}
+
+static bool failed_to_load(void *handle, VALUE *failure_details) {
+  if (handle == NULL) {
+    set_failure_from_dlerror(failure_details);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+static bool incompatible_library(void *handle, VALUE *failure_details) {
+  // The library being loaded may be linked to a different libruby than the current executing Ruby.
+  // We check if this is the case by checking if a well-known symbol resolves to a common address.
+  if (dlsym(handle, "ruby_xmalloc") != &ruby_xmalloc) {
+    *failure_details = rb_str_new_cstr("library was compiled and linked to a different Ruby version");
+    unload_failed_library(handle);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+static bool failed_to_initialize(void *handle, char *init_name, VALUE *failure_details) {
+  void (*initialization_function)(void) = dlsym(handle, init_name);
+
+  if (initialization_function == NULL) {
+    set_failure_from_dlerror(failure_details);
+    unload_failed_library(handle);
+    return true;
+  } else {
+    (*initialization_function)();
+    return false;
+  }
+}
+
+static void set_failure_from_dlerror(VALUE *failure_details) {
+  char *failure = dlerror();
+  *failure_details = failure == NULL ? Qnil : rb_str_new_cstr(failure);
+}
+
+static void unload_failed_library(void *handle) {
+  // Note: According to the Ruby VM sources, this may fail with a segfault on really old versions of macOS (< 10.11)
+  dlclose(handle);
+}

data/ext/ddtrace_profiling_loader/extconf.rb

@@ -0,0 +1,54 @@
+# typed: ignore
+
+# rubocop:disable Style/StderrPuts
+# rubocop:disable Style/GlobalVars
+
+if RUBY_ENGINE != 'ruby' || Gem.win_platform?
+  $stderr.puts(
+    'WARN: Skipping build of ddtrace profiling loader. See ddtrace profiling native extension note for details.'
+  )
+
+  File.write('Makefile', 'all install clean: # dummy makefile that does nothing')
+  exit
+end
+
+require 'mkmf'
+
+# 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
+def add_compiler_flag(flag)
+  if try_cflags(flag)
+    $CFLAGS << ' ' << flag
+  else
+    $stderr.puts("WARNING: '#{flag}' not accepted by compiler, skipping it")
+  end
+end
+
+# Gets really noisy when we include the MJIT header, let's omit it
+add_compiler_flag '-Wno-unused-function'
+
+# Allow defining variables at any point in a function
+add_compiler_flag '-Wno-declaration-after-statement'
+
+# If we forget to include a Ruby header, the function call may still appear to work, but then
+# cause a segfault later. Let's ensure that never happens.
+add_compiler_flag '-Werror-implicit-function-declaration'
+
+# The native extension is not intended to expose any symbols/functions for other native libraries to use;
+# the sole exception being `Init_ddtrace_profiling_loader` which needs to be visible for Ruby to call it when
+# it `dlopen`s the library.
+#
+# By setting this compiler flag, we tell it to assume that everything is private unless explicitly stated.
+# For more details see https://gcc.gnu.org/wiki/Visibility
+add_compiler_flag '-fvisibility=hidden'
+
+# 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
+# the wrong library is never loaded.
+# When requiring, we need to use the exact same string, including the version and the platform.
+EXTENSION_NAME = "ddtrace_profiling_loader.#{RUBY_VERSION}_#{RUBY_PLATFORM}".freeze
+
+create_makefile(EXTENSION_NAME)
+
+# rubocop:enable Style/GlobalVars
+# rubocop:enable Style/StderrPuts

data/ext/ddtrace_profiling_native_extension/NativeExtensionDesign.md

@@ -1,32 +1,60 @@
 # Profiling Native Extension Design
 
-The profiling native extension is used to implement features which are expensive (in terms of resources) or otherwise
-impossible to implement using Ruby code.
+The profiling native extension is used to:
+1. Implement features which are expensive (in terms of resources) or otherwise impossible to implement using Ruby code.
+2. Bridge between Ruby-specific profiling features and [`libddprof`](https://github.com/DataDog/libddprof), a Rust-based
+library with common profiling functionality.
 
-This extension is quite coupled with MRI Ruby ("C Ruby") internals, and is not intended to support other rubies such as
+Due to (1), this extension is quite coupled with MRI Ruby ("C Ruby") internals, and is not intended to support other rubies such as
 JRuby or TruffleRuby. When below we say "Ruby", read it as "MRI Ruby".
 
 ## Disabling
 
-The profiling native extension can be disabled by setting `DD_PROFILING_NO_EXTENSION=true` when installing or running
+The profiling native extension can be disabled by setting `DD_PROFILING_NO_EXTENSION=true` when installing
 the gem. Setting `DD_PROFILING_NO_EXTENSION` at installation time skips compilation of the extension entirely.
 
 (If you're a customer and needed to use this, please tell us why on <https://github.com/DataDog/dd-trace-rb/issues/new>.)
 
-Currently the profiler can still "limp along" when the native extension is disabled, but the plan is to require it
-in future releases -- e.g. disabling the extension will disable profiling entirely.
+In past releases, it was possible for the profiler to run without the native extension, but that's no longer the case,
+and disabling the extension will disable profiling.
 
-## Safety
+## Must not block or break users that cannot use it
 
 The profiling native extension is (and must always be) designed to **not cause failures** during gem installation, even
 if some features, Ruby versions, or operating systems are not supported.
 
-E.g. the extension must cleanly build on Ruby 2.1 (or the oldest Ruby version we support at the time) on Windows,
+E.g. the extension must not break installation on Ruby 2.1 (or the oldest Ruby version we support at the time) on 64-bit ARM macOS,
 even if at run time it will effectively do nothing for such a setup.
 
 We have a CI setup to help validate this, but this is really important to keep in mind when adding to or changing the
 existing codebase.
 
+## Memory leaks and Interaction with Ruby VM APIs
+
+When adding to or changing the native extension, we must always consider what API calls can lead to Ruby exceptions to
+be raised, and whether there are is dynamically-allocated memory that can be leaked if that happens.
+
+(When a Ruby exception is raised, the VM will use `setjmp` and `longjmp` to jump back in the stack and thus skip
+our clean-up code, like in a Ruby-level exception.)
+
+We avoid issues using a combination of:
+
+* Avoiding dynamic allocation as much as possible
+* Getting all needed data and doing all validations before doing any dynamic allocations
+* Avoiding calling Ruby VM APIs after doing dynamic allocations
+* Wrapping dynamic allocations into Ruby GC-managed objects (using `TypedData_Wrap_Struct`), so that Ruby will manage
+  their lifetime and call `free` when the GC-managed object is no longer being referenced
+* Using [`rb_protect` and similar APIs](https://silverhammermba.github.io/emberb/c/?#rescue) to run cleanup code on
+  exception cases
+
+Non-exhaustive list of APIs that cause exceptions to be raised:
+
+* `Check_TypedStruct`, `Check_Type`
+* `rb_funcall`
+* `rb_thread_call_without_gvl`, `rb_thread_call_without_gvl2`
+* [Numeric conversion APIs, e.g. `NUM2LONG`, `NUM2INT`, etc.](https://silverhammermba.github.io/emberb/c/?#translation)
+* Our `char_slice_from_ruby_string` helper
+
 ## Usage of private VM headers
 
 To implement some of the features below, we sometimes require access to private Ruby header files (that describe VM
@@ -64,7 +92,6 @@ Thus, even though a regular Ruby installation does not include these files, we c
 ## Feature: Getting thread CPU-time clock_ids
 
 * **OS support**: Linux
-* **Ruby support**: 2.6+
 
 To enable CPU-time profiling, we use the `pthread_getcpuclockid(pthread_t thread, clockid_t *clockid)` C function to
 obtain a `clockid_t` that can then be used with the `Process.clock_gettime` method (or directly with the

data/ext/ddtrace_profiling_native_extension/clock_id.h

@@ -1,4 +1,4 @@
 #pragma once
 
-void self_test_clock_id();
+void self_test_clock_id(void);
 VALUE clock_id_for(VALUE self, VALUE thread);

data/ext/ddtrace_profiling_native_extension/clock_id_from_pthread.c

@@ -9,19 +9,11 @@
 #include <errno.h>
 
 #include <ruby.h>
-
-#ifdef RUBY_2_1_WORKAROUND
-#include <thread_native.h>
-#else
-#include <ruby/thread_native.h>
-#endif
-
 #include "private_vm_api_access.h"
-
 #include "clock_id.h"
 
 // Validate that our home-cooked pthread_id_for() matches pthread_self() for the current thread
-void self_test_clock_id() {
+void self_test_clock_id(void) {
   rb_nativethread_id_t expected_pthread_id = pthread_self();
   rb_nativethread_id_t actual_pthread_id = pthread_id_for(rb_thread_current());
 

data/ext/ddtrace_profiling_native_extension/clock_id_noop.c

@@ -8,7 +8,7 @@
 
 #include "clock_id.h"
 
-void self_test_clock_id() { } // Nothing to check
+void self_test_clock_id(void) { } // Nothing to check
 VALUE clock_id_for(VALUE self, VALUE thread) { return Qnil; } // Nothing to return
 
 #endif

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time.c

@@ -0,0 +1,269 @@
+#include <ruby.h>
+#include "collectors_stack.h"
+#include "stack_recorder.h"
+#include "private_vm_api_access.h"
+
+// Used to periodically (time-based) sample threads, recording elapsed CPU-time and Wall-time between samples.
+// This file implements the native bits of the Datadog::Profiling::Collectors::CpuAndWallTime class
+
+static VALUE collectors_cpu_and_wall_time_class = Qnil;
+
+// Contains state for a single CpuAndWallTime instance
+struct cpu_and_wall_time_collector_state {
+  // Note: Places in this file that usually need to be changed when this struct is changed are tagged with
+  // "Update this when modifying state struct"
+
+  // Required by Datadog::Profiling::Collectors::Stack as a scratch buffer during sampling
+  sampling_buffer *sampling_buffer;
+  // Hashmap <Thread Object, struct per_thread_context>
+  st_table *hash_map_per_thread_context;
+  // Datadog::Profiling::StackRecorder instance
+  VALUE recorder_instance;
+  // Track how many samples we've taken.
+  unsigned int sample_count;
+};
+
+// Tracks per-thread state
+struct per_thread_context {
+  int dummy_placeholder_will_be_removed_in_next_pr;
+};
+
+static void cpu_and_wall_time_collector_typed_data_mark(void *state_ptr);
+static void cpu_and_wall_time_collector_typed_data_free(void *state_ptr);
+static int hash_map_per_thread_context_mark(st_data_t key_thread, st_data_t _value, st_data_t _argument);
+static int hash_map_per_thread_context_free_values(st_data_t _thread, st_data_t value_per_thread_context, st_data_t _argument);
+static VALUE _native_new(VALUE klass);
+static VALUE _native_initialize(VALUE self, VALUE collector_instance, VALUE recorder_instance, VALUE max_frames);
+static VALUE _native_sample(VALUE self, VALUE collector_instance);
+static void sample(VALUE collector_instance);
+static VALUE _native_thread_list(VALUE self);
+static struct per_thread_context *get_or_create_context_for(VALUE thread, struct cpu_and_wall_time_collector_state *state);
+static VALUE _native_inspect(VALUE self, VALUE collector_instance);
+static VALUE per_thread_context_st_table_as_ruby_hash(struct cpu_and_wall_time_collector_state *state);
+static int per_thread_context_as_ruby_hash(st_data_t key_thread, st_data_t value_context, st_data_t result_hash);
+static void remove_context_for_dead_threads(struct cpu_and_wall_time_collector_state *state);
+static int remove_if_dead_thread(st_data_t key_thread, st_data_t value_context, st_data_t _argument);
+static VALUE _native_per_thread_context(VALUE self, VALUE collector_instance);
+
+void collectors_cpu_and_wall_time_init(VALUE profiling_module) {
+  VALUE collectors_module = rb_define_module_under(profiling_module, "Collectors");
+  collectors_cpu_and_wall_time_class = rb_define_class_under(collectors_module, "CpuAndWallTime", rb_cObject);
+
+  // Instances of the CpuAndWallTime class are "TypedData" objects.
+  // "TypedData" objects are special objects in the Ruby VM that can wrap C structs.
+  // In this case, it wraps the cpu_and_wall_time_collector_state.
+  //
+  // Because Ruby doesn't know how to initialize native-level structs, we MUST override the allocation function for objects
+  // of this class so that we can manage this part. Not overriding or disabling the allocation function is a common
+  // gotcha for "TypedData" objects that can very easily lead to VM crashes, see for instance
+  // https://bugs.ruby-lang.org/issues/18007 for a discussion around this.
+  rb_define_alloc_func(collectors_cpu_and_wall_time_class, _native_new);
+
+  rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_initialize", _native_initialize, 3);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_sample", _native_sample, 1);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_thread_list", _native_thread_list, 0);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_inspect", _native_inspect, 1);
+  rb_define_singleton_method(collectors_cpu_and_wall_time_class, "_native_per_thread_context", _native_per_thread_context, 1);
+}
+
+// This structure is used to define a Ruby object that stores a pointer to a struct cpu_and_wall_time_collector_state
+// See also https://github.com/ruby/ruby/blob/master/doc/extension.rdoc for how this works
+static const rb_data_type_t cpu_and_wall_time_collector_typed_data = {
+  .wrap_struct_name = "Datadog::Profiling::Collectors::CpuAndWallTime",
+  .function = {
+    .dmark = cpu_and_wall_time_collector_typed_data_mark,
+    .dfree = cpu_and_wall_time_collector_typed_data_free,
+    .dsize = NULL, // We don't track profile memory usage (although it'd be cool if we did!)
+    //.dcompact = NULL, // FIXME: Add support for compaction
+  },
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+// This function is called by the Ruby GC to give us a chance to mark any Ruby objects that we're holding on to,
+// so that they don't get garbage collected
+static void cpu_and_wall_time_collector_typed_data_mark(void *state_ptr) {
+  struct cpu_and_wall_time_collector_state *state = (struct cpu_and_wall_time_collector_state *) state_ptr;
+
+  // Update this when modifying state struct
+  rb_gc_mark(state->recorder_instance);
+  st_foreach(state->hash_map_per_thread_context, hash_map_per_thread_context_mark, 0 /* unused */);
+}
+
+static void cpu_and_wall_time_collector_typed_data_free(void *state_ptr) {
+  struct cpu_and_wall_time_collector_state *state = (struct cpu_and_wall_time_collector_state *) state_ptr;
+
+  // Update this when modifying state struct
+
+  // Important: Remember that we're only guaranteed to see here what's been set in _native_new, aka
+  // pointers that have been set NULL there may still be NULL here.
+  if (state->sampling_buffer != NULL) sampling_buffer_free(state->sampling_buffer);
+
+  // Free each entry in the map
+  st_foreach(state->hash_map_per_thread_context, hash_map_per_thread_context_free_values, 0 /* unused */);
+  // ...and then the map
+  st_free_table(state->hash_map_per_thread_context);
+
+  ruby_xfree(state);
+}
+
+// Mark Ruby thread references we keep as keys in hash_map_per_thread_context
+static int hash_map_per_thread_context_mark(st_data_t key_thread, st_data_t _value, st_data_t _argument) {
+  VALUE thread = (VALUE) key_thread;
+  rb_gc_mark(thread);
+  return ST_CONTINUE;
+}
+
+// Used to clear each of the per_thread_contexts inside the hash_map_per_thread_context
+static int hash_map_per_thread_context_free_values(st_data_t _thread, st_data_t value_per_thread_context, st_data_t _argument) {
+  struct per_thread_context *per_thread_context = (struct per_thread_context*) value_per_thread_context;
+  ruby_xfree(per_thread_context);
+  return ST_CONTINUE;
+}
+
+static VALUE _native_new(VALUE klass) {
+  struct cpu_and_wall_time_collector_state *state = ruby_xcalloc(1, sizeof(struct cpu_and_wall_time_collector_state));
+
+  // Update this when modifying state struct
+  state->sampling_buffer = NULL;
+  state->hash_map_per_thread_context =
+   // "numtable" is an awful name, but TL;DR it's what should be used when keys are `VALUE`s.
+    st_init_numtable();
+  state->recorder_instance = Qnil;
+  state->sample_count = 0;
+
+  return TypedData_Wrap_Struct(collectors_cpu_and_wall_time_class, &cpu_and_wall_time_collector_typed_data, state);
+}
+
+static VALUE _native_initialize(VALUE self, VALUE collector_instance, VALUE recorder_instance, VALUE max_frames) {
+  enforce_recorder_instance(recorder_instance);
+
+  struct cpu_and_wall_time_collector_state *state;
+  TypedData_Get_Struct(collector_instance, struct cpu_and_wall_time_collector_state, &cpu_and_wall_time_collector_typed_data, state);
+
+  int max_frames_requested = NUM2INT(max_frames);
+  if (max_frames_requested < 0) rb_raise(rb_eArgError, "Invalid max_frames: value must not be negative");
+
+  // Update this when modifying state struct
+  state->sampling_buffer = sampling_buffer_new(max_frames_requested);
+  // hash_map_per_thread_context is already initialized, nothing to do here
+  state->recorder_instance = recorder_instance;
+
+  return Qtrue;
+}
+
+// This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTime behavior using RSpec.
+// It SHOULD NOT be used for other purposes.
+static VALUE _native_sample(VALUE self, VALUE collector_instance) {
+  sample(collector_instance);
+  return Qtrue;
+}
+
+static void sample(VALUE collector_instance) {
+  struct cpu_and_wall_time_collector_state *state;
+  TypedData_Get_Struct(collector_instance, struct cpu_and_wall_time_collector_state, &cpu_and_wall_time_collector_typed_data, state);
+
+  VALUE threads = ddtrace_thread_list();
+
+  const long thread_count = RARRAY_LEN(threads);
+  for (long i = 0; i < thread_count; i++) {
+    VALUE thread = RARRAY_AREF(threads, i);
+    struct per_thread_context *thread_context = get_or_create_context_for(thread, state);
+
+    int64_t metric_values[ENABLED_VALUE_TYPES_COUNT] = {0};
+
+    // FIXME: TODO These are just dummy values for now
+    metric_values[CPU_TIME_VALUE_POS] = 12;
+    metric_values[CPU_SAMPLES_VALUE_POS] = 34;
+    metric_values[WALL_TIME_VALUE_POS] = 56;
+
+    sample_thread(
+      thread,
+      state->sampling_buffer,
+      state->recorder_instance,
+      (ddprof_ffi_Slice_i64) {.ptr = metric_values, .len = ENABLED_VALUE_TYPES_COUNT},
+      (ddprof_ffi_Slice_label) {.ptr = NULL, .len = 0} // FIXME: TODO we need to gather the expected labels
+    );
+  }
+
+  state->sample_count++;
+
+  // TODO: This seems somewhat overkill and inefficient to do often; right now we just doing every few samples
+  // but there's probably a better way to do this if we actually track when threads finish
+  if (state->sample_count % 100 == 0) remove_context_for_dead_threads(state);
+}
+
+// This method exists only to enable testing Datadog::Profiling::Collectors::CpuAndWallTime behavior using RSpec.
+// It SHOULD NOT be used for other purposes.
+static VALUE _native_thread_list(VALUE self) {
+  return ddtrace_thread_list();
+}
+
+static struct per_thread_context *get_or_create_context_for(VALUE thread, struct cpu_and_wall_time_collector_state *state) {
+  struct per_thread_context* thread_context = NULL;
+  st_data_t value_context = 0;
+
+  if (st_lookup(state->hash_map_per_thread_context, (st_data_t) thread, &value_context)) {
+    thread_context = (struct per_thread_context*) value_context;
+  } else {
+    thread_context = ruby_xcalloc(1, sizeof(struct per_thread_context));
+    st_insert(state->hash_map_per_thread_context, (st_data_t) thread, (st_data_t) thread_context);
+  }
+
+  return thread_context;
+}
+
+static VALUE _native_inspect(VALUE self, VALUE collector_instance) {
+  struct cpu_and_wall_time_collector_state *state;
+  TypedData_Get_Struct(collector_instance, struct cpu_and_wall_time_collector_state, &cpu_and_wall_time_collector_typed_data, state);
+
+  VALUE result = rb_str_new2(" (native state)");
+
+  // Update this when modifying state struct
+  rb_str_concat(result, rb_sprintf(" hash_map_per_thread_context=%"PRIsVALUE, per_thread_context_st_table_as_ruby_hash(state)));
+  rb_str_concat(result, rb_sprintf(" recorder_instance=%"PRIsVALUE, state->recorder_instance));
+  rb_str_concat(result, rb_sprintf(" sample_count=%u", state->sample_count));
+
+  return result;
+}
+
+static VALUE per_thread_context_st_table_as_ruby_hash(struct cpu_and_wall_time_collector_state *state) {
+  VALUE result = rb_hash_new();
+  st_foreach(state->hash_map_per_thread_context, per_thread_context_as_ruby_hash, result);
+  return result;
+}
+
+#define VALUE_COUNT(array) (sizeof(array) / sizeof(VALUE))
+
+static int per_thread_context_as_ruby_hash(st_data_t key_thread, st_data_t value_context, st_data_t result_hash) {
+  VALUE thread = (VALUE) key_thread;
+  VALUE result = (VALUE) result_hash;
+  VALUE context_as_hash = rb_hash_new();
+  rb_hash_aset(result, thread, context_as_hash);
+
+  VALUE arguments[] = {};
+  for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(context_as_hash, arguments[i], arguments[i+1]);
+
+  return ST_CONTINUE;
+}
+
+static void remove_context_for_dead_threads(struct cpu_and_wall_time_collector_state *state) {
+  st_foreach(state->hash_map_per_thread_context, remove_if_dead_thread, 0 /* unused */);
+}
+
+static int remove_if_dead_thread(st_data_t key_thread, st_data_t value_context, st_data_t _argument) {
+  VALUE thread = (VALUE) key_thread;
+  struct per_thread_context* thread_context = (struct per_thread_context*) value_context;
+
+  if (is_thread_alive(thread)) return ST_CONTINUE;
+
+  ruby_xfree(thread_context);
+  return ST_DELETE;
+}
+
+// Returns the whole contents of the per_thread_context structs being tracked, for debugging/testing
+static VALUE _native_per_thread_context(VALUE self, VALUE collector_instance) {
+  struct cpu_and_wall_time_collector_state *state;
+  TypedData_Get_Struct(collector_instance, struct cpu_and_wall_time_collector_state, &cpu_and_wall_time_collector_typed_data, state);
+
+  return per_thread_context_st_table_as_ruby_hash(state);
+}