ruby-profiler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0e85aa4c32011018aa3931f59a3465548e32c6f5d20c1ec59b43ab567a790ac5
+  data.tar.gz: ce20b28ad51dac0503f8094b81e0e9e19f5906864473856265f6535df6b1366e
+SHA512:
+  metadata.gz: 4b9f9f473810035e0bc071d22590ccc04c7897dbbf9171c8c7686511de7a5a56aea7a746c5556070acdbdf95e9759196a2b32f0104a5e7a5deabe2511d089495
+  data.tar.gz: eccf1caa3fb6ccef12afce709ee405b88223e1b77c3e34350dcd548211adcb592fd800de513336dc7f20aad7fd90c24ae6b3ce00005cf03b7ac02330c65af732

data/ext/extconf.rb

@@ -0,0 +1,42 @@
+#!/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 = "Ruby_Profiler"
+
+append_cflags(["-Wall", "-Wno-unknown-pragmas", "-std=c99"])
+
+if ENV.key?("RUBY_DEBUG")
+	$stderr.puts "Enabling debug mode..."
+	
+	append_cflags(["-DRUBY_DEBUG", "-O0"])
+end
+
+$srcs = ["ruby/profiler/profiler.c", "ruby/profiler/state.c"]
+$VPATH << "$(srcdir)/ruby/profiler"
+
+have_func("rb_fiber_current")
+have_func("rb_ext_ractor_safe")
+have_func("rb_fiber_storage_get")
+have_func("rb_fiber_storage_set")
+
+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/ruby/profiler/profiler.c

@@ -0,0 +1,66 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "profiler.h"
+#include "state.h"
+
+#include <ruby/debug.h>
+
+#ifndef HAVE_RB_FIBER_CURRENT
+static ID id_current;
+
+static VALUE Ruby_Profiler_Fiber_current(void) {
+	return rb_funcall(rb_cFiber, id_current, 0);
+}
+#else
+static VALUE Ruby_Profiler_Fiber_current(void) {
+	return rb_fiber_current();
+}
+#endif
+
+// Fiber switch callback - updates thread-local pointer based on fiber-local storage
+static void Ruby_Profiler_fiber_switch_callback(rb_event_flag_t event_flag, VALUE data, VALUE self, ID id, VALUE klass) {
+	VALUE fiber = Ruby_Profiler_Fiber_current();
+	
+	struct Ruby_Profiler_State *state = Ruby_Profiler_State_for(fiber);
+	
+	// Update thread-local pointer
+	ruby_profiler_state = state;
+}
+
+void Init_Ruby_Profiler(void)
+{
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+	rb_ext_ractor_safe(true);
+#endif
+
+#ifndef HAVE_RB_FIBER_CURRENT
+	id_current = rb_intern("current");
+#endif
+	
+	// Get or create Ruby module:
+	VALUE Ruby;
+	if (rb_const_defined(rb_cObject, rb_intern("Ruby"))) {
+		Ruby = rb_const_get(rb_cObject, rb_intern("Ruby"));
+	} else {
+		Ruby = rb_define_module("Ruby");
+	}
+	
+	VALUE Ruby_Profiler = rb_define_module_under(Ruby, "Profiler");
+	
+	Init_Ruby_Profiler_State(Ruby_Profiler);
+	
+	// Register fiber switch event hook automatically:
+	// This updates the thread-local pointer whenever a fiber switch occurs.
+	rb_add_event_hook(
+		Ruby_Profiler_fiber_switch_callback,
+		RUBY_EVENT_FIBER_SWITCH,
+		Qnil  // No data needed, callback is stateless.
+	);
+	
+	// Also update state immediately for current fiber:
+	VALUE fiber = Ruby_Profiler_Fiber_current();
+	struct Ruby_Profiler_State *state = Ruby_Profiler_State_for(fiber);
+	ruby_profiler_state = state;
+}
+

data/ext/ruby/profiler/profiler.h

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

data/ext/ruby/profiler/state.c

