gvl-tracing 1.6.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bf28c6665bf4afa02c13299947bb65d7c62c3af783858afdc3a5383e334fa47
-  data.tar.gz: b1999e7e17d56e76ba732962708c14979e2690cd78204946d2f05e7146b05725
+  metadata.gz: d331bd3080954e6c98634d72ed6a0a7b0ed3aa622cb2455bb38aea773d5ed44b
+  data.tar.gz: 6ba87866b4bcf64463aa60dee238fb1000367d8028f360237c88ed9a22353625
 SHA512:
-  metadata.gz: feb5fb173e07343af18c929608b20b2463fc0b676565b926242585f3fed31991e34ab5f549d7cbfe0e26c883d4a1e6eebf1d8da9e1586f0fa63d0890cdd3b108
-  data.tar.gz: 615226e345e230b989d7738754f02a058935d67679b4ca16c610cbbb6fe34f82aff6de3299d9548af579a30d55bccaedf25cd52d4f631023cff93a683fe3c8bb
+  metadata.gz: 0a6cb0429d039c6980c1df628e33d8f5275ecefb0bc5417e59af714ee48c505c24b3a099e8e0d1d57654c3afabdd199588a88d6f35b0f65eafa50aea18b3bfd3
+  data.tar.gz: fb4b359539bb519526e6232b72b383c2de3ee1c9bae171f302918c52a8646a8e19386012946ccecf5611e05f176fa8b250e2761e2bc32ad077508c9ffdc2b8d8

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/README.adoc

@@ -8,9 +8,14 @@ A Ruby gem for getting a timeline view of Global VM Lock usage in your Ruby app
 
 image::preview.png[]
 
-For instructions and examples on how to use it, see my https://ivoanjo.me/blog/2023/07/23/understanding-the-ruby-global-vm-lock-by-observing-it/[RubyKaigi 2023 talk on "Understanding the Ruby Global VM Lock by observing it"].
+There's a few blog posts and conference talks about what this gem is and how to read its results:
 
-NOTE: This gem only works on Ruby 3.2 and above because it depends on the https://github.com/ruby/ruby/pull/5500[GVL Instrumentation API]. Furthermore, the GVL Instrumentation API does not (as of Ruby 3.2 and 3.3) currently work on Microsoft Windows.
+* https://ivoanjo.me/blog/2025/03/30/mn-scheduling-and-how-the-ruby-gvl-impacts-app-perf/[m:n scheduling and how the (ruby) global vm lock impacts app performance]
+* https://ivoanjo.me/blog/2023/07/23/understanding-the-ruby-global-vm-lock-by-observing-it/[understanding the ruby global vm lock by observing it]
+* https://ivoanjo.me/blog/2023/02/11/ruby-unexpected-io-vs-cpu-unfairness/[ruby’s unexpected i/o vs cpu unfairness]
+* https://ivoanjo.me/blog/2022/07/17/tracing-ruby-global-vm-lock/[tracing ruby’s (global) vm lock] (Also available [https://techracho.bpsinc.jp/hachi8833/2022_09_02/120530[in Japanese] and https://velog.io/@heka1024/%EB%B2%88%EC%97%AD-tracing-rubys-global-vm-lock[in Korean])
+
+NOTE: This gem only works on Ruby 3.2 and above because it depends on the https://github.com/ruby/ruby/pull/5500[GVL Instrumentation API]. Furthermore, the GVL Instrumentation API does not (as of this writing) currently work on Microsoft Windows.
 
 == Quickest start
 
@@ -68,11 +73,25 @@ This gem only provides a single module (`GvlTracing`) with methods:
 
 The resulting traces can be analyzed by going to https://ui.perfetto.dev/[Perfetto UI].
 
-== Experimental features
+=== What do each of the events mean?
+
+The following events are shown in the timeline:
 
-1. Sleep tracking: Add `require 'gvl_tracing/sleep_tracking'` to add a more specific `sleeping` state for sleeps (which are otherwise rendered as `waiting` without this feature)
+* `started_tracing`: First event, when `GvlTracing` is enabled
+* `stopped_tracing`: Last event, when `GvlTracing` is disabled
+* `started`: Ruby thread created
+* `died`: Ruby thread died
+* `wants_gvl`: Ruby thread is ready to execute, but needs the GVL before it can do so
+* `running`: Ruby thread is running code (and owns the GVL)
+* `waiting`: Ruby thread is waiting to be waken up when some event happens (IO, timeout)
+* `gc`: Doing garbage collection
+* `sleeping`: Thread called `Kernel#sleep`
+
+Note that not all events come from the GVL instrumentation API, and some events were renamed vs the "RUBY_INTERNAL_THREAD_EVENT" entries.
+
+== Experimental features
 
-2. OS threads view: Pass in `os_threads_view_enabled: true` to `GvlTracing.start` to also render a view of Ruby thread activity from the OS native threads point-of-view. This is useful when using M:N thread scheduling, which is used on Ruby 3.3+ Ractors, and when using the `RUBY_MN_THREADS=1` setting.
+1. OS threads view: Pass in `os_threads_view_enabled: true` to `GvlTracing.start` to also render a view of Ruby thread activity from the OS native threads point-of-view. This is useful when using M:N thread scheduling, which is used on Ruby 3.3+ Ractors, and when using the `RUBY_MN_THREADS=1` setting.
 
 == Tips
 

data/ext/gvl_tracing_native_extension/direct-bind.c

@@ -0,0 +1,175 @@
+// direct-bind: Ruby gem for getting direct access to function pointers
+// Copyright (c) 2025 Ivo Anjo <ivo@ivoanjo.me>
+//
+// This file is part of direct-bind.
+//
+// MIT License
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// See direct-bind.h for details on using direct-bind and why you may be finding this file vendored inside another gem.
+
+#include "direct-bind.h"
+
+static bool direct_bind_self_test(bool raise_on_failure);
+
+// # Initialization and version management
+
+bool direct_bind_initialize(VALUE publish_version_under, bool raise_on_failure) {
+  if (!direct_bind_self_test(raise_on_failure)) return false;
+
+  if (publish_version_under != Qnil) {
+    rb_define_const(rb_define_module_under(publish_version_under, "DirectBind"), "VERSION", rb_str_new_lit(DIRECT_BIND_VERSION));
+  }
+
+  return true;
+}
+
+// # Self-test implementation
+
+#define SELF_TEST_ARITY 3
+
+static VALUE self_test_target_func(
+  __attribute__((unused)) VALUE _1,
+  __attribute__((unused)) VALUE _2,
+  __attribute__((unused)) VALUE _3,
+  __attribute__((unused)) VALUE _4
+) {
+  return Qnil;
+}
+
+static bool direct_bind_self_test(bool raise_on_failure) {
+  VALUE anonymous_module = rb_module_new();
+  rb_define_method(anonymous_module, "direct_bind_self_test_target", self_test_target_func, SELF_TEST_ARITY);
+
+  ID self_test_id = rb_intern("direct_bind_self_test_target");
+  direct_bind_cfunc_result test_target = direct_bind_get_cfunc_with_arity(anonymous_module, self_test_id, SELF_TEST_ARITY, raise_on_failure);
+
+  return test_target.ok && test_target.func == self_test_target_func;
+}
+
+// # Structure layouts and exported symbol definitions from Ruby
+
+// ## From internal/gc.h
+void rb_objspace_each_objects(int (*callback)(void *start, void *end, size_t stride, void *data), void *data);
+int rb_objspace_internal_object_p(VALUE obj);
+
+// ## From method.h
+typedef struct rb_method_entry_struct {
+  VALUE flags;
+  VALUE defined_class;
+  struct rb_method_definition_struct * const def;
+  ID called_id;
+  VALUE owner;
+} rb_method_entry_t;
+
+// ### This was simplified/inlined vs the original structure
+struct rb_method_definition_struct {
+  unsigned int type: 4;
+  int _ignored;
+  struct {
+    VALUE (*func)(ANYARGS);
+    void *_ignored;
+    int argc;
+  } cfunc;
+};
+
+// # This is where the magic happens: Using objectspace to find the method entry and retrieve the cfunc
+
+typedef struct {
+  VALUE target_klass;
+  ID target_id;
+  direct_bind_cfunc_result result;
+} find_data_t;
+
+static bool valid_method_entry(VALUE object);
+static bool found_target_method_entry(rb_method_entry_t *method_entry, find_data_t *find_data);
+static int find_cfunc(void *start, void *end, size_t stride, void *data);
+
+direct_bind_cfunc_result direct_bind_get_cfunc(VALUE klass, ID method_name, bool raise_on_failure) {
+  VALUE definition_not_found = rb_sprintf("method %"PRIsVALUE".%"PRIsVALUE" not found", klass, ID2SYM(method_name));
+
+  find_data_t find_data = {.target_klass = klass, .target_id = method_name, .result = {.ok = false, .failure_reason = definition_not_found}};
+  rb_objspace_each_objects(find_cfunc, &find_data);
+
+  if (raise_on_failure && find_data.result.ok == false) {
+    rb_raise(rb_eRuntimeError, "direct_bind_get_cfunc failed: %"PRIsVALUE, find_data.result.failure_reason);
+  }
+
+  return find_data.result;
+}
+
+direct_bind_cfunc_result direct_bind_get_cfunc_with_arity(VALUE klass, ID method_name, int arity, bool raise_on_failure) {
+  direct_bind_cfunc_result result = direct_bind_get_cfunc(klass, method_name, raise_on_failure);
+
+  if (result.ok && result.arity != arity) {
+    VALUE unexpected_arity = rb_sprintf("method %"PRIsVALUE".%"PRIsVALUE" unexpected arity %d, expected %d", klass, ID2SYM(method_name), result.arity, arity);
+
+    if (raise_on_failure) rb_raise(rb_eRuntimeError, "direct_bind_get_cfunc_with_arity failed: %"PRIsVALUE, unexpected_arity);
+    else result = (direct_bind_cfunc_result) {.ok = false, .failure_reason = unexpected_arity};
+  }
+
+  return result;
+}
+
+// TODO: Maybe change this to use safe memory reads that can never segv (e.g. if structure layouts are off?)
+static int find_cfunc(void *start, void *end, size_t stride, void *data) {
+  const int stop_iteration = 1;
+  const int continue_iteration = 0;
+  const int vm_method_type_cfunc = 1;
+
+  find_data_t *find_data = (find_data_t *) data;
+
+  for (VALUE v = (VALUE) start; v != (VALUE) end; v += stride) {
+    if (!valid_method_entry(v)) continue;
+
+    rb_method_entry_t *method_entry = (rb_method_entry_t*) v;
+    if (!found_target_method_entry(method_entry, find_data)) continue;
+
+    if (method_entry->def == NULL) {
+      find_data->result.failure_reason = rb_str_new_lit("method_entry->def is NULL");
+    } else if (method_entry->def->type != vm_method_type_cfunc) {
+      find_data->result.failure_reason = rb_str_new_lit("method_entry is not a cfunc");
+    } else {
+      find_data->result = (direct_bind_cfunc_result) {
+        .ok = true,
+        .failure_reason = Qnil,
+        .arity = method_entry->def->cfunc.argc,
+        .func = method_entry->def->cfunc.func,
+      };
+    }
+    return stop_iteration;
+  }
+
+  return continue_iteration;
+}
+
+static bool is_method_entry(VALUE imemo) {
+  const unsigned long method_entry_id = 6;
+  return ((RBASIC(imemo)->flags >> FL_USHIFT) & method_entry_id) == method_entry_id;
+}
+
+static bool valid_method_entry(VALUE object) {
+  return rb_objspace_internal_object_p(object) && RB_BUILTIN_TYPE(object) == RUBY_T_IMEMO && RB_TYPE_P(object, RUBY_T_IMEMO) && is_method_entry(object);
+}
+
+static bool found_target_method_entry(rb_method_entry_t *method_entry, find_data_t *find_data) {
+  VALUE method_klass = method_entry->defined_class ? method_entry->defined_class : method_entry->owner;
+  return method_klass == find_data->target_klass && method_entry->called_id == find_data->target_id;
+}

data/ext/gvl_tracing_native_extension/direct-bind.h

@@ -0,0 +1,61 @@
+// direct-bind: Ruby gem for getting direct access to function pointers
+// Copyright (c) 2025 Ivo Anjo <ivo@ivoanjo.me>
+//
+// This file is part of direct-bind.
+//
+// MIT License
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// The recommended way to consume the direct-bind gem is to always vendor it.
+// That is, use its rake task to automatically copy direct-bind.h and direct-bind.c into another gem's native extension
+// sources folder. (P.s.: There's also a test helper to make sure copying is working fine and the gem is up-to-date.)
+//
+// This makes the actual Ruby direct-bind gem only a development dependency, simplifying distribution for the gem
+// that uses it.
+//
+// For more details, check the direct-bind gem's documentation.
+
+#pragma once
+
+#include <stdbool.h>
+#include <ruby.h>
+
+#define DIRECT_BIND_VERSION "1.0.0"
+
+typedef struct {
+  bool ok;
+  VALUE failure_reason;
+  int arity;
+  VALUE (*func)(ANYARGS);
+} direct_bind_cfunc_result;
+
+// Recommended to call once during your gem's initialization, to validate that direct-bind's Ruby hacking is in good shape and
+// to make it easy to (optionally) validate what version you're using
+bool direct_bind_initialize(VALUE publish_version_under, bool raise_on_failure);
+
+// Provides the reverse of `rb_define_method`: Given a class and a method_name, retrieves the arity and func previously
+// passed to `rb_define_method`.
+//
+// Performance note: As of this writing, this method scans objspace to find the definition of the method, so you
+// most probably want to cache its result, rather than calling it very often.
+direct_bind_cfunc_result direct_bind_get_cfunc(VALUE klass, ID method_name, bool raise_on_failure);
+
+// Same as above, but automatically fails if arity isn't the expected value
+direct_bind_cfunc_result direct_bind_get_cfunc_with_arity(VALUE klass, ID method_name, int arity, bool raise_on_failure);

data/ext/gvl_tracing_native_extension/gvl_tracing.c

@@ -27,6 +27,7 @@
 #include <ruby/debug.h>
 #include <ruby/thread.h>
 #include <ruby/atomic.h>
+
 #include <errno.h>
 #include <inttypes.h>
 #include <stdbool.h>
@@ -34,6 +35,8 @@
 #include <pthread.h>
 #include <stdint.h>
 
+#include "direct-bind.h"
+
 #include "extconf.h"
 
 #ifdef HAVE_PTHREAD_H
@@ -69,7 +72,6 @@ typedef struct {
   #endif
   VALUE thread;
   rb_event_flag_t previous_state; // Used to coalesce similar events
-  bool sleeping; // Used to track when a thread is sleeping
 } thread_local_state;
 
 // Global mutable state
@@ -83,9 +85,13 @@ static VALUE gc_tracepoint = Qnil;
 static int thread_storage_key = 0;
 static VALUE all_seen_threads = Qnil;
 static pthread_mutex_t all_seen_threads_mutex = PTHREAD_MUTEX_INITIALIZER;
-static pthread_mutex_t output_mutex = PTHREAD_MUTEX_INITIALIZER;
 static bool os_threads_view_enabled;
+static uint32_t timeslice_meta_ms = 0;
+
+static ID sleep_id;
+static VALUE (*is_thread_alive)(VALUE thread);
 
+static inline void initialize_timeslice_meta(void);
 static VALUE tracing_init_local_storage(VALUE, VALUE);
 static VALUE tracing_start(UNUSED_ARG VALUE _self, VALUE output_path, VALUE os_threads_view_enabled_arg);
 static VALUE tracing_stop(VALUE _self);
@@ -93,11 +99,8 @@ static double timestamp_microseconds(void);
 static double render_event(thread_local_state *, const char *event_name);
 static void on_thread_event(rb_event_flag_t event, const rb_internal_thread_event_data_t *_unused1, void *_unused2);
 static void on_gc_event(VALUE tpval, void *_unused1);
-static VALUE mark_sleeping(VALUE _self);
 static size_t thread_local_state_memsize(UNUSED_ARG const void *_unused);
 static void thread_local_state_mark(void *data);
-static inline void output_mutex_lock(void);
-static inline void output_mutex_unlock(void);
 static inline int32_t thread_id_for(thread_local_state *state);
 static VALUE ruby_thread_id_for(UNUSED_ARG VALUE _self, VALUE thread);
 static VALUE trim_all_seen_threads(UNUSED_ARG VALUE _self);
@@ -140,14 +143,27 @@ void Init_gvl_tracing_native_extension(void) {
 
   all_seen_threads = rb_ary_new();
 
+  sleep_id = rb_intern("sleep");
+
   VALUE gvl_tracing_module = rb_define_module("GvlTracing");
 
   rb_define_singleton_method(gvl_tracing_module, "_init_local_storage", tracing_init_local_storage, 1);
   rb_define_singleton_method(gvl_tracing_module, "_start", tracing_start, 2);
   rb_define_singleton_method(gvl_tracing_module, "_stop", tracing_stop, 0);
-  rb_define_singleton_method(gvl_tracing_module, "mark_sleeping", mark_sleeping, 0);
   rb_define_singleton_method(gvl_tracing_module, "_thread_id_for", ruby_thread_id_for, 1);
   rb_define_singleton_method(gvl_tracing_module, "trim_all_seen_threads", trim_all_seen_threads, 0);
+
+  initialize_timeslice_meta();
+
+  direct_bind_initialize(gvl_tracing_module, true);
+  is_thread_alive = direct_bind_get_cfunc_with_arity(rb_cThread, rb_intern("alive?"), 0, true).func;
+}
+
+static inline void initialize_timeslice_meta(void) {
+  const char *timeslice = getenv("RUBY_THREAD_TIMESLICE");
+  if (timeslice) {
+    timeslice_meta_ms = (uint32_t) strtol(timeslice, NULL, 0);
+  }
 }
 
 static inline void initialize_thread_local_state(thread_local_state *state) {
@@ -187,10 +203,15 @@ static VALUE tracing_start(UNUSED_ARG VALUE _self, VALUE output_path, VALUE os_t
   VALUE ruby_version = rb_const_get(rb_cObject, rb_intern("RUBY_VERSION"));
   Check_Type(ruby_version, T_STRING);
 
+  VALUE metadata = rb_obj_dup(ruby_version);
+  if (timeslice_meta_ms > 0) {
+    rb_str_append(metadata, rb_sprintf(", %ums", timeslice_meta_ms));
+  }
+
   fprintf(output_file, "[\n");
   fprintf(output_file,
     "  {\"ph\": \"M\", \"pid\": %"PRId64", \"name\": \"process_name\", \"args\": {\"name\": \"Ruby threads view (%s)\"}},\n",
-    process_id, StringValuePtr(ruby_version)
+    process_id, StringValuePtr(metadata)
   );
 
   double now_microseconds = render_event(state, "started_tracing");
@@ -216,6 +237,8 @@ static VALUE tracing_start(UNUSED_ARG VALUE _self, VALUE output_path, VALUE os_t
 
   rb_tracepoint_enable(gc_tracepoint);
 
+  RB_GC_GUARD(metadata);
+
   return Qtrue;
 }
 
@@ -262,7 +285,6 @@ static double render_event(thread_local_state *state, const char *event_name) {
   // Important note: We've observed some rendering issues in perfetto if the tid or pid are numbers that are "too big",
   // see https://github.com/ivoanjo/gvl-tracing/pull/4#issuecomment-1196463364 for an example.
 
-  output_mutex_lock();
   fprintf(output_file,
     // Finish previous duration
     "  {\"ph\": \"E\", \"pid\": %"PRId64", \"tid\": %d, \"ts\": %f},\n" \
@@ -273,7 +295,6 @@ static double render_event(thread_local_state *state, const char *event_name) {
     // Args for second line
     process_id, thread_id_for(state), now_microseconds, event_name
   );
-  output_mutex_unlock();
 
   return now_microseconds;
 }
@@ -285,9 +306,13 @@ static void on_thread_event(rb_event_flag_t event_id, const rb_internal_thread_e
 
   if (!state) return;
 
-  #ifdef RUBY_3_3_PLUS
-    if (!state->thread) state->thread = event_data->thread;
-  #endif
+  if (!state->thread) {
+    #ifdef RUBY_3_3_PLUS
+      state->thread = event_data->thread;
+    #else
+      if (event_id == RUBY_INTERNAL_THREAD_EVENT_SUSPENDED) { state->thread = rb_thread_current(); }
+    #endif
+  }
   // In some cases, Ruby seems to emit multiple suspended events for the same thread in a row (e.g. when multiple threads)
   // are waiting on a Thread::ConditionVariable.new that gets signaled. We coalesce these events to make the resulting
   // timeline easier to see.
@@ -298,11 +323,18 @@ static void on_thread_event(rb_event_flag_t event_id, const rb_internal_thread_e
   if (event_id == RUBY_INTERNAL_THREAD_EVENT_SUSPENDED && event_id == state->previous_state) return;
   state->previous_state = event_id;
 
-  if (event_id == RUBY_INTERNAL_THREAD_EVENT_SUSPENDED && state->sleeping) {
-    render_event(state, "sleeping");
-    return;
-  } else {
-    state->sleeping = false;
+  if (event_id == RUBY_INTERNAL_THREAD_EVENT_SUSPENDED &&
+      // Check that thread is not being shut down
+      (state->thread != Qnil && is_thread_alive(state->thread))
+  ) {
+    ID current_method = 0;
+    VALUE current_method_owner = Qnil;
+    rb_frame_method_id_and_class(&current_method, &current_method_owner);
+
+    if (current_method == sleep_id && current_method_owner == rb_mKernel) {
+      render_event(state, "sleeping");
+      return;
+    }
   }
 
   const char* event_name = "bug_unknown_event";
@@ -338,11 +370,6 @@ static void on_gc_event(VALUE tpval, UNUSED_ARG void *_unused1) {
   render_event(state, event_name);
 }
 
-static VALUE mark_sleeping(UNUSED_ARG VALUE _self) {
-  GT_CURRENT_THREAD_LOCAL_STATE()->sleeping = true;
-  return Qnil;
-}
-
 static size_t thread_local_state_memsize(UNUSED_ARG const void *_unused) { return sizeof(thread_local_state); }
 
 static void thread_local_state_mark(void *data) {
@@ -360,18 +387,6 @@ static inline void all_seen_threads_mutex_unlock(void) {
   if (error) rb_syserr_fail(error, "Failed to unlock GvlTracing mutex");
 }
 
-static inline void output_mutex_lock(void) {
-  int error = pthread_mutex_lock(&output_mutex);
-  // Can't raise exceptions on error since it gets used from outside the GVL
-  if (error) fprintf(stderr, "Failed to lock the GvlTracing output_mutex");
-}
-
-static inline void output_mutex_unlock(void) {
-  int error = pthread_mutex_unlock(&output_mutex);
-  // Can't raise exceptions on error since it gets used from outside the GVL
-  if (error) fprintf(stderr, "Failed to unlock the GvlTracing output_mutex");
-}
-
 #ifdef RUBY_3_3_PLUS
   static inline thread_local_state *GT_LOCAL_STATE(VALUE thread, bool allocate) {
     thread_local_state *state = rb_internal_thread_specific_get(thread, thread_storage_key);
@@ -461,21 +476,17 @@ static void render_os_thread_event(thread_local_state *state, double now_microse
   // chars, so here we append a different letter to each thread to cause the color hashing to differ.
   char color_suffix_hack = ('a' + (thread_id_for(state) % 26));
 
-  output_mutex_lock();
   fprintf(output_file,
     "  {\"ph\": \"B\", \"pid\": %"PRId64", \"tid\": %u, \"ts\": %f, \"name\": \"Thread %d (%c)\"},\n",
     OS_THREADS_VIEW_PID, current_native_thread_id(), now_microseconds, thread_id_for(state), color_suffix_hack
   );
-  output_mutex_unlock();
 }
 
 static void finish_previous_os_thread_event(double now_microseconds) {
-  output_mutex_lock();
   fprintf(output_file,
     "  {\"ph\": \"E\", \"pid\": %"PRId64", \"tid\": %u, \"ts\": %f},\n",
     OS_THREADS_VIEW_PID, current_native_thread_id(), now_microseconds
   );
-  output_mutex_unlock();
 }
 
 static inline uint32_t current_native_thread_id(void) {

data/lib/gvl_tracing/sleep_tracking.rb

@@ -1,12 +1 @@
-# Experimental: This monkey patch when loaded introduces a new state -- "sleeping" -- which is more specific than the
-# regular "waiting". This can be useful to distinguish when waiting is happening based on time, vs for some event to
-# happen.
-
-module GvlTracing::SleepTracking
-  def sleep(...)
-    GvlTracing.mark_sleeping
-    super
-  end
-end
-
-include GvlTracing::SleepTracking
+warn("GvlTracing::SleepTracking no longer requires loading this file. Please remove your require 'gvl_tracing/sleep_tracking'.")

data/lib/gvl_tracing/version.rb

@@ -26,5 +26,5 @@
 # frozen_string_literal: true
 
 module GvlTracing
-  VERSION = "1.6.1"
+  VERSION = "1.7.0"
 end

metadata

@@ -1,16 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gvl-tracing
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.7.0
 platform: ruby
 authors:
 - Ivo Anjo
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-08 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: 
 email:
 - ivo@ivoanjo.me
 executables: []
@@ -18,9 +16,12 @@ extensions:
 - ext/gvl_tracing_native_extension/extconf.rb
 extra_rdoc_files: []
 files:
+- ".rspec"
 - CODE_OF_CONDUCT.adoc
 - LICENSE
 - README.adoc
+- ext/gvl_tracing_native_extension/direct-bind.c
+- ext/gvl_tracing_native_extension/direct-bind.h
 - ext/gvl_tracing_native_extension/extconf.rb
 - ext/gvl_tracing_native_extension/gvl_tracing.c
 - gvl-tracing.gemspec
@@ -32,7 +33,6 @@ homepage: https://github.com/ivoanjo/gvl-tracing
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -48,8 +48,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Get a timeline view of Global VM Lock usage in your Ruby app
 test_files: []