fiber-profiler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 242de388a621c02117a98ee14496714ce82c3ad8d8770a891789536fe4dc8fad
+  data.tar.gz: a911793eb422ac5e0092789263c58564e71831d769bf907d4db489777fbebdf6
+SHA512:
+  metadata.gz: e3b5be8bb62d92f11ae5262a526a351092920d2a64761b5a5ce2b38a2bae05edc4eed57283d0031f7e44c28e94427688ab602fca2e303fe0ec6c38f0a7ef68e1
+  data.tar.gz: e959a0bf539b76cea581a42842e8c08541d9b75b51c6cebbb85f18eb5ad7b15ce5d361f13a1c7466ff0053511c736c556ae22468263148279a10a10148193e1b

data/ext/extconf.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "mkmf"
+
+gem_name = File.basename(__dir__)
+extension_name = "Fiber_Profiler"
+
+$CFLAGS << " -Wall -Wno-unknown-pragmas -std=c99"
+
+if ENV.key?("RUBY_DEBUG")
+	$stderr.puts "Enabling debug mode..."
+	
+	$CFLAGS << " -DRUBY_DEBUG -O0"
+end
+
+$srcs = ["fiber/profiler/profiler.c", "fiber/profiler/time.c", "fiber/profiler/fiber.c", "fiber/profiler/capture.c"]
+$VPATH << "$(srcdir)/fiber/profiler"
+
+have_func("rb_fiber_current")
+have_func("rb_ext_ractor_safe")
+
+if ENV.key?("RUBY_SANITIZE")
+	$stderr.puts "Enabling sanitizers..."
+	
+	# Add address and undefined behaviour sanitizers:
+	$CFLAGS << " -fsanitize=address -fsanitize=undefined -fno-omit-frame-pointer"
+	$LDFLAGS << " -fsanitize=address -fsanitize=undefined"
+end
+
+create_header
+
+# Generate the makefile to compile the native binary into `lib`:
+create_makefile(extension_name)

data/ext/fiber/profiler/capture.c