@@ -0,0 +1,375 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#include "profiler.h"
+#include "state.h"
+
+#include <ruby/internal/core/rhash.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Thread-local pointer to current state (public symbol for BPF access)
+_Thread_local struct Ruby_Profiler_State *ruby_profiler_state = NULL;
+
+VALUE Ruby_Profiler_State = Qnil;
+
+// Cached ID for @ruby_profiler_state instance variable
+ID id_ruby_profiler_state;
+
+static void Ruby_Profiler_State_mark(void *ptr) {
+	struct Ruby_Profiler_State *state = (struct Ruby_Profiler_State*)ptr;
+	
+	// Handle NULL (deferred allocation)
+	if (!state) {
+		return;
+	}
+	
+	// Mark all VALUEs in pairs (iterate through capacity to find all non-empty slots)
+	for (size_t i = 0; i < state->capacity; i++) {
+		if (state->pairs[i].key != 0) {
+			rb_gc_mark_movable(state->pairs[i].value);
+		}
+	}
+}
+
+static void Ruby_Profiler_State_compact(void *ptr) {
+	struct Ruby_Profiler_State *state = (struct Ruby_Profiler_State*)ptr;
+	
+	// Handle NULL (deferred allocation)
+	if (!state) {
+		return;
+	}
+	
+	// Update all VALUE locations after GC compaction (iterate through capacity)
+	for (size_t i = 0; i < state->capacity; i++) {
+		if (state->pairs[i].key != 0) {
+			state->pairs[i].value = rb_gc_location(state->pairs[i].value);
+		}
+	}
+}
+
+static void Ruby_Profiler_State_free(void *ptr) {
+	struct Ruby_Profiler_State *state = (struct Ruby_Profiler_State*)ptr;
+	
+	// Handle NULL (deferred allocation):
+	if (!state) {
+		return;
+	}
+	
+	// If this state is currently active, clear the thread-local pointer
+	if (ruby_profiler_state == state) {
+		ruby_profiler_state = NULL;
+	}
+	
+	free(state);
+}
+
+static size_t Ruby_Profiler_State_memsize(const void *ptr) {
+	const struct Ruby_Profiler_State *state = (const struct Ruby_Profiler_State*)ptr;
+	
+	// Handle NULL (deferred allocation)
+	if (!state) {
+		return 0;
+	}
+	
+	return sizeof(*state) + (state->capacity * sizeof(struct Ruby_Profiler_Pair));
+}
+
+const rb_data_type_t Ruby_Profiler_State_Type = {
+	.wrap_struct_name = "Ruby::Profiler::State",
+	.function = {
+		.dmark = Ruby_Profiler_State_mark,
+		.dcompact = Ruby_Profiler_State_compact,
+		.dfree = Ruby_Profiler_State_free,
+		.dsize = Ruby_Profiler_State_memsize,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+struct Ruby_Profiler_State *Ruby_Profiler_State_get(VALUE self) {
+	struct Ruby_Profiler_State *state;
+	TypedData_Get_Struct(self, struct Ruby_Profiler_State, &Ruby_Profiler_State_Type, state);
+	return state;
+}
+
+// Round up to next power of 2
+static size_t round_capacity_to_power_of_2(size_t capacity) {
+	if (capacity == 0) return 1;
+	capacity--;
+	capacity |= capacity >> 1;
+	capacity |= capacity >> 2;
+	capacity |= capacity >> 4;
+	capacity |= capacity >> 8;
+	capacity |= capacity >> 16;
+#if SIZEOF_SIZE_T == 8
+	capacity |= capacity >> 32;
+#endif
+	return capacity + 1;
+}
+
+static VALUE Ruby_Profiler_State_allocate(VALUE klass) {
+	// Defer allocation until initialize when we know the required capacity
+	return TypedData_Wrap_Struct(klass, &Ruby_Profiler_State_Type, NULL);
+}
+
+// Find a pair by key using hash table lookup with linear probing
+static struct Ruby_Profiler_Pair *Ruby_Profiler_State_find_pair(struct Ruby_Profiler_State *state, ID key) {
+	if (key == 0 || state->capacity == 0) {
+		return NULL;
+	}
+	
+	size_t mask = state->capacity - 1;  // Assumes power of 2
+	size_t idx = (size_t)key & mask;
+	
+	for (size_t i = 0; i < state->capacity; i++) {
+		size_t pos = (idx + i) & mask;
+		
+		if (state->pairs[pos].key == key) {
+			return &state->pairs[pos];
+		}
+		if (state->pairs[pos].key == 0) {
+			return NULL;  // Empty slot means not found
+		}
+	}
+	
+	return NULL;  // Table full, key not found
+}
+
+// Insert or update a pair using hash table with linear probing
+static int Ruby_Profiler_State_insert_pair(struct Ruby_Profiler_State *state, ID key, VALUE value) {
+	if (key == 0) {
+		return 0;  // Invalid key
+	}
+	
+	size_t mask = state->capacity - 1;  // Assumes power of 2
+	size_t idx = (size_t)key & mask;
+	
+	// First, check if key already exists (update case)
+	for (size_t i = 0; i < state->capacity; i++) {
+		size_t pos = (idx + i) & mask;
+		
+		if (state->pairs[pos].key == key) {
+			// Update existing pair (doesn't require capacity check)
+			state->pairs[pos].value = value;
+			return 1;
+		}
+		if (state->pairs[pos].key == 0) {
+			// Found empty slot, check capacity before inserting
+			if (state->size >= state->capacity) {
+				return 0;  // Table full
+			}
+			// Insert here
+			state->pairs[pos].key = key;
+			state->pairs[pos].value = value;
+			state->size++;
+			return 1;
+		}
+	}
+	
+	return 0;  // Table full (no empty slot found)
+}
+
+// Callback for rb_hash_foreach to insert pairs into state
+static int Ruby_Profiler_State_foreach_insert(VALUE key, VALUE value, VALUE data) {
+	struct Ruby_Profiler_State *state = (struct Ruby_Profiler_State*)data;
+	
+	// Keys must be symbols - raise TypeError if not
+	if (!RB_TYPE_P(key, T_SYMBOL)) {
+		rb_raise(rb_eTypeError, "State keys must be symbols, got %s", rb_obj_classname(key));
+	}
+	
+	ID id = rb_sym2id(key);
+	
+	// Insert using hash table (will update if key exists, insert if new)
+	if (!Ruby_Profiler_State_insert_pair(state, id, value)) {
+		rb_raise(rb_eArgError, "State capacity exceeded (%zu pairs)!", state->capacity);
+	}
+	
+	return ST_CONTINUE;
+}
+
+// Helper struct for counting new keys
+struct Ruby_Profiler_State_CountData {
+	struct Ruby_Profiler_State *old_state;
+	size_t new_count;
+};
+
+// Callback for rb_hash_foreach to count new keys (keys not in old_state)
+static int Ruby_Profiler_State_foreach_count_new(VALUE key, VALUE value, VALUE data) {
+	struct Ruby_Profiler_State_CountData *count_data = (struct Ruby_Profiler_State_CountData*)data;
+	
+	// Keys must be symbols
+	if (!RB_TYPE_P(key, T_SYMBOL)) {
+		return ST_CONTINUE;  // Skip non-symbols, will be caught during insert
+	}
+	
+	ID id = rb_sym2id(key);
+	
+	// Count if key doesn't exist in old_state
+	if (!count_data->old_state || !Ruby_Profiler_State_find_pair(count_data->old_state, id)) {
+		count_data->new_count++;
+	}
+	
+	return ST_CONTINUE;
+}
+
+static VALUE Ruby_Profiler_State_initialize(int argc, VALUE *argv, VALUE self) {
+	struct Ruby_Profiler_State *state;
+	TypedData_Get_Struct(self, struct Ruby_Profiler_State, &Ruby_Profiler_State_Type, state);
+	
+	if (state) {
+		rb_raise(rb_eRuntimeError, "State already initialized!");
+	}
+	
+	VALUE options = Qnil;
+	rb_scan_args(argc, argv, ":", &options);
+	
+	// Determine required capacity based on number of pairs
+	size_t required_capacity = 0;
+	
+	if (!RB_NIL_P(options)) {
+		// Get hash size directly without allocating temporary array
+		size_t keys_count = RHASH_SIZE(options);
+		
+		// Calculate required capacity (next power of 2)
+		required_capacity = round_capacity_to_power_of_2(keys_count);
+	} else {
+		return self;
+	}
+	
+	// Allocate state with correct capacity (or reallocate if already allocated)
+	size_t size = sizeof(struct Ruby_Profiler_State) + (required_capacity * sizeof(struct Ruby_Profiler_Pair));
+	state = (struct Ruby_Profiler_State*)calloc(1, size);
+	
+	if (!state) {
+		rb_raise(rb_eNoMemError, "Failed to allocate state!");
+	}
+	
+	// Initialize state:
+	state->size = 0;
+	state->capacity = required_capacity;
+	
+	// Update TypedData pointer:
+	DATA_PTR(self) = state;
+
+	// Now insert all pairs using rb_hash_foreach (more efficient than allocating keys array):
+	rb_hash_foreach(options, Ruby_Profiler_State_foreach_insert, (VALUE)state);
+	
+	return self;
+}
+
+static VALUE Ruby_Profiler_State_apply(VALUE self) {
+	struct Ruby_Profiler_State *state = Ruby_Profiler_State_get(self);
+	
+	// Update the thread-local pointer (NULL if state not initialized)
+	ruby_profiler_state = state;
+	
+	// Store state in fiber-local storage using Fiber#ruby_profiler_state=
+	// This is fiber-local storage that persists across fiber switches
+	VALUE fiber;
+
+#ifdef HAVE_RB_FIBER_CURRENT
+	fiber = rb_fiber_current();
+#else
+	fiber = rb_funcall(rb_cFiber, rb_intern("current"), 0);
+#endif
+	
+	rb_ivar_set(fiber, id_ruby_profiler_state, self);
+	
+	return self;
+}
+
+static VALUE Ruby_Profiler_State_size(VALUE self) {
+	struct Ruby_Profiler_State *state = Ruby_Profiler_State_get(self);
+	
+	if (!state) {
+		return SIZET2NUM(0);  // Uninitialized state has size 0
+	}
+	
+	return SIZET2NUM(state->size);
+}
+
+static VALUE Ruby_Profiler_State_with(int argc, VALUE *argv, VALUE self) {
+	struct Ruby_Profiler_State *old_state;
+	TypedData_Get_Struct(self, struct Ruby_Profiler_State, &Ruby_Profiler_State_Type, old_state);
+	
+	VALUE options = Qnil;
+	rb_scan_args(argc, argv, ":", &options);
+	
+	if (RB_NIL_P(options)) {
+		// No updates, return self:
+		return self;
+	}
+	
+	// Count how many keys in options are NOT in old_state (new keys)
+	size_t old_size = old_state ? old_state->size : 0;
+	struct Ruby_Profiler_State_CountData count_data = {old_state, 0};
+	
+	rb_hash_foreach(options, Ruby_Profiler_State_foreach_count_new, (VALUE)&count_data);
+	
+	size_t required_capacity = round_capacity_to_power_of_2(old_size + count_data.new_count);
+	
+	// Allocate a new state with the required capacity
+	VALUE klass = rb_obj_class(self);
+	VALUE new_state_value = Ruby_Profiler_State_allocate(klass);
+	
+	// Allocate the new state struct
+	size_t size = sizeof(struct Ruby_Profiler_State) + (required_capacity * sizeof(struct Ruby_Profiler_Pair));
+	struct Ruby_Profiler_State *new_state = (struct Ruby_Profiler_State*)calloc(1, size);
+	
+	if (!new_state) {
+		rb_raise(rb_eNoMemError, "Failed to allocate Ruby_Profiler_State");
+	}
+	
+	new_state->size = 0;
+	new_state->capacity = required_capacity;
+	DATA_PTR(new_state_value) = new_state;
+	
+	// Copy all existing pairs from old_state to new_state (if old_state exists)
+	if (old_state) {
+		for (size_t i = 0; i < old_state->capacity; i++) {
+			if (old_state->pairs[i].key != 0) {
+				if (!Ruby_Profiler_State_insert_pair(new_state, old_state->pairs[i].key, old_state->pairs[i].value)) {
+					rb_raise(rb_eArgError, "State capacity exceeded while copying state");
+				}
+			}
+		}
+	}
+	
+	// Apply updates from options hash using rb_hash_foreach
+	rb_hash_foreach(options, Ruby_Profiler_State_foreach_insert, (VALUE)new_state);
+	
+	return new_state_value;
+}
+
+// Get state for fiber from fiber-local storage
+struct Ruby_Profiler_State *Ruby_Profiler_State_for(VALUE fiber) {
+	VALUE state_value = rb_ivar_get(fiber, id_ruby_profiler_state);
+	
+	if (RB_NIL_P(state_value)) {
+		return NULL;
+	}
+	
+	// Extract the state pointer from the VALUE
+	struct Ruby_Profiler_State *state;
+	if (!rb_typeddata_is_kind_of(state_value, &Ruby_Profiler_State_Type)) {
+		return NULL;
+	}
+	
+	TypedData_Get_Struct(state_value, struct Ruby_Profiler_State, &Ruby_Profiler_State_Type, state);
+	return state;
+}
+
+void Init_Ruby_Profiler_State(VALUE Ruby_Profiler) {
+	Ruby_Profiler_State = rb_define_class_under(Ruby_Profiler, "State", rb_cObject);
+	rb_define_alloc_func(Ruby_Profiler_State, Ruby_Profiler_State_allocate);
+	
+	// Cache the ID for @ruby_profiler_state instance variable
+	id_ruby_profiler_state = rb_intern("@ruby_profiler_state");
+	
+	rb_define_method(Ruby_Profiler_State, "initialize", Ruby_Profiler_State_initialize, -1);
+	rb_define_method(Ruby_Profiler_State, "apply!", Ruby_Profiler_State_apply, 0);
+	rb_define_method(Ruby_Profiler_State, "with", Ruby_Profiler_State_with, -1);
+	rb_define_method(Ruby_Profiler_State, "size", Ruby_Profiler_State_size, 0);
+}
+

data/ext/ruby/profiler/state.h

@@ -0,0 +1,56 @@
+// Released under the MIT License.
+// Copyright, 2025, by Samuel Williams.
+
+#pragma once
+
+#include <ruby.h>
+
+struct Ruby_Profiler_Pair {
+	// ID 0 indicates empty slot:
+	ID key;
+	VALUE value;
+};
+
+// This state is considered a public interface for BPF programs to read. Therefore, we will endeavour not to change it without an extremely good reason.
+struct Ruby_Profiler_State {
+	// Number of active pairs:
+	size_t size;
+
+	// Total slots (must be power of 2 for efficient hashing):
+	size_t capacity;
+	
+	// Array of pairs:
+	struct Ruby_Profiler_Pair pairs[];
+};
+
+// Hash Table Design:
+//
+// For small hash tables (< 16 items) with integer keys like your Ruby profiler,
+// hash + linear probing at 100% load factor is optimal: computing key % capacity
+// (especially with power-of-2 capacity using bitwise AND) is essentially free, and
+// even in the worst case where you scan all slots, you're no worse off than a pure
+// linear scan from index 0, while on average you start closer to your target and
+// find items faster—giving you all the benefits of hashing with zero memory overhead
+// and no downside, making it strictly better than either pure linear scan or traditional
+// linear probing with lower load factors.
+//
+// Implementation details:
+// - Capacity must be a power of 2 (enforced at allocation).
+// - Hash function: key & (capacity - 1) (fast bitwise AND).
+// - Linear probing: (hash + i) & (capacity - 1) for i = 0, 1, 2, ...
+// - Empty slots: key == 0 (ID 0 is invalid in Ruby).
+// - BPF-friendly: Can enumerate by iterating capacity slots and skipping empty ones.
+
+// Thread-local pointer to current state (public symbol for BPF access)
+extern _Thread_local struct Ruby_Profiler_State *ruby_profiler_state;
+
+// Typed data type (defined in state.c)
+extern const rb_data_type_t Ruby_Profiler_State_Type;
+
+// Cached ID for @ruby_profiler_state instance variable (defined in state.c)
+extern ID id_ruby_profiler_state;
+
+// Get state for fiber from fiber-local storage
+struct Ruby_Profiler_State *Ruby_Profiler_State_for(VALUE fiber);
+
+void Init_Ruby_Profiler_State(VALUE Ruby_Profiler);

data/lib/ruby/profiler/native.rb

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

data/lib/ruby/profiler/version.rb

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

data/lib/ruby/profiler.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "profiler/version"
+require_relative "profiler/native"
+
+# Define fiber-local accessor for profiler state:
+Fiber.attr_accessor :ruby_profiler_state

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,37 @@
+# Ruby Profiler
+
+A profiler state manager for Ruby fibers, designed for BPF/eBPF integration.
+
+[![Development Status](https://github.com/socketry/ruby-profiler/workflows/Test/badge.svg)](https://github.com/socketry/ruby-profiler/actions?workflow=Test)
+
+## Usage
+
+Please see the [project documentation](https://socketry.github.io/ruby-profiler/) for more details.
+
+  - [Getting Started](https://socketry.github.io/ruby-profiler/guides/getting-started/index) - This guide explains how to get started with `ruby-profiler`, a profiler state manager for Ruby fibers designed for BPF/eBPF integration.
+
+  - [BPF Integration Guide](https://socketry.github.io/ruby-profiler/guides/bpf-integration/index) - This guide explains how to integrate `ruby-profiler` with BPF/eBPF programs to read profiler state from Ruby fibers.
+
+## Releases
+
+Please see the [project releases](https://socketry.github.io/ruby-profiler/releases/index) for all releases.
+
+### v0.1.0
+
+## 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,3 @@
+# Releases
+
+## v0.1.0

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: ruby-profiler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/extconf.rb
+- ext/ruby/profiler/profiler.c
+- ext/ruby/profiler/profiler.h
+- ext/ruby/profiler/state.c
+- ext/ruby/profiler/state.h
+- lib/ruby/profiler.rb
+- lib/ruby/profiler/native.rb
+- lib/ruby/profiler/version.rb
+- license.md
+- readme.md
+- releases.md
+homepage: https://github.com/socketry/ruby-profiler
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/ruby-profiler/
+  source_code_uri: https://github.com/socketry/ruby-profiler.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A profiler state manager for Ruby fibers.
+test_files: []