io-event 1.8.4 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8f87753ac2f9c6404a21012d3e2dd385302bbfd49b3769383ef03bc48bd85da
-  data.tar.gz: 4d158577022ddfe99db042ee2d3285bd9db86d9192e8081e0d34217f526252f4
+  metadata.gz: 7265f0fb5702ae05b5d928a8efb9e5a5e877f62afc5c93d23fec26f8a3dd1437
+  data.tar.gz: 8ba9b4b0d4e95be1401b8952cccac1a9bcc93c7a0a40e843aea60f0015c791ad
 SHA512:
-  metadata.gz: 77ef53ab5090825e04ca6fcee9f1643c42977fffced2493485b68f085790657a62c8280091a8564f92e6edd22150a762b22e70e1b3d09e42dacced90faa5b192
-  data.tar.gz: 0f11763cc34d3f84ccc0c131b275ca837f64bac73e6a87069c2bbb2e14fe5e665051f95a8495fa32a04fcd82edecefb928970e040709017393996b9d6cb7d71d
+  metadata.gz: b4346972aa2dbe00b560e2a1e2cce32a50e9acafaa0c9253f12791c183f35bea8e3cffba93eb93147b4d975ef05edeffef84e0ed8bf29934fb39c70ea1320c6f
+  data.tar.gz: 41b6b53ca30bd0934c702c1ff0899e0e8a6bd3bc97a95f455b0d6cf0be28ff690b69575c44d92a784226edea27958cd43c486e9d907989859e298d602536078b

data/ext/extconf.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2021-2024, by Samuel Williams.
+# Copyright, 2021-2025, by Samuel Williams.
 # Copyright, 2023, by Math Ieu.
 
 return if RUBY_DESCRIPTION =~ /jruby/
@@ -22,7 +22,7 @@ if ENV.key?("RUBY_DEBUG")
 	$CFLAGS << " -DRUBY_DEBUG -O0"
 end
 
-$srcs = ["io/event/event.c", "io/event/selector/selector.c", "io/event/time.c", "io/event/profile.c"]
+$srcs = ["io/event/event.c", "io/event/time.c", "io/event/fiber.c", "io/event/profiler.c", "io/event/selector/selector.c"]
 $VPATH << "$(srcdir)/io/event"
 $VPATH << "$(srcdir)/io/event/selector"
 

data/ext/io/event/array.h

@@ -159,6 +159,22 @@ inline static void* IO_Event_Array_last(struct IO_Event_Array *array)
 	else return array->base[array->limit - 1];
 }
 
+inline static void IO_Event_Array_truncate(struct IO_Event_Array *array, size_t limit)
+{
+	if (limit < array->limit) {
+		for (size_t i = limit; i < array->limit; i += 1) {
+			void **element = array->base + i;
+			if (*element) {
+				array->element_free(*element);
+				free(*element);
+				*element = NULL;
+			}
+		}
+		
+		array->limit = limit;
+	}
+}
+
 // Push a new element onto the end of the array.
 inline static void* IO_Event_Array_push(struct IO_Event_Array *array)
 {

data/ext/io/event/event.c

@@ -2,8 +2,10 @@
 // Copyright, 2021-2025, by Samuel Williams.
 
 #include "event.h"
-#include "profile.h"
+#include "fiber.h"
+#include "profiler.h"
 #include "selector/selector.h"
+#include <complex.h>
 
 void Init_IO_Event(void)
 {
@@ -13,7 +15,8 @@ void Init_IO_Event(void)
 	
 	VALUE IO_Event = rb_define_module_under(rb_cIO, "Event");
 	
-	Init_IO_Event_Profile(IO_Event);
+	Init_IO_Event_Fiber(IO_Event);
+	Init_IO_Event_Profiler(IO_Event);
 	
 	VALUE IO_Event_Selector = rb_define_module_under(IO_Event, "Selector");
 	Init_IO_Event_Selector(IO_Event_Selector);

data/ext/io/event/fiber.c

@@ -0,0 +1,63 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "fiber.h"
+
+static ID id_transfer, id_alive_p;
+
+VALUE IO_Event_Fiber_transfer(VALUE fiber, int argc, VALUE *argv) {
+	// TODO Consider introducing something like `rb_fiber_scheduler_transfer(...)`.
+#ifdef HAVE__RB_FIBER_TRANSFER
+	if (RTEST(rb_obj_is_fiber(fiber))) {
+		if (RTEST(rb_fiber_alive_p(fiber))) {
+			return rb_fiber_transfer(fiber, argc, argv);
+		}
+		
+		// If it's a fiber, but dead, we are done.
+		return Qnil;
+	}
+#endif
+	if (RTEST(rb_funcall(fiber, id_alive_p, 0))) {
+		return rb_funcallv(fiber, id_transfer, argc, argv);
+	}
+	
+	return Qnil;
+}
+
+#ifndef HAVE__RB_FIBER_RAISE
+static ID id_raise;
+
+VALUE IO_Event_Fiber_raise(VALUE fiber, int argc, VALUE *argv) {
+	return rb_funcallv(fiber, id_raise, argc, argv);
+}
+#endif
+
+#ifndef HAVE_RB_FIBER_CURRENT
+static ID id_current;
+
+static VALUE IO_Event_Fiber_current(void) {
+	return rb_funcall(rb_cFiber, id_current, 0);
+}
+#endif
+
+// There is no public interface for this... yet.
+static ID id_blocking_p;
+
+int IO_Event_Fiber_blocking(VALUE fiber) {
+	return RTEST(rb_funcall(fiber, id_blocking_p, 0));
+}
+
+void Init_IO_Event_Fiber(VALUE IO_Event) {
+	id_transfer = rb_intern("transfer");
+	id_alive_p = rb_intern("alive?");
+	
+#ifndef HAVE__RB_FIBER_RAISE
+	id_raise = rb_intern("raise");
+#endif
+	
+#ifndef HAVE_RB_FIBER_CURRENT
+	id_current = rb_intern("current");
+#endif
+	
+	id_blocking_p = rb_intern("blocking?");
+}

data/ext/io/event/fiber.h

@@ -0,0 +1,23 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#pragma once
+
+#include <ruby.h>
+
+VALUE IO_Event_Fiber_transfer(VALUE fiber, int argc, VALUE *argv);
+
+#ifdef HAVE__RB_FIBER_RAISE
+#define IO_Event_Fiber_raise(fiber, argc, argv) rb_fiber_raise(fiber, argc, argv)
+#else
+VALUE IO_Event_Fiber_raise(VALUE fiber, int argc, VALUE *argv);
+#endif
+
+#ifdef HAVE_RB_FIBER_CURRENT
+#define IO_Event_Fiber_current() rb_fiber_current()
+#else
+VALUE IO_Event_Fiber_current(void);
+#endif
+
+int IO_Event_Fiber_blocking(VALUE fiber);
+void Init_IO_Event_Fiber(VALUE IO_Event);

data/ext/io/event/profiler.c

@@ -0,0 +1,505 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "profiler.h"
+
+#include "time.h"
+#include "fiber.h"
+#include "array.h"
+
+#include <ruby/debug.h>
+#include <stdio.h>
+
+VALUE IO_Event_Profiler = Qnil;
+
+struct IO_Event_Profiler_Call {
+	struct timespec enter_time;
+	struct timespec exit_time;
+	
+	size_t nesting;
+	
+	rb_event_flag_t event_flag;
+	ID id;
+	
+	VALUE klass;
+	const char *path;
+	int line;
+	
+	struct IO_Event_Profiler_Call *parent;
+};
+
+struct IO_Event_Profiler {
+	// Configuration:
+	float log_threshold;
+	int track_calls;
+	
+	// Whether or not the profiler is currently running:
+	int running;
+	
+	// Whether or not to capture call data:
+	int capture;
+	
+	size_t stalls;
+	
+	// From this point on, the state of any profile in progress:
+	struct timespec start_time;
+	struct timespec stop_time;
+	
+	// The depth of the call stack:
+	size_t nesting;
+	
+	// The current call frame:
+	struct IO_Event_Profiler_Call *current;
+	
+	struct IO_Event_Array calls;
+};
+
+void IO_Event_Profiler_reset(struct IO_Event_Profiler *profiler) {
+	profiler->nesting = 0;
+	profiler->current = NULL;
+	IO_Event_Array_truncate(&profiler->calls, 0);
+}
+
+void IO_Event_Profiler_Call_initialize(struct IO_Event_Profiler_Call *call) {
+	call->enter_time.tv_sec = 0;
+	call->enter_time.tv_nsec = 0;
+	call->exit_time.tv_sec = 0;
+	call->exit_time.tv_nsec = 0;
+	
+	call->nesting = 0;
+	
+	call->event_flag = 0;
+	call->id = 0;
+	
+	call->path = NULL;
+	call->line = 0;
+}
+
+void IO_Event_Profiler_Call_free(struct IO_Event_Profiler_Call *call) {
+	if (call->path) {
+		free((void*)call->path);
+		call->path = NULL;
+	}
+}
+
+static void IO_Event_Profiler_mark(void *ptr) {
+	struct IO_Event_Profiler *profiler = (struct IO_Event_Profiler*)ptr;
+	
+	// If `klass` is stored as a VALUE in calls, we need to mark them here:
+	for (size_t i = 0; i < profiler->calls.limit; i += 1) {
+		struct IO_Event_Profiler_Call *call = profiler->calls.base[i];
+		rb_gc_mark_movable(call->klass);
+	}
+}
+
+static void IO_Event_Profiler_compact(void *ptr) {
+	struct IO_Event_Profiler *profiler = (struct IO_Event_Profiler*)ptr;
+	
+	// If `klass` is stored as a VALUE in calls, we need to update their locations here:
+	for (size_t i = 0; i < profiler->calls.limit; i += 1) {
+			struct IO_Event_Profiler_Call *call = profiler->calls.base[i];
+			call->klass = rb_gc_location(call->klass);
+	}
+}
+
+static void IO_Event_Profiler_free(void *ptr) {
+	struct IO_Event_Profiler *profiler = (struct IO_Event_Profiler*)ptr;
+	
+	IO_Event_Array_free(&profiler->calls);
+	
+	free(profiler);
+}
+
+static size_t IO_Event_Profiler_memsize(const void *ptr) {
+	const struct IO_Event_Profiler *profiler = (const struct IO_Event_Profiler*)ptr;
+	return sizeof(*profiler) + IO_Event_Array_memory_size(&profiler->calls);
+}
+
+const rb_data_type_t IO_Event_Profiler_Type = {
+	.wrap_struct_name = "IO::Event::Profiler",
+	.function = {
+		.dmark = IO_Event_Profiler_mark,
+		.dcompact = IO_Event_Profiler_compact,
+		.dfree = IO_Event_Profiler_free,
+		.dsize = IO_Event_Profiler_memsize,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+struct IO_Event_Profiler *IO_Event_Profiler_get(VALUE self) {
+	struct IO_Event_Profiler *profiler;
+	TypedData_Get_Struct(self, struct IO_Event_Profiler, &IO_Event_Profiler_Type, profiler);
+	return profiler;
+}
+
+VALUE IO_Event_Profiler_allocate(VALUE klass) {
+	struct IO_Event_Profiler *profiler = ALLOC(struct IO_Event_Profiler);
+	
+	// Initialize the profiler state:
+	profiler->running = 0;
+	profiler->capture = 0;
+	profiler->stalls = 0;
+	profiler->nesting = 0;
+	profiler->current = NULL;
+	
+	profiler->calls.element_initialize = (void (*)(void*))IO_Event_Profiler_Call_initialize;
+	profiler->calls.element_free = (void (*)(void*))IO_Event_Profiler_Call_free;
+	IO_Event_Array_initialize(&profiler->calls, 0, sizeof(struct IO_Event_Profiler_Call));
+	
+	return TypedData_Wrap_Struct(klass, &IO_Event_Profiler_Type, profiler);
+}
+
+int IO_Event_Profiler_p(void) {
+	const char *enabled = getenv("IO_EVENT_PROFILER");
+	
+	if (enabled && strcmp(enabled, "true") == 0) {
+		return 1;
+	}
+	
+	return 0;
+}
+
+float IO_Event_Profiler_default_log_threshold(void) {
+	const char *log_threshold = getenv("IO_EVENT_PROFILER_LOG_THRESHOLD");
+	
+	if (log_threshold) {
+		return strtof(log_threshold, NULL);
+	} else {
+		return 0.01;
+	}
+}
+
+int IO_Event_Profiler_default_track_calls(void) {
+	const char *track_calls = getenv("IO_EVENT_PROFILER_TRACK_CALLS");
+	
+	if (track_calls && strcmp(track_calls, "false") == 0) {
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+VALUE IO_Event_Profiler_initialize(int argc, VALUE *argv, VALUE self) {
+	struct IO_Event_Profiler *profiler = IO_Event_Profiler_get(self);
+	VALUE log_threshold, track_calls;
+	
+	rb_scan_args(argc, argv, "02", &log_threshold, &track_calls);
+	
+	if (RB_NIL_P(log_threshold)) {
+		profiler->log_threshold = IO_Event_Profiler_default_log_threshold();
+	} else {
+		profiler->log_threshold = NUM2DBL(log_threshold);
+	}
+	
+	if (RB_NIL_P(track_calls)) {
+		profiler->track_calls = IO_Event_Profiler_default_track_calls();
+	} else {
+		profiler->track_calls = RB_TEST(track_calls);
+	}
+	
+	return self;
+}
+
+VALUE IO_Event_Profiler_default(VALUE klass) {
+	if (!IO_Event_Profiler_p()) {
+		return Qnil;
+	}
+	
+	VALUE profiler = IO_Event_Profiler_allocate(klass);
+	
+	struct IO_Event_Profiler *profiler_data = IO_Event_Profiler_get(profiler);
+	profiler_data->log_threshold = IO_Event_Profiler_default_log_threshold();
+	profiler_data->track_calls = IO_Event_Profiler_default_track_calls();
+	
+	return profiler;
+}
+
+VALUE IO_Event_Profiler_new(float log_threshold, int track_calls) {
+	VALUE profiler = IO_Event_Profiler_allocate(IO_Event_Profiler);
+	
+	struct IO_Event_Profiler *profiler_data = IO_Event_Profiler_get(profiler);
+	profiler_data->log_threshold = log_threshold;
+	profiler_data->track_calls = track_calls;
+	
+	return profiler;
+}
+
+int event_flag_call_p(rb_event_flag_t event_flags) {
+	return event_flags & (RUBY_EVENT_CALL | RUBY_EVENT_C_CALL | RUBY_EVENT_B_CALL);
+}
+
+int event_flag_return_p(rb_event_flag_t event_flags) {
+	return event_flags & (RUBY_EVENT_RETURN | RUBY_EVENT_C_RETURN | RUBY_EVENT_B_RETURN);
+}
+
+const char *event_flag_name(rb_event_flag_t event_flag) {
+	switch (event_flag) {
+		case RUBY_EVENT_CALL: return "call";
+		case RUBY_EVENT_C_CALL: return "c-call";
+		case RUBY_EVENT_B_CALL: return "b-call";
+		case RUBY_EVENT_RETURN: return "return";
+		case RUBY_EVENT_C_RETURN: return "c-return";
+		case RUBY_EVENT_B_RETURN: return "b-return";
+		default: return "unknown";
+	}
+}
+
+static struct IO_Event_Profiler_Call* profiler_event_record_call(struct IO_Event_Profiler *profiler, rb_event_flag_t event_flag, ID id, VALUE klass) {
+	struct IO_Event_Profiler_Call *call = IO_Event_Array_push(&profiler->calls);
+	
+	call->event_flag = event_flag;
+
+	call->parent = profiler->current;
+	profiler->current = call;
+
+	call->nesting = profiler->nesting;
+	profiler->nesting += 1;
+
+	if (id) {
+		call->id = id;
+		call->klass = klass;
+	} else {
+		rb_frame_method_id_and_class(&call->id, &call->klass);
+	}
+
+	const char *path = rb_sourcefile();
+	if (path) {
+		call->path = strdup(path);
+	}
+	call->line = rb_sourceline();
+	
+	return call;
+}
+
+void IO_Event_Profiler_fiber_switch(struct IO_Event_Profiler *profiler);
+
+static void IO_Event_Profiler_callback(rb_event_flag_t event_flag, VALUE data, VALUE self, ID id, VALUE klass) {
+	struct IO_Event_Profiler *profiler = IO_Event_Profiler_get(data);
+	
+	if (event_flag & RUBY_EVENT_FIBER_SWITCH) {
+		IO_Event_Profiler_fiber_switch(profiler);
+		return;
+	}
+	
+	// We don't want to capture data if we're not running:
+	if (!profiler->capture) return;
+	
+	if (event_flag_call_p(event_flag)) {
+		struct IO_Event_Profiler_Call *call = profiler_event_record_call(profiler, event_flag, id, klass);
+		IO_Event_Time_current(&call->enter_time);
+	}
+	
+	else if (event_flag_return_p(event_flag)) {
+		struct IO_Event_Profiler_Call *call = profiler->current;
+		
+		// We may encounter returns without a preceeding call. This isn't an error, but we should pretend like the call started at the beginning of the profiling session:
+		if (call == NULL) {
+			struct IO_Event_Profiler_Call *last_call = IO_Event_Array_last(&profiler->calls);
+			call = profiler_event_record_call(profiler, event_flag, id, klass);
+			
+			if (last_call) {
+				call->enter_time = last_call->enter_time;
+			} else {
+				call->enter_time = profiler->start_time;
+			}
+		}
+		
+		IO_Event_Time_current(&call->exit_time);
+		
+		profiler->current = call->parent;
+		
+		// We may encounter returns without a preceeding call.
+		if (profiler->nesting > 0)
+			profiler->nesting -= 1;
+	}
+}
+
+VALUE IO_Event_Profiler_start(VALUE self) {
+	struct IO_Event_Profiler *profiler = IO_Event_Profiler_get(self);
+	
+	if (profiler->running) return Qfalse;
+	
+	profiler->running = 1;
+	
+	IO_Event_Profiler_reset(profiler);
+	IO_Event_Time_current(&profiler->start_time);
+	
+	rb_event_flag_t event_flags = RUBY_EVENT_FIBER_SWITCH;
+	
+	if (profiler->track_calls) {
+		event_flags |= RUBY_EVENT_CALL | RUBY_EVENT_RETURN;
+		event_flags |= RUBY_EVENT_C_CALL | RUBY_EVENT_C_RETURN;
+		// event_flags |= RUBY_EVENT_B_CALL | RUBY_EVENT_B_RETURN;
+	}
+	
+	VALUE thread = rb_thread_current();
+	rb_thread_add_event_hook(thread, IO_Event_Profiler_callback, event_flags, self);
+	
+	return self;
+}
+
+VALUE IO_Event_Profiler_stop(VALUE self) {
+	struct IO_Event_Profiler *profiler = IO_Event_Profiler_get(self);
+	
+	if (!profiler->running) return Qfalse;
+	
+	profiler->running = 0;
+	
+	VALUE thread = rb_thread_current();
+	rb_thread_remove_event_hook_with_data(thread, IO_Event_Profiler_callback, self);
+	
+	IO_Event_Time_current(&profiler->stop_time);
+	IO_Event_Profiler_reset(profiler);
+	
+	return self;
+}
+
+static inline float IO_Event_Profiler_duration(struct IO_Event_Profiler *profiler) {
+	struct timespec duration;
+	
+	IO_Event_Time_current(&profiler->stop_time);
+	IO_Event_Time_elapsed(&profiler->start_time, &profiler->stop_time, &duration);
+	
+	return IO_Event_Time_duration(&duration);
+}
+
+void IO_Event_Profiler_print(struct IO_Event_Profiler *profiler, FILE *restrict stream);
+
+void IO_Event_Profiler_finish(struct IO_Event_Profiler *profiler) {
+	profiler->capture = 0;
+	
+	struct IO_Event_Profiler_Call *current = profiler->current;
+	while (current) {
+		IO_Event_Time_current(&current->exit_time);
+		
+		current = current->parent;
+	}
+}
+
+void IO_Event_Profiler_fiber_switch(struct IO_Event_Profiler *profiler)
+{
+	float duration = IO_Event_Profiler_duration(profiler);
+	
+	if (profiler->capture) {
+		IO_Event_Profiler_finish(profiler);
+		
+		if (duration > profiler->log_threshold) {
+			profiler->stalls += 1;
+			IO_Event_Profiler_print(profiler, stderr);
+		}
+	}
+	
+	IO_Event_Profiler_reset(profiler);
+	
+	if (!IO_Event_Fiber_blocking(IO_Event_Fiber_current())) {
+		// Reset the start time:
+		IO_Event_Time_current(&profiler->start_time);
+		
+		profiler->capture = 1;
+	}
+}
+
+static const float IO_EVENT_PROFILER_PRINT_MINIMUM_PROPORTION = 0.01;
+
+void IO_Event_Profiler_print_tty(struct IO_Event_Profiler *profiler, FILE *restrict stream) {
+	struct timespec total_duration = {};
+	IO_Event_Time_elapsed(&profiler->start_time, &profiler->stop_time, &total_duration);
+	
+	fprintf(stderr, "Fiber stalled for %.3f seconds\n", IO_Event_Time_duration(&total_duration));
+	
+	size_t skipped = 0;
+	
+	for (size_t i = 0; i < profiler->calls.limit; i += 1) {
+		struct IO_Event_Profiler_Call *call = profiler->calls.base[i];
+		struct timespec duration = {};
+		IO_Event_Time_elapsed(&call->enter_time, &call->exit_time, &duration);
+		
+		// Skip calls that are too short to be meaningful:
+		if (IO_Event_Time_proportion(&duration, &total_duration) < IO_EVENT_PROFILER_PRINT_MINIMUM_PROPORTION) {
+			skipped += 1;
+			continue;
+		}
+		
+		for (size_t i = 0; i < call->nesting; i += 1) {
+			fputc('\t', stream);
+		}
+		
+		VALUE class_inspect = rb_inspect(call->klass);
+		const char *name = rb_id2name(call->id);
+		
+		fprintf(stream, "%s:%d in %s '%s#%s' (" IO_EVENT_TIME_PRINTF_TIMESPEC "s)\n", call->path, call->line, event_flag_name(call->event_flag), RSTRING_PTR(class_inspect), name, IO_EVENT_TIME_PRINTF_TIMESPEC_ARGUMENTS(duration));
+	}
+	
+	if (skipped > 0) {
+		fprintf(stream, "Skipped %zu calls that were too short to be meaningful.\n", skipped);
+	}
+}
+
+void IO_Event_Profiler_print_json(struct IO_Event_Profiler *profiler, FILE *restrict stream) {
+	struct timespec total_duration = {};
+	IO_Event_Time_elapsed(&profiler->start_time, &profiler->stop_time, &total_duration);
+	
+	fputc('{', stream);
+	
+	fprintf(stream, "\"duration\":" IO_EVENT_TIME_PRINTF_TIMESPEC, IO_EVENT_TIME_PRINTF_TIMESPEC_ARGUMENTS(total_duration));
+	
+	size_t skipped = 0;
+	
+	fprintf(stream, ",\"calls\":[");
+	int first = 1;
+	
+	for (size_t i = 0; i < profiler->calls.limit; i += 1) {
+		struct IO_Event_Profiler_Call *call = profiler->calls.base[i];
+		struct timespec duration = {};
+		IO_Event_Time_elapsed(&call->enter_time, &call->exit_time, &duration);
+		
+		// Skip calls that are too short to be meaningful:
+		if (IO_Event_Time_proportion(&duration, &total_duration) < IO_EVENT_PROFILER_PRINT_MINIMUM_PROPORTION) {
+			skipped += 1;
+			continue;
+		}
+		
+		VALUE class_inspect = rb_inspect(call->klass);
+		const char *name = rb_id2name(call->id);
+		
+		fprintf(stream, "%s{\"path\":\"%s\",\"line\":%d,\"class\":\"%s\",\"method\":\"%s\",\"duration\":" IO_EVENT_TIME_PRINTF_TIMESPEC ",\"nesting\":%zu}", first ? "" : ",", call->path, call->line, RSTRING_PTR(class_inspect), name, IO_EVENT_TIME_PRINTF_TIMESPEC_ARGUMENTS(duration), call->nesting);
+		
+		first = 0;
+	}
+	
+	fprintf(stream, "]");
+	
+	if (skipped > 0) {
+		fprintf(stream, ",\"skipped\":%zu", skipped);
+	}
+	
+	fprintf(stream, "}\n");
+}
+
+void IO_Event_Profiler_print(struct IO_Event_Profiler *profiler, FILE *restrict stream) {
+	if (isatty(fileno(stream))) {
+		IO_Event_Profiler_print_tty(profiler, stream);
+	} else {
+		IO_Event_Profiler_print_json(profiler, stream);
+	}
+}
+
+VALUE IO_Event_Profiler_stalls(VALUE self) {
+	struct IO_Event_Profiler *profiler = IO_Event_Profiler_get(self);
+	
+	return SIZET2NUM(profiler->stalls);
+}
+
+void Init_IO_Event_Profiler(VALUE IO_Event) {
+	IO_Event_Profiler = rb_define_class_under(IO_Event, "Profiler", rb_cObject);
+	rb_define_alloc_func(IO_Event_Profiler, IO_Event_Profiler_allocate);
+	
+	rb_define_singleton_method(IO_Event_Profiler, "default", IO_Event_Profiler_default, 0);
+	
+	rb_define_method(IO_Event_Profiler, "initialize", IO_Event_Profiler_initialize, -1);
+	
+	rb_define_method(IO_Event_Profiler, "start", IO_Event_Profiler_start, 0);
+	rb_define_method(IO_Event_Profiler, "stop", IO_Event_Profiler_stop, 0);
+	
+	rb_define_method(IO_Event_Profiler, "stalls", IO_Event_Profiler_stalls, 0);
+}

data/ext/io/event/profiler.h

@@ -0,0 +1,8 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#pragma once
+
+#include <ruby.h>
+
+void Init_IO_Event_Profiler(VALUE IO_Event);