@@ -0,0 +1,670 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "profiler.h"
+
+#include "time.h"
+#include "fiber.h"
+#include "deque.h"
+
+#include <stdio.h>
+#include <ruby/io.h>
+#include <ruby/debug.h>
+#include <stdio.h>
+
+enum {
+	DEBUG_SKIPPED = 1,
+};
+
+int Fiber_Profiler_capture_p = 0;
+double Fiber_Profiler_Capture_stall_threshold = 0.01;
+int Fiber_Profiler_Capture_track_calls = 1;
+double Fiber_Profiler_Capture_sample_rate = 1;
+
+VALUE Fiber_Profiler_Capture = Qnil;
+
+struct Fiber_Profiler_Capture_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 Fiber_Profiler_Capture_Call *parent;
+};
+
+struct Fiber_Profiler_Stream {
+	FILE *file;
+	char *buffer;
+	size_t size;
+};
+
+void Fiber_Profiler_Stream_initialize(struct Fiber_Profiler_Stream *stream) {
+	stream->file = open_memstream(&stream->buffer, &stream->size);
+}
+
+void Fiber_Profiler_Stream_free(struct Fiber_Profiler_Stream *stream) {
+	if (stream->file) {
+		fclose(stream->file);
+		stream->file = NULL;
+	}
+	
+	if (stream->buffer) {
+		free(stream->buffer);
+		stream->buffer = NULL;
+	}
+}
+
+struct Fiber_Profiler_Capture;
+typedef void(*Fiber_Profiler_Stream_Print)(struct Fiber_Profiler_Capture*, FILE* restrict);
+
+struct Fiber_Profiler_Capture {
+	// Configuration:
+	double stall_threshold;
+	int track_calls;
+	double sample_rate;
+	
+	// Calls that are shorter than this filter threshold will be ignored:
+	double filter_threshold;
+	
+	VALUE output;
+	Fiber_Profiler_Stream_Print print;
+	struct Fiber_Profiler_Stream stream;
+	
+	// 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 Fiber_Profiler_Capture_Call *current;
+	
+	struct Fiber_Profiler_Deque calls;
+};
+
+void Fiber_Profiler_Capture_reset(struct Fiber_Profiler_Capture *profiler) {
+	profiler->nesting = 0;
+	profiler->current = NULL;
+	Fiber_Profiler_Deque_truncate(&profiler->calls);
+}
+
+void Fiber_Profiler_Capture_Call_initialize(void *element) {
+	struct Fiber_Profiler_Capture_Call *call = element;
+	
+	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 Fiber_Profiler_Capture_Call_free(void *element) {
+	struct Fiber_Profiler_Capture_Call *call = element;
+	
+	if (call->path) {
+		free((void*)call->path);
+		call->path = NULL;
+	}
+}
+
+static void Fiber_Profiler_Capture_mark(void *ptr) {
+	struct Fiber_Profiler_Capture *profiler = (struct Fiber_Profiler_Capture*)ptr;
+	
+	rb_gc_mark_movable(profiler->output);
+	
+	// If `klass` is stored as a VALUE in calls, we need to mark them here:
+	Fiber_Profiler_Deque_each(&profiler->calls, struct Fiber_Profiler_Capture_Call, call) {
+		rb_gc_mark_movable(call->klass);
+	}
+}
+
+static void Fiber_Profiler_Capture_compact(void *ptr) {
+	struct Fiber_Profiler_Capture *profiler = (struct Fiber_Profiler_Capture*)ptr;
+	
+	profiler->output = rb_gc_location(profiler->output);
+	
+	// If `klass` is stored as a VALUE in calls, we need to update their locations here:
+	Fiber_Profiler_Deque_each(&profiler->calls, struct Fiber_Profiler_Capture_Call, call) {
+		call->klass = rb_gc_location(call->klass);
+	}
+}
+
+static void Fiber_Profiler_Capture_free(void *ptr) {
+	struct Fiber_Profiler_Capture *profiler = (struct Fiber_Profiler_Capture*)ptr;
+	
+	RUBY_ASSERT(profiler->running == 0);
+	
+	Fiber_Profiler_Stream_free(&profiler->stream);
+	Fiber_Profiler_Deque_free(&profiler->calls);
+	
+	free(profiler);
+}
+
+static size_t Fiber_Profiler_Capture_memsize(const void *ptr) {
+	const struct Fiber_Profiler_Capture *profiler = (const struct Fiber_Profiler_Capture*)ptr;
+	return sizeof(*profiler) + Fiber_Profiler_Deque_memory_size(&profiler->calls);
+}
+
+const rb_data_type_t Fiber_Profiler_Capture_Type = {
+	.wrap_struct_name = "IO::Event::Profiler",
+	.function = {
+		.dmark = Fiber_Profiler_Capture_mark,
+		.dcompact = Fiber_Profiler_Capture_compact,
+		.dfree = Fiber_Profiler_Capture_free,
+		.dsize = Fiber_Profiler_Capture_memsize,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+struct Fiber_Profiler_Capture *Fiber_Profiler_Capture_get(VALUE self) {
+	struct Fiber_Profiler_Capture *profiler;
+	TypedData_Get_Struct(self, struct Fiber_Profiler_Capture, &Fiber_Profiler_Capture_Type, profiler);
+	return profiler;
+}
+
+int IO_istty(VALUE io) {
+	if (RB_TYPE_P(io, T_FILE)) {
+		int descriptor = rb_io_descriptor(io);
+		return isatty(descriptor);
+	}
+	
+	return 0;
+}
+
+void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *profiler, FILE *restrict stream);
+void Fiber_Profiler_Capture_print_json(struct Fiber_Profiler_Capture *profiler, FILE *restrict stream);
+
+static void Fiber_Profiler_Capture_output_set(struct Fiber_Profiler_Capture *profiler, VALUE output) {
+	profiler->output = output;
+	
+	if (IO_istty(profiler->output)) {
+		profiler->print = &Fiber_Profiler_Capture_print_tty;
+	} else {
+		profiler->print = &Fiber_Profiler_Capture_print_json;
+	}
+}
+
+VALUE Fiber_Profiler_Capture_allocate(VALUE klass) {
+	struct Fiber_Profiler_Capture *profiler = ALLOC(struct Fiber_Profiler_Capture);
+	
+	// Initialize the profiler state:
+	Fiber_Profiler_Capture_output_set(profiler, rb_stderr);	
+	Fiber_Profiler_Stream_initialize(&profiler->stream);
+	
+	profiler->running = 0;
+	profiler->capture = 0;
+	profiler->stalls = 0;
+	profiler->nesting = 0;
+	profiler->current = NULL;
+	
+	profiler->stall_threshold = Fiber_Profiler_Capture_stall_threshold;
+	profiler->track_calls = Fiber_Profiler_Capture_track_calls;
+	profiler->sample_rate = Fiber_Profiler_Capture_sample_rate;
+	
+	// Filter calls that are less than 1% of the stall threshold:
+	profiler->filter_threshold = profiler->stall_threshold * 0.01;
+	
+	profiler->calls.element_initialize = (void (*)(void*))Fiber_Profiler_Capture_Call_initialize;
+	profiler->calls.element_free = (void (*)(void*))Fiber_Profiler_Capture_Call_free;
+	Fiber_Profiler_Deque_initialize(&profiler->calls, sizeof(struct Fiber_Profiler_Capture_Call));
+	
+	return TypedData_Wrap_Struct(klass, &Fiber_Profiler_Capture_Type, profiler);
+}
+
+ID Fiber_Profiler_Capture_initialize_options[4];
+
+VALUE Fiber_Profiler_Capture_initialize(int argc, VALUE *argv, VALUE self) {
+	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	
+	VALUE arguments[4] = {0};
+	VALUE options = Qnil;
+	rb_scan_args(argc, argv, ":", &options);
+	rb_get_kwargs(options, Fiber_Profiler_Capture_initialize_options, 0, 4, arguments);
+	
+	if (arguments[0] != Qundef) {
+		profiler->stall_threshold = NUM2DBL(arguments[0]);
+	}
+	
+	if (arguments[1] != Qundef) {
+		profiler->track_calls = RB_TEST(arguments[1]);
+	}
+	
+	if (arguments[2] != Qundef) {
+		profiler->sample_rate = NUM2DBL(arguments[2]);
+	}
+	
+	if (arguments[3] != Qundef) {
+		Fiber_Profiler_Capture_output_set(profiler, arguments[3]);
+	}
+	
+	return self;
+}
+
+VALUE Fiber_Profiler_Capture_default(VALUE klass) {
+	if (!Fiber_Profiler_capture_p) {
+		return Qnil;
+	}
+	
+	VALUE profiler = Fiber_Profiler_Capture_allocate(klass);
+	Fiber_Profiler_Capture_initialize(0, NULL, profiler);
+	
+	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 | RUBY_INTERNAL_EVENT_GC_START);
+}
+
+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 | RUBY_INTERNAL_EVENT_GC_END_SWEEP);
+}
+
+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";
+		case RUBY_INTERNAL_EVENT_GC_START: return "gc-start";
+		case RUBY_INTERNAL_EVENT_GC_END_MARK: return "gc-end-mark";
+		case RUBY_INTERNAL_EVENT_GC_END_SWEEP: return "gc-end-sweep";
+		default: return "unknown";
+	}
+}
+
+static struct Fiber_Profiler_Capture_Call* profiler_event_record_call(struct Fiber_Profiler_Capture *profiler, rb_event_flag_t event_flag, ID id, VALUE klass) {
+	struct Fiber_Profiler_Capture_Call *call = Fiber_Profiler_Deque_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 Fiber_Profiler_Capture_fiber_switch(struct Fiber_Profiler_Capture *profiler);
+
+static void Fiber_Profiler_Capture_callback(rb_event_flag_t event_flag, VALUE data, VALUE self, ID id, VALUE klass) {
+	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(data);
+	
+	if (event_flag & RUBY_EVENT_FIBER_SWITCH) {
+		Fiber_Profiler_Capture_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 Fiber_Profiler_Capture_Call *call = profiler_event_record_call(profiler, event_flag, id, klass);
+		Fiber_Profiler_Time_current(&call->enter_time);
+	}
+	
+	else if (event_flag_return_p(event_flag)) {
+		struct Fiber_Profiler_Capture_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 Fiber_Profiler_Capture_Call *last_call = Fiber_Profiler_Deque_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;
+			}
+		}
+		
+		Fiber_Profiler_Time_current(&call->exit_time);
+		
+		profiler->current = call->parent;
+		
+		// We may encounter returns without a preceeding call.
+		if (profiler->nesting > 0)
+			profiler->nesting -= 1;
+		
+		// If the call was < 1% of the stall threshold, we can ignore it:
+		double duration = Fiber_Profiler_Time_delta(&call->enter_time, &call->exit_time);
+		if (duration < profiler->filter_threshold) {
+			Fiber_Profiler_Deque_pop(&profiler->calls);
+		}
+	}
+}
+
+VALUE Fiber_Profiler_Capture_start(VALUE self) {
+	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	
+	if (profiler->running) return Qfalse;
+	
+	profiler->running = 1;
+	
+	Fiber_Profiler_Capture_reset(profiler);
+	Fiber_Profiler_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, Fiber_Profiler_Capture_callback, event_flags, self);
+	
+	// if (profiler->track_garbage_collection) {
+		rb_thread_add_event_hook(thread, Fiber_Profiler_Capture_callback, RUBY_INTERNAL_EVENT_GC_START | RUBY_INTERNAL_EVENT_GC_END_SWEEP, self);
+	// }
+	
+	return self;
+}
+
+VALUE Fiber_Profiler_Capture_stop(VALUE self) {
+	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	
+	if (!profiler->running) return Qfalse;
+	
+	profiler->running = 0;
+	
+	VALUE thread = rb_thread_current();
+	rb_thread_remove_event_hook_with_data(thread, Fiber_Profiler_Capture_callback, self);
+	
+	Fiber_Profiler_Time_current(&profiler->stop_time);
+	Fiber_Profiler_Capture_reset(profiler);
+	
+	return self;
+}
+
+static inline float Fiber_Profiler_Capture_duration(struct Fiber_Profiler_Capture *profiler) {
+	struct timespec duration;
+	
+	Fiber_Profiler_Time_current(&profiler->stop_time);
+	Fiber_Profiler_Time_elapsed(&profiler->start_time, &profiler->stop_time, &duration);
+	
+	return Fiber_Profiler_Time_duration(&duration);
+}
+
+void Fiber_Profiler_Capture_finish(struct Fiber_Profiler_Capture *profiler) {
+	profiler->capture = 0;
+	
+	struct Fiber_Profiler_Capture_Call *current = profiler->current;
+	while (current) {
+		Fiber_Profiler_Time_current(&current->exit_time);
+		
+		current = current->parent;
+	}
+}
+
+void Fiber_Profiler_Capture_print(struct Fiber_Profiler_Capture *profiler);
+
+int Fiber_Profiler_Capture_sample(struct Fiber_Profiler_Capture *profiler) {
+	VALUE fiber = Fiber_Profiler_Fiber_current();
+	
+	// We don't want to capture data from blocking fibers:
+	if (Fiber_Profiler_Fiber_blocking(fiber)) return 0;
+	
+	if (profiler->sample_rate < 1) {
+		return rand() < (RAND_MAX * profiler->sample_rate);
+	} else {
+		return 1;
+	}
+}
+
+void Fiber_Profiler_Capture_fiber_switch(struct Fiber_Profiler_Capture *profiler)
+{
+	float duration = Fiber_Profiler_Capture_duration(profiler);
+	
+	if (profiler->capture) {
+		Fiber_Profiler_Capture_finish(profiler);
+		
+		if (duration > profiler->stall_threshold) {
+			profiler->stalls += 1;
+			Fiber_Profiler_Capture_print(profiler);
+		}
+	}
+	
+	Fiber_Profiler_Capture_reset(profiler);
+	
+	if (Fiber_Profiler_Capture_sample(profiler)) {
+		// Reset the start time:
+		Fiber_Profiler_Time_current(&profiler->start_time);
+		
+		profiler->capture = 1;
+	}
+}
+
+static const float Fiber_Profiler_Capture_PRINT_MINIMUM_PROPORTION = 0.01;
+
+void Fiber_Profiler_Capture_print_tty(struct Fiber_Profiler_Capture *profiler, FILE *restrict stream) {
+	struct timespec total_duration = {};
+	Fiber_Profiler_Time_elapsed(&profiler->start_time, &profiler->stop_time, &total_duration);
+	
+	fprintf(stderr, "Fiber stalled for %.3f seconds\n", Fiber_Profiler_Time_duration(&total_duration));
+	
+	size_t skipped = 0;
+	
+	Fiber_Profiler_Deque_each(&profiler->calls, struct Fiber_Profiler_Capture_Call, call) {
+		struct timespec duration = {};
+		Fiber_Profiler_Time_elapsed(&call->enter_time, &call->exit_time, &duration);
+		
+		// Skip calls that are too short to be meaningful:
+		if (Fiber_Profiler_Time_proportion(&duration, &total_duration) < Fiber_Profiler_Capture_PRINT_MINIMUM_PROPORTION) {
+			
+			if (!DEBUG_SKIPPED) {
+				skipped += 1;
+				continue;
+			} else {
+				fprintf(stream, "\e[2m");
+			}
+		}
+		
+		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' (" Fiber_Profiler_TIME_PRINTF_TIMESPEC "s)\n", call->path, call->line, event_flag_name(call->event_flag), RSTRING_PTR(class_inspect), name, Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(duration));
+		
+		if (DEBUG_SKIPPED) {
+			fprintf(stream, "\e[0m");
+		}
+	}
+	
+	if (skipped > 0) {
+		fprintf(stream, "Skipped %zu calls that were too short to be meaningful.\n", skipped);
+	}
+}
+
+void Fiber_Profiler_Capture_print_json(struct Fiber_Profiler_Capture *profiler, FILE *restrict stream) {
+	struct timespec total_duration = {};
+	Fiber_Profiler_Time_elapsed(&profiler->start_time, &profiler->stop_time, &total_duration);
+	
+	fputc('{', stream);
+	
+	fprintf(stream, "\"duration\":" Fiber_Profiler_TIME_PRINTF_TIMESPEC, Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(total_duration));
+	
+	size_t skipped = 0;
+	
+	fprintf(stream, ",\"calls\":[");
+	int first = 1;
+	
+	Fiber_Profiler_Deque_each(&profiler->calls, struct Fiber_Profiler_Capture_Call, call) {
+		struct timespec duration = {};
+		Fiber_Profiler_Time_elapsed(&call->enter_time, &call->exit_time, &duration);
+		
+		// Skip calls that are too short to be meaningful:
+		if (Fiber_Profiler_Time_proportion(&duration, &total_duration) < Fiber_Profiler_Capture_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\":" Fiber_Profiler_TIME_PRINTF_TIMESPEC ",\"nesting\":%zu}", first ? "" : ",", call->path, call->line, RSTRING_PTR(class_inspect), name, Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(duration), call->nesting);
+		
+		first = 0;
+	}
+	
+	fprintf(stream, "]");
+	
+	if (skipped > 0) {
+		fprintf(stream, ",\"skipped\":%zu", skipped);
+	}
+	
+	fprintf(stream, "}\n");
+}
+
+void Fiber_Profiler_Capture_print(struct Fiber_Profiler_Capture *profiler) {
+	FILE *stream = profiler->stream.file;
+	profiler->print(profiler, stream);
+	fflush(stream);
+	
+	rb_io_write(profiler->output, rb_str_new_static(profiler->stream.buffer, profiler->stream.size));
+	
+	fseek(stream, 0, SEEK_SET);
+}
+
+#pragma mark - Accessors
+
+static VALUE Fiber_Profiler_Capture_stall_threshold_get(VALUE self) {
+	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	
+	return DBL2NUM(profiler->stall_threshold);
+}
+
+static VALUE Fiber_Profiler_Capture_track_calls_get(VALUE self) {
+	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	
+	return profiler->track_calls ? Qtrue : Qfalse;
+}
+
+static VALUE Fiber_Profiler_Capture_stalls_get(VALUE self) {
+	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	
+	return SIZET2NUM(profiler->stalls);
+}
+
+static VALUE Fiber_Profiler_Capture_sample_rate_get(VALUE self) {
+	struct Fiber_Profiler_Capture *profiler = Fiber_Profiler_Capture_get(self);
+	
+	return DBL2NUM(profiler->sample_rate);
+}
+
+#pragma mark - Environment Variables
+
+static int FIBER_PROFILER_CAPTURE(void) {
+	const char *value = getenv("FIBER_PROFILER_CAPTURE");
+	
+	if (value && strcmp(value, "true") == 0) {
+		return 1;
+	} else {
+		return 0;
+	}
+}
+
+static double FIBER_PROFILER_CAPTURE_STALL_THRESHOLD(void) {
+	const char *value = getenv("FIBER_PROFILER_CAPTURE_STALL_THRESHOLD");
+	
+	if (value) {
+		return atof(value);
+	} else {
+		return 0.01;
+	}
+}
+
+static int FIBER_PROFILER_CAPTURE_TRACK_CALLS(void) {
+	const char *value = getenv("FIBER_PROFILER_CAPTURE_TRACK_CALLS");
+	
+	if (value && strcmp(value, "false") == 0) {
+		return 0;
+	} else {
+		return 1;
+	}
+}
+
+static double FIBER_PROFILER_CAPTURE_SAMPLE_RATE(void) {
+	const char *value = getenv("FIBER_PROFILER_CAPTURE_SAMPLE_RATE");
+	
+	if (value) {
+		return atof(value);
+	} else {
+		return 1;
+	}
+}
+
+#pragma mark - Initialization
+
+void Init_Fiber_Profiler_Capture(VALUE Fiber_Profiler) {
+	Fiber_Profiler_capture_p = FIBER_PROFILER_CAPTURE();
+	Fiber_Profiler_Capture_stall_threshold = FIBER_PROFILER_CAPTURE_STALL_THRESHOLD();
+	Fiber_Profiler_Capture_track_calls = FIBER_PROFILER_CAPTURE_TRACK_CALLS();
+	Fiber_Profiler_Capture_sample_rate = FIBER_PROFILER_CAPTURE_SAMPLE_RATE();
+	
+	Fiber_Profiler_Capture_initialize_options[0] = rb_intern("stall_threshold");
+	Fiber_Profiler_Capture_initialize_options[1] = rb_intern("track_calls");
+	Fiber_Profiler_Capture_initialize_options[2] = rb_intern("sample_rate");
+	Fiber_Profiler_Capture_initialize_options[3] = rb_intern("output");
+	
+	Fiber_Profiler_Capture = rb_define_class_under(Fiber_Profiler, "Capture", rb_cObject);
+	rb_define_alloc_func(Fiber_Profiler_Capture, Fiber_Profiler_Capture_allocate);
+	
+	rb_define_singleton_method(Fiber_Profiler_Capture, "default", Fiber_Profiler_Capture_default, 0);
+	
+	rb_define_method(Fiber_Profiler_Capture, "initialize", Fiber_Profiler_Capture_initialize, -1);
+	
+	rb_define_method(Fiber_Profiler_Capture, "start", Fiber_Profiler_Capture_start, 0);
+	rb_define_method(Fiber_Profiler_Capture, "stop", Fiber_Profiler_Capture_stop, 0);
+	
+	rb_define_method(Fiber_Profiler_Capture, "stall_threshold", Fiber_Profiler_Capture_stall_threshold_get, 0);
+	rb_define_method(Fiber_Profiler_Capture, "track_calls", Fiber_Profiler_Capture_track_calls_get, 0);
+	rb_define_method(Fiber_Profiler_Capture, "sample_rate", Fiber_Profiler_Capture_sample_rate_get, 0);
+	
+	rb_define_method(Fiber_Profiler_Capture, "stalls", Fiber_Profiler_Capture_stalls_get, 0);
+	
+	rb_define_singleton_method(Fiber_Profiler_Capture, "default", Fiber_Profiler_Capture_default, 0);
+}

data/ext/fiber/profiler/capture.h

@@ -0,0 +1,12 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#pragma once
+
+#include <ruby.h>
+
+extern int Fiber_Profiler_capture;
+extern float Fiber_Profiler_Capture_stall_threshold;
+extern int Fiber_Profiler_Capture_track_calls;
+
+void Init_Fiber_Profiler_Capture(VALUE Fiber_Profiler);

data/ext/fiber/profiler/deque.h

@@ -0,0 +1,272 @@
+// Released under the MIT License.
+// Copyright, 2023, by Samuel Williams.
+
+// Provides a simple implementation of unique pointers to elements of the given size.
+
+#include <ruby.h>
+#include <stdlib.h>
+#include <assert.h>
+
+enum {
+#ifdef RUBY_DEBUG
+	Fiber_Profiler_Deque_DEBUG = 1,
+#else
+	Fiber_Profiler_Deque_DEBUG = 0,
+#endif
+};
+
+// A page of elements:
+struct Fiber_Profiler_Deque_Page {
+	struct Fiber_Profiler_Deque_Page *head, *tail;
+	
+	size_t size;
+	size_t capacity;
+	
+	char elements[];
+};
+
+struct Fiber_Profiler_Deque_Page *Fiber_Profiler_Deque_Page_allocate(size_t element_size, size_t capacity)
+{
+	struct Fiber_Profiler_Deque_Page *page = (struct Fiber_Profiler_Deque_Page *)malloc(sizeof(struct Fiber_Profiler_Deque_Page) + element_size * capacity);
+	
+	if (page) {
+		page->head = page->tail = NULL;
+		
+		page->size = 0;
+		page->capacity = capacity;
+		
+		memset(page->elements, 0, element_size * capacity);
+	}
+	
+	return page;
+}
+
+inline static void *Fiber_Profiler_Deque_Page_get(struct Fiber_Profiler_Deque_Page *page, size_t index, size_t element_size)
+{
+#ifdef RUBY_DEBUG
+	if (index >= page->size) {
+		fprintf(stderr, "Fiber_Profiler_Deque_Page_get: index=%lu, size=%lu\n", index, page->size);
+	}
+#endif
+	
+	RUBY_ASSERT(index < page->size);
+	
+	return (void*)((char *)page->elements + (index * element_size));
+}
+
+inline static struct Fiber_Profiler_Deque_Page *Fiber_Profiler_Deque_Page_free(struct Fiber_Profiler_Deque_Page *page, size_t element_size, void (*element_free)(void*))
+{
+	struct Fiber_Profiler_Deque_Page *tail = page->tail;
+	
+	if (element_free) {
+		for (size_t i = 0; i < page->size; i += 1) {
+			void *element = Fiber_Profiler_Deque_Page_get(page, i, element_size);
+			element_free(element);
+		}
+	}
+	
+	free(page);
+	
+	return tail;
+}
+
+inline static void Fiber_Profiler_Deque_Page_truncate(struct Fiber_Profiler_Deque_Page *page, size_t size, size_t element_size, void (*element_free)(void*))
+{
+	if (size < page->size) {
+		if (element_free) {
+			for (size_t i = size; i < page->size; i += 1) {
+				void *element = Fiber_Profiler_Deque_Page_get(page, i, element_size);
+				element_free(element);
+			}
+		}
+		
+		page->size = size;
+	}
+}
+
+struct Fiber_Profiler_Deque {
+	// The deque of elements:
+	struct Fiber_Profiler_Deque_Page *head, *tail;
+	
+	// The current capacity:
+	size_t capacity;
+	
+	// The size of each element that is allocated:
+	size_t element_size;
+	
+	void (*element_initialize)(void*);
+	void (*element_free)(void*);
+};
+
+inline static int Fiber_Profiler_Deque_initialize(struct Fiber_Profiler_Deque *deque, size_t element_size)
+{
+	deque->head = deque->tail = NULL;
+	
+	deque->capacity = 0;
+	
+	deque->element_size = element_size;
+	
+	return 0;
+}
+
+inline static size_t Fiber_Profiler_Deque_memory_size(const struct Fiber_Profiler_Deque *deque)
+{
+	struct Fiber_Profiler_Deque_Page *page = deque->head;
+	
+	size_t size = 0;
+	while (page) {
+		size += sizeof(struct Fiber_Profiler_Deque_Page);
+		size += page->capacity * deque->element_size;
+		page = page->tail;
+	}
+	
+	return size;
+}
+
+inline static void Fiber_Profiler_Deque_free(struct Fiber_Profiler_Deque *deque)
+{
+	struct Fiber_Profiler_Deque_Page *page = deque->head;
+	
+	deque->head = deque->tail = NULL;
+	
+	while (page) {
+		page = Fiber_Profiler_Deque_Page_free(page, deque->element_size, deque->element_free);
+	}
+}
+
+inline static void Fiber_Profiler_Deque_debug(struct Fiber_Profiler_Deque *deque, const char * operation)
+{
+	struct Fiber_Profiler_Deque_Page *page = deque->head;
+	
+	while (page) {
+		// fprintf(stderr, "Fiber_Profiler_Deque: %s: page=%p, size=%lu, capacity=%lu\n", operation, page, page->size, page->capacity);
+		
+		RUBY_ASSERT(page->size <= page->capacity);
+		
+		RUBY_ASSERT(page->head == NULL || page->head->tail == page);
+		RUBY_ASSERT(page->tail == NULL || page->tail->head == page);
+		
+		page = page->tail;
+	}
+}
+
+void Fiber_Profiler_Deque_truncate(struct Fiber_Profiler_Deque *deque)
+{
+	struct Fiber_Profiler_Deque_Page *page = deque->tail;
+	
+	while (page) {
+		Fiber_Profiler_Deque_Page_truncate(page, 0, deque->element_size, deque->element_free);
+		
+		page = page->head;
+	}
+	
+	deque->tail = deque->head;
+	
+	if (Fiber_Profiler_Deque_DEBUG) Fiber_Profiler_Deque_debug(deque, __FUNCTION__);
+}
+
+inline static size_t Fiber_Profiler_Deque_default_capacity(struct Fiber_Profiler_Deque *deque)
+{
+	static const size_t target_size = 4096*8;
+	
+	return (target_size - sizeof(struct Fiber_Profiler_Deque_Page)) / deque->element_size;
+}
+
+void *Fiber_Profiler_Deque_push(struct Fiber_Profiler_Deque *deque)
+{
+	struct Fiber_Profiler_Deque_Page *page = deque->tail;
+	
+	if (page == NULL) {
+		page = Fiber_Profiler_Deque_Page_allocate(deque->element_size, Fiber_Profiler_Deque_default_capacity(deque));
+		
+		if (page == NULL) {
+			return NULL;
+		}
+		
+		deque->head = deque->tail = page;
+		deque->capacity += page->capacity;
+	} else if (page->size == page->capacity) {
+		if (page->tail) {
+			page = page->tail;
+			deque->tail = page;
+		} else {
+			page = Fiber_Profiler_Deque_Page_allocate(deque->element_size, Fiber_Profiler_Deque_default_capacity(deque));
+			
+			if (page == NULL) {
+				return NULL;
+			}
+			
+			page->head = deque->tail;
+			deque->tail->tail = page;
+			deque->tail = page;
+			deque->capacity += page->capacity;
+		}
+	}
+	
+	// Push a new element:
+	page->size += 1;
+	void *element = Fiber_Profiler_Deque_Page_get(page, page->size - 1, deque->element_size);
+	
+	if (deque->element_initialize) {
+		deque->element_initialize(element);
+	}
+	
+	if (Fiber_Profiler_Deque_DEBUG) Fiber_Profiler_Deque_debug(deque, __FUNCTION__);
+	
+	return element;
+}
+
+inline static void *Fiber_Profiler_Deque_pop(struct Fiber_Profiler_Deque *deque)
+{
+	struct Fiber_Profiler_Deque_Page *page = deque->tail;
+	
+	if (page == NULL) {
+		return NULL;
+	}
+	
+	while (page->size == 0) {
+		if (page->head) {
+			page = page->head;
+		} else {
+			return NULL;
+		}
+	}
+	
+	deque->tail = page;
+	
+	// Pop the last element:
+	void *element = Fiber_Profiler_Deque_Page_get(page, page->size - 1, deque->element_size);
+	page->size -= 1;
+	
+	if (deque->element_free) {
+		deque->element_free(element);
+	}
+	
+	if (Fiber_Profiler_Deque_DEBUG) Fiber_Profiler_Deque_debug(deque, __FUNCTION__);
+	
+	return element;
+}
+
+inline static void *Fiber_Profiler_Deque_last(struct Fiber_Profiler_Deque *deque)
+{
+	struct Fiber_Profiler_Deque_Page *page = deque->tail;
+	
+	if (page == NULL) {
+		return NULL;
+	}
+	
+	while (page->size == 0) {
+		if (page->head) {
+			page = page->head;
+		} else {
+			return NULL;
+		}
+	}
+	
+	return Fiber_Profiler_Deque_Page_get(page, page->size - 1, deque->element_size);
+}
+
+#define Fiber_Profiler_Deque_each(deque, type, element) \
+	for (struct Fiber_Profiler_Deque_Page *page = (deque)->head; page != NULL && page->size; page = page->tail) \
+		for (size_t i = 0; i < page->size; i++) \
+			for (type *element = Fiber_Profiler_Deque_Page_get(page, i, sizeof(type)); element != NULL; element = NULL)

data/ext/fiber/profiler/fiber.c

@@ -0,0 +1,27 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "fiber.h"
+
+#ifndef HAVE_RB_FIBER_CURRENT
+static ID id_current;
+
+static VALUE Fiber_Profiler_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 Fiber_Profiler_Fiber_blocking(VALUE fiber) {
+	return RTEST(rb_funcall(fiber, id_blocking_p, 0));
+}
+
+void Init_Fiber_Profiler_Fiber(VALUE Fiber_Profiler) {
+#ifndef HAVE_RB_FIBER_CURRENT
+	id_current = rb_intern("current");
+#endif
+	
+	id_blocking_p = rb_intern("blocking?");
+}

data/ext/fiber/profiler/fiber.h

@@ -0,0 +1,16 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#pragma once
+
+#include <ruby.h>
+
+#ifdef HAVE_RB_FIBER_CURRENT
+#define Fiber_Profiler_Fiber_current() rb_fiber_current()
+#else
+VALUE Fiber_Profiler_Fiber_current(void);
+#endif
+
+int Fiber_Profiler_Fiber_blocking(VALUE fiber);
+
+void Init_Fiber_Profiler_Fiber(VALUE Fiber_Profiler);

data/ext/fiber/profiler/profiler.c

@@ -0,0 +1,20 @@
+// Released under the MIT License.
+// Copyright, 2021-2025, by Samuel Williams.
+
+#include "profiler.h"
+
+#include "fiber.h"
+#include "capture.h"
+
+void Init_Fiber_Profiler(void)
+{
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+	rb_ext_ractor_safe(true);
+#endif
+	
+	VALUE Fiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
+	VALUE Fiber_Profiler = rb_define_module_under(Fiber, "Profiler");
+	
+	Init_Fiber_Profiler_Fiber(Fiber_Profiler);
+	Init_Fiber_Profiler_Capture(Fiber_Profiler);
+}

data/ext/fiber/profiler/profiler.h

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

data/ext/fiber/profiler/time.c

@@ -0,0 +1,35 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "time.h"
+
+void Fiber_Profiler_Time_elapsed(const struct timespec* start, const struct timespec* stop, struct timespec *duration)
+{
+	if ((stop->tv_nsec - start->tv_nsec) < 0) {
+		duration->tv_sec = stop->tv_sec - start->tv_sec - 1;
+		duration->tv_nsec = stop->tv_nsec - start->tv_nsec + 1000000000;
+	} else {
+		duration->tv_sec = stop->tv_sec - start->tv_sec;
+		duration->tv_nsec = stop->tv_nsec - start->tv_nsec;
+	}
+}
+
+double Fiber_Profiler_Time_duration(const struct timespec *duration)
+{
+	return duration->tv_sec + duration->tv_nsec / 1000000000.0;
+}
+
+void Fiber_Profiler_Time_current(struct timespec *time) {
+	clock_gettime(CLOCK_MONOTONIC, time);
+}
+
+double Fiber_Profiler_Time_proportion(const struct timespec *duration, const struct timespec *total_duration) {
+	return Fiber_Profiler_Time_duration(duration) / Fiber_Profiler_Time_duration(total_duration);
+}
+
+double Fiber_Profiler_Time_delta(const struct timespec *start, const struct timespec *stop) {
+	struct timespec duration;
+	Fiber_Profiler_Time_elapsed(start, stop, &duration);
+	
+	return Fiber_Profiler_Time_duration(&duration);
+}

data/ext/fiber/profiler/time.h

@@ -0,0 +1,17 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#pragma once
+
+#include <ruby.h>
+#include <time.h>
+
+void Fiber_Profiler_Time_elapsed(const struct timespec* start, const struct timespec* stop, struct timespec *duration);
+double Fiber_Profiler_Time_duration(const struct timespec *duration);
+void Fiber_Profiler_Time_current(struct timespec *time);
+
+double Fiber_Profiler_Time_delta(const struct timespec *start, const struct timespec *stop);
+double Fiber_Profiler_Time_proportion(const struct timespec *duration, const struct timespec *total_duration);
+
+#define Fiber_Profiler_TIME_PRINTF_TIMESPEC "%.3g"
+#define Fiber_Profiler_TIME_PRINTF_TIMESPEC_ARGUMENTS(ts) ((double)(ts).tv_sec + (ts).tv_nsec / 1e9)

data/lib/fiber/profiler/capture.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "native"

data/lib/fiber/profiler/native.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "Fiber_Profiler"

data/lib/fiber/profiler/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+# @namespace
+class Fiber
+	# @namespace
+	module Profiler
+		VERSION = "0.1.0"
+	end
+end

data/lib/fiber/profiler.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "profiler/version"
+require_relative "profiler/native"
+
+module Fiber::Profiler
+	# The default profiler to use, if any.
+	#
+	# Use the `FIBER_PROFILER_CAPTURE=true` environment variable to enable profiling.
+	#
+	# @returns [Capture | Nil]
+	def self.default
+		Capture.default
+	end
+	
+	# Execute the given block with the {default} profiler, if any.
+	#
+	# @yields {...} The block to execute.
+	def self.capture
+		if capture = self.default
+			begin
+				capture.start
+				
+				yield
+			ensure
+				capture.stop
+			end
+		else
+			yield
+		end
+	end
+end

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2025, by Samuel Williams.  
+
+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.

data/readme.md

@@ -0,0 +1,41 @@
+# Fiber::Profiler
+
+Detects fibers that are stalling the event loop.
+
+[![Development Status](https://github.com/socketry/fiber-profiler/workflows/Test/badge.svg)](https://github.com/socketry/fiber-profiler/actions?workflow=Test)
+
+## Motivation
+
+Migrating existing applications to the event loop can be tricky. One of the most common issues is when a fiber is blocking the event loop. This can happen when a fiber is waiting on a blocking operation, such as a database query, or a network request, that could not take advantage of the event loop. This can cause the event loop to stall, and prevent other fibers from running. This gem provides a way to detect these fibers, and help you identify the cause of the stall.
+
+## Usage
+
+Please see the [project documentation](https://socketry.github.io/fiber-profiler/) for more details.
+
+  - [Getting Started](https://socketry.github.io/fiber-profiler/guides/getting-started/index) - This guide explains how to detect stalls using the fiber profiler.
+
+## Releases
+
+Please see the [project releases](https://socketry.github.io/fiber-profiler/releases/index) for all releases.
+
+### v0.1.0
+
+  - Initial implementation extracted from `io-event` gem.
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

data/releases.md

@@ -0,0 +1,5 @@
+# Releases
+
+## v0.1.0
+
+  - Initial implementation extracted from `io-event` gem.

data.tar.gz.sig

@@ -0,0 +1,3 @@
+'��Jg��`��
+�1m���Vk���Lm�z������g�R��~�z�P�F��ɮ֑�ɇ2=q;9˅��?�`��J`�/�
+�C��ڄ(xx�

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: fiber-profiler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 2025-02-13 00:00:00.000000000 Z
+dependencies: []
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/extconf.rb
+- ext/fiber/profiler/capture.c
+- ext/fiber/profiler/capture.h
+- ext/fiber/profiler/deque.h
+- ext/fiber/profiler/fiber.c
+- ext/fiber/profiler/fiber.h
+- ext/fiber/profiler/profiler.c
+- ext/fiber/profiler/profiler.h
+- ext/fiber/profiler/time.c
+- ext/fiber/profiler/time.h
+- lib/fiber/profiler.rb
+- lib/fiber/profiler/capture.rb
+- lib/fiber/profiler/native.rb
+- lib/fiber/profiler/version.rb
+- license.md
+- readme.md
+- releases.md
+homepage: https://github.com/socketry/fiber-profiler
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/fiber-profiler/
+  source_code_uri: https://github.com/socketry/fiber-profiler.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A fiber stall profiler.
+test_files: []

metadata.gz.sig

@@ -0,0 +1,3 @@
+r�!H��
+e�nz�X������L�񉿁栕|�=�~���*4,q�i)ݟ0�M�Q.���H����^
+�s��%��6"��8/�P.6~	0��볪�89U���=rU�xX�5C	
���Õ|�,���