pf2 0.13.0 → 1.0.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84ea10eb9b861a910a1190ea017ad276ad593bc460c01687aabce8128392e35a
-  data.tar.gz: abd41b0b0ca74ebbcfeb1a202b75a4eec52f7c48b5b87e80d6e3052516304415
+  metadata.gz: 9f219b8aa5b5281a6ed662a085e00f82636ab52365d2b0f7a8d61a3e06bfc9c6
+  data.tar.gz: 162e1eae488afe17e33291f63f807642aa304d7df8069cb165e3a25ce6f10895
 SHA512:
-  metadata.gz: 7f17ba3e89269c97398559f97b87033a598e590b4c20efe341b76ce4841a47080a75c6324cce0881f83b6d68a336892ccd7ca593b953f5963097cf99b0a065ab
-  data.tar.gz: d09630c20fbddb0e5b072c20cf97ad0af0f541db7fa4265090427a0a64af0bf4b565923fe9e988438a623e060c902ba92243b75d6b0f257df57b11674d8d4d1b
+  metadata.gz: 37b6a1aa4f6ab0753d86983d76cbdfae4b3dfbb7464afb0388aa113d728725f09eabcabb2ae7c2ffadc5ab797be75675b5b27b465c20565d5d69f30291d4837f
+  data.tar.gz: 7b69aea55c8873cfd6e28fba3bdddd09325e4c73e1e3e44a5be48fcb9ad776b03e811c707fc049ad8ccc1590e7c011032be7f4053e3d15a5ba5b50c4344db656

data/CHANGELOG.md

@@ -1,87 +1,5 @@
 ## [Unreleased]
 
-## [0.13.0] - 2026-01-18
-
-### Added
-
-- Pf2 should now have a dramatically lower memory footprint.
-  - Samples are now stored in a compact hashmap internally.
-  - See https://github.com/osyoyu/pf2/pull/85 for details.
-
-### Fixed
-
-- `pf2 serve` command now properly works. (Thanks @hanazuki)
-
-
-## [0.12.0] - 2026-01-09
-
-### Added
-
-- `Pf2.profile` now accepts the same options as `Pf2.start`.
-- The resulting profile now has `collected_sample_count` and `dropped_sample_count` fields.
-
-### Fixed
-
-- Samples captured after the collector thread was stopped now get included in the profile.
-  - This shouldn't matter in practice (this all happens after `Pf2.stop` is called).
-
-### Changed
-
-- Accepted max stack depth is expanded to 1024 for Ruby (was 200) and 512 for native (was 300).
-  - This is not configurable, but should be sufficient for most use cases. Please open an issue if you need higher limits.
-- Pf2.profile now accepts the same parameters as Pf2.start.
-- Internal changes
-  - Updated libbacktrace to the latest version as of 2026/1/8.
-  - Tests are now much more stabilized.
-
-
-## [0.11.3] - 2025-12-28
-
-This version is for testing the new release process through [Trusted Publishing](https://guides.rubygems.org/trusted-publishing/). All code is identical to 0.11.2.
-
-
-## [0.11.2] - 2025-12-28
-
-0.11.1 was yanked since it was accidentally published without libbacktrace vendored. Use 0.11.2.
-
-### Fixed
-
-- Fixed issues preventing builds on macOS.
-
-
-## [0.11.0] - 2025-12-27
-
-### Added
-
-- RDoc documentation is now online - https://osyoyu.github.io/pf2/
-- Native stack consolidation now supports LTO-ed binaries (@hanazuki)
-
-### Changed
-
-- `Pf2c` module is now completely removed. `Pf2c::Session` has been merged as `Pf2::Session`.
-
-### Fixed
-
-- Fixed an bug where the program crashes when a `Pf2::Session` is GC'd before profiling starts.
-- Fixed an bug where the program crashes when the native stack was more than 200 frames deep.
-
-
-## [0.10.0] - 2025-12-26
-
-### Added
-
-**This version contains a complete rewrite of the profiler!**
-
-- The default sample collection backend has been switched to the new C-based backend.
-  - The previous Rust-based backed has been removed. Use v0.9.0 if you need it.
-- macOS / non-Linux platform support!
-  - On platforms which lack `timer_create(3)` such as macOS, Pf2 now fall backs to `setitimer(3)` based sampling. This mode does not support per-thread CPU time sampling.
-
-### Changed
-
-- `logger` is now declared as a dependency (Ruby 4.0 compat).
-
-
 ## [0.9.0] - 2025-03-22
 
 ## Added
@@ -93,7 +11,6 @@ This version is for testing the new release process through [Trusted Publishing]
 
 - Set SA_RESTART flag to reduce EINTRs in profiled code
 
-
 ## [0.8.0] - 2025-01-27
 
 ## Added
@@ -102,14 +19,12 @@ This version is for testing the new release process through [Trusted Publishing]
   - This serializer is more efficient and has a smaller memory footprint than the default serializer.
   - Ser2 still lacks some features, such as weaving of native stacks.
 
-
 ## [0.7.1] - 2025-01-02
 
 ### Fixed
 
 - Reverted Cargo.lock version to 3 to support older versions of Rust (<1.78).
 
-
 ## [0.7.0] - 2025-01-03
 
 ### Changed

data/README.md

@@ -3,10 +3,6 @@ Pf2
 
 A experimental sampling-based profiler for Ruby 3.3+.
 
-- GitHub: https://github.com/osyoyu/pf2
-- Documentation: https://osyoyu.github.io/pf2/
-
-
 Notable Capabilites
 --------
 
@@ -17,25 +13,6 @@ Notable Capabilites
 Usage
 --------
 
-### Installation
-
-You will need a C compiler to build the native extension.
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'pf2'
-
-# When using the main branch, specify submodules: true
-gem 'pf2', git: 'https://github.com/osyoyu/pf2.git', submodules: true
-```
-
-Pf2 can be installed as a standalone CLI tool as well.
-
-```console
-gem install pf2
-```
-
 ### Quickstart
 
 Run your Ruby program through `pf2 serve`.
@@ -97,7 +74,10 @@ Pf2 accepts the following configuration keys:
 ```rb
 Pf2.start(
   interval_ms: 9,        # Integer: The sampling interval in milliseconds (default: 9)
-  time_mode: :cpu,       # `:cpu` or `:wall`: The sampling timer's mode
+  time_mode: :cpu,        # `:cpu` or `:wall`: The sampling timer's mode
+                          # (default: `:cpu` for SignalScheduler, `:wall` for TimerThreadScheduler)
+  threads: [th1, th2],    # `Array<Thread>` | `:all`: A list of Ruby Threads to be tracked.
+                          # When `:all` or unspecified, Pf2 will track all active Threads.
 )
 ```
 
@@ -128,33 +108,36 @@ Pf2 is a _sampling profiler_. This means that Pf2 collects _samples_ of program
 
 Pf2 uses the `rb_profile_thread_frames()` API for sampling. When to do so is controlled by _Schedulers_, described in the following section.
 
-### Scheduling
+### Schedulers
 
-Schedulers determine when to execute sample collection, based on configuration (time mode and interval).
+Schedulers determine when to execute sample collection, based on configuration (time mode and interval). Pf2 has two schedulers available.
 
-#### Signal-based scheduling
+#### SignalScheduler (Linux-only)
 
-Pf2 schedules sample collection using POSIX timers. It creates a POSIX timer using `timer_create(3)` where available, or otherwise `setitimer(3)`. This leaves the actual time-keeping to the operating system kernel, which is capable of tracking accurate per-thread CPU time usage.
+The first is the `SignalScheduler`, based on POSIX timers. Pf2 will use this scheduler when possible. SignalScheduler creates a POSIX timer for each Ruby Thread (the underlying pthread to be more accurate) using `timer_create(2)`. This leaves the actual time-keeping to the OS, which is capable of tracking accurate per-thread CPU time usage.
 
-When the specified interval has arrived (the timer has _expired_), the OS delivers us a SIGPROF signal.
+When the specified interval has arrived (the timer has _expired_), the OS delivers us a SIGPROF signal. This is why the scheduler is named SignalScheduler.
 
 Signals are directed to Ruby Threads' underlying pthread, effectively "pausing" the Thread's activity. This routing is done using `SIGEV_THREAD_ID`, which is a Linux-only feature. Sample collection is done in the signal handler, which is expected to be more _accurate_, capturing the paused Thread's activity.
 
 This scheduler heavily relies on Ruby's 1:N Thread model (1 Ruby Threads is strongly tied to a native pthread). It will not work properly in MaNy (`RUBY_MN_THREADS=1`).
 
-#### ~~Timer-thread based scheduling~~
-
-Note: Timer thread-based scheduling has been removed in v0.10.0, when the profiling backend has been rewritten in C. This may come back in the future if needed.
+#### TimerThreadScheduler
 
 Another scheduler is the `TimerThreadScheduler`, which maintains a time-keeping thread by itself. A new native thread (pthread on Linux/macOS) will be created, and an infinite loop will be run inside. After `sleep(2)`-ing for the specified interval time, sampling will be queued using Ruby's Postponed Job API.
 
 This scheduler is wall-time only, and does not support CPU-time based profiling.
 
+#### macOS Support
+
+On platforms where `timer_create()` is not supported (namely macOS), Pf2 falls back to `setitimer()`.
+
 
 Wishlist
 --------
 
 - [Flame Scopes](https://www.brendangregg.com/flamescope.html)
+- More unit/e2e tests
 - more
 
 Development
@@ -167,4 +150,3 @@ License
 --------
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-See [LICENSE.txt](/LICENSE.txt) and [THIRD_PARTY_LICENSES.txt](/THIRD_PARTY_LICENSES.txt) for details.

data/Rakefile

@@ -1,7 +1,6 @@
 require 'bundler/gem_tasks'
 require 'rake/extensiontask'
 require 'minitest/test_task'
-require 'rdoc/task'
 
 task default: %i[]
 
@@ -15,9 +14,4 @@ Minitest::TestTask.create(:test) do |t|
   t.libs << "lib"
   t.warning = false
   t.test_globs = ["test/**/*_test.rb"]
-  t.extra_args << "--verbose"
-end
-
-RDoc::Task.new do |doc|
-  doc.rdoc_dir = "_site" # for GitHub pages
 end

data/ext/pf2/configuration.c

@@ -1,12 +1,10 @@
 #include <ruby.h>
 #include <stdlib.h>
-#include <stdbool.h>
 
 #include "configuration.h"
 
 static int extract_interval_ms(VALUE options_hash);
 static enum pf2_time_mode extract_time_mode(VALUE options_hash);
-static bool extract__test_no_install_timer(VALUE options_hash);
 
 struct pf2_configuration *
 pf2_configuration_new_from_options_hash(VALUE options_hash)
@@ -18,7 +16,6 @@ pf2_configuration_new_from_options_hash(VALUE options_hash)
 
     config->interval_ms = extract_interval_ms(options_hash);
     config->time_mode = extract_time_mode(options_hash);
-    config->_test_no_install_timer = extract__test_no_install_timer(options_hash);
 
     return config;
 }
@@ -60,17 +57,6 @@ extract_time_mode(VALUE options_hash)
     }
 }
 
-static bool
-extract__test_no_install_timer(VALUE options_hash)
-{
-    if (options_hash == Qnil) {
-        return PF2_DEFAULT__TEST_NO_INSTALL_TIMER;
-    }
-
-    VALUE _test_no_install_timer = rb_hash_aref(options_hash, ID2SYM(rb_intern("_test_no_install_timer")));
-    return RTEST(_test_no_install_timer);
-}
-
 void
 pf2_configuration_free(struct pf2_configuration *config)
 {

data/ext/pf2/configuration.h

@@ -2,7 +2,6 @@
 #define PF2_CONFIGURATION_H
 
 #include <ruby.h>
-#include <stdbool.h>
 
 enum pf2_time_mode {
     PF2_TIME_MODE_CPU_TIME,
@@ -12,12 +11,10 @@ enum pf2_time_mode {
 struct pf2_configuration {
     int interval_ms;
     enum pf2_time_mode time_mode;
-    bool _test_no_install_timer; // for testing only
 };
 
 #define PF2_DEFAULT_INTERVAL_MS 9
 #define PF2_DEFAULT_TIME_MODE PF2_TIME_MODE_CPU_TIME
-#define PF2_DEFAULT__TEST_NO_INSTALL_TIMER false
 
 struct pf2_configuration *pf2_configuration_new_from_options_hash(VALUE options_hash);
 void pf2_configuration_free(struct pf2_configuration *config);

data/ext/pf2/extconf.rb

@@ -1,44 +1,10 @@
 require 'mkmf'
 require 'mini_portile2'
-require 'fileutils'
-require 'optparse'
-
-gem_root = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
-
-options = {
-  debug: ENV['PF2_DEBUG'] == '1',
-}
-option_parser = OptionParser.new do |opts|
-  opts.on('--debug[=BOOL]') do |debug|
-    options[:debug] =
-      case debug
-      when nil, "true"
-        true
-      when "false"
-        false
-      else
-        raise OptionParser::InvalidArgument, "Expected true or false for --debug"
-      end
-  end
-end
-option_parser.parse!(ARGV)
 
 libbacktrace = MiniPortile.new('libbacktrace', '1.0.0')
-libbacktrace.source_directory = File.join(gem_root, 'vendor', 'libbacktrace')
-libbacktrace.patch_files = Dir.glob(File.join(gem_root, 'ext', 'patches', 'libbacktrace', '*.patch'))
+libbacktrace.source_directory = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'vendor', 'libbacktrace'))
 libbacktrace.configure_options << 'CFLAGS=-fPIC'
-
-# Expand 'libbacktrace.cook' to call #patch on source_directory files
-libbacktrace.prepare_build_directory
-# Added: Copy source to build_directory
-build_directory = libbacktrace.send(:work_path)
-FileUtils.cp_r(File.join(libbacktrace.source_directory, '.'), build_directory)
-libbacktrace.patch
-libbacktrace.configure unless libbacktrace.configured?
-libbacktrace.compile
-libbacktrace.install unless libbacktrace.installed?
-# END expand 'libbacktrace.cook'
-
+libbacktrace.cook
 libbacktrace.mkmf_config
 
 if !have_func('backtrace_full', 'backtrace.h')
@@ -47,7 +13,7 @@ end
 
 append_ldflags('-lrt') # for timer_create
 append_cflags('-fvisibility=hidden')
-append_cflags('-DPF2_DEBUG') if options[:debug]
+append_cflags('-DPF2_DEBUG') if ENV['PF2_DEBUG'] == '1'
 
 # Check for timer functions
 have_timer_create = have_func('timer_create')

data/ext/pf2/pf2.c

@@ -2,16 +2,16 @@
 
 #include "session.h"
 
-VALUE rb_mPf2;
+VALUE rb_mPf2c;
 
 RUBY_FUNC_EXPORTED void
 Init_pf2(void)
 {
-    rb_mPf2 = rb_define_module("Pf2");
-    VALUE rb_mPf2_cSession = rb_define_class_under(rb_mPf2, "Session", rb_cObject);
-    rb_define_alloc_func(rb_mPf2_cSession, pf2_session_alloc);
-    rb_define_method(rb_mPf2_cSession, "initialize", rb_pf2_session_initialize, -1);
-    rb_define_method(rb_mPf2_cSession, "start", rb_pf2_session_start, 0);
-    rb_define_method(rb_mPf2_cSession, "stop", rb_pf2_session_stop, 0);
-    rb_define_method(rb_mPf2_cSession, "configuration", rb_pf2_session_configuration, 0);
+    rb_mPf2c = rb_define_module("Pf2c");
+    VALUE rb_mPf2c_cSession = rb_define_class_under(rb_mPf2c, "Session", rb_cObject);
+    rb_define_alloc_func(rb_mPf2c_cSession, pf2_session_alloc);
+    rb_define_method(rb_mPf2c_cSession, "initialize", rb_pf2_session_initialize, -1);
+    rb_define_method(rb_mPf2c_cSession, "start", rb_pf2_session_start, 0);
+    rb_define_method(rb_mPf2c_cSession, "stop", rb_pf2_session_stop, 0);
+    rb_define_method(rb_mPf2c_cSession, "configuration", rb_pf2_session_configuration, 0);
 }

data/ext/pf2/sample.c

@@ -9,6 +9,8 @@
 #include "backtrace_state.h"
 #include "sample.h"
 
+const int PF2_SAMPLE_MAX_NATIVE_DEPTH = 300;
+
 static int capture_native_backtrace(struct pf2_sample *sample);
 static int backtrace_on_ok(void *data, uintptr_t pc);
 
@@ -27,7 +29,7 @@ pf2_sample_capture(struct pf2_sample *sample)
     sample->context_pthread = pthread_self();
 
     // Obtain the current stack from Ruby
-    sample->depth = rb_profile_frames(0, PF2_SAMPLE_MAX_RUBY_DEPTH, sample->cmes, sample->linenos);
+    sample->depth = rb_profile_frames(0, 200, sample->cmes, sample->linenos);
 
     // Capture C-level backtrace
     sample->native_stack_depth = capture_native_backtrace(sample);

data/ext/pf2/sample.h

@@ -5,18 +5,17 @@
 
 #include <ruby.h>
 
-#define PF2_SAMPLE_MAX_RUBY_DEPTH 1024
-#define PF2_SAMPLE_MAX_NATIVE_DEPTH 512
+extern const int PF2_SAMPLE_MAX_NATIVE_DEPTH;
 
 struct pf2_sample {
     pthread_t context_pthread;
 
     int depth;
-    VALUE cmes[PF2_SAMPLE_MAX_RUBY_DEPTH];
-    int linenos[PF2_SAMPLE_MAX_RUBY_DEPTH];
+    VALUE cmes[200];
+    int linenos[200];
 
     size_t native_stack_depth;
-    uintptr_t native_stack[PF2_SAMPLE_MAX_NATIVE_DEPTH];
+    uintptr_t native_stack[200];
 
     uint64_t consumed_time_ns;
     uint64_t timestamp_ns;

data/ext/pf2/serializer.c

@@ -1,7 +1,6 @@
 #include <time.h>
 #include <stdint.h>
 #include <string.h>
-#include <stdatomic.h>
 
 #include <ruby.h>
 #include <ruby/debug.h>
@@ -17,8 +16,8 @@ static struct pf2_ser_function extract_function_from_ruby_frame(VALUE frame);
 static struct pf2_ser_function extract_function_from_native_pc(uintptr_t pc);
 // static int backtrace_pcinfo_callback(void *data, uintptr_t pc, const char *filename, int lineno, const char *function);
 static void pf2_backtrace_syminfo_callback(void *data, uintptr_t pc, const char *symname, uintptr_t symval, uintptr_t symsize);
-static size_t function_index_for(struct pf2_ser *serializer, struct pf2_ser_function *function);
-static size_t location_index_for(struct pf2_ser *serializer, size_t function_index, int32_t lineno);
+static int function_index_for(struct pf2_ser *serializer, struct pf2_ser_function *function);
+static int location_index_for(struct pf2_ser *serializer, int function_index, int32_t lineno);
 static void ensure_samples_capacity(struct pf2_ser *serializer);
 static void ensure_locations_capacity(struct pf2_ser *serializer);
 static void ensure_functions_capacity(struct pf2_ser *serializer);
@@ -30,9 +29,6 @@ pf2_ser_new(void) {
     ser->start_timestamp_ns = 0;
     ser->duration_ns = 0;
 
-    ser->collected_sample_count = 0;
-    ser->dropped_sample_count = 0;
-
     ser->samples = NULL;
     ser->samples_count = 0;
     ser->samples_capacity = 0;
@@ -80,125 +76,48 @@ pf2_ser_prepare(struct pf2_ser *serializer, struct pf2_session *session) {
         (uint64_t)session->start_time_realtime.tv_sec * 1000000000ULL +
         (uint64_t)session->start_time_realtime.tv_nsec;
     serializer->duration_ns = session->duration_ns;
-    serializer->collected_sample_count =
-        atomic_load_explicit(&session->collected_sample_count, memory_order_relaxed);
-    serializer->dropped_sample_count =
-        atomic_load_explicit(&session->dropped_sample_count, memory_order_relaxed);
-
-    // ---------------------------------------------------------------------
-    // Build locations/functions from the session's interning tables
-    // ---------------------------------------------------------------------
-    size_t location_table_size = kh_size(session->location_table);
-    if (location_table_size > serializer->locations_capacity) {
-        serializer->locations_capacity = location_table_size;
-        serializer->locations = realloc(
-            serializer->locations,
-            serializer->locations_capacity * sizeof(struct pf2_ser_location)
-        );
-    }
 
-    khint_t k;
-    kh_foreach(session->location_table, k) {
-        size_t location_id = kh_val(session->location_table, k);
-        VALUE cme = kh_key(session->location_table, k).cme;
-        int lineno = kh_key(session->location_table, k).lineno;
+    // Process samples
+    for (size_t i = 0; i < session->samples_index; i++) {
+        struct pf2_sample *sample = &session->samples[i];
+        ensure_samples_capacity(serializer);
 
-        struct pf2_ser_function func = extract_function_from_ruby_frame(cme);
-        size_t function_index = function_index_for(serializer, &func);
+        struct pf2_ser_sample *ser_sample = &serializer->samples[serializer->samples_count++];
+        ser_sample->ruby_thread_id = sample->context_pthread;
+        ser_sample->elapsed_ns = sample->timestamp_ns - serializer->start_timestamp_ns;
 
-        // location ids are assigned sequentially in intern_location, so we can
-        // place them directly by id.
-        serializer->locations[location_id].function_index = function_index;
-        serializer->locations[location_id].lineno = lineno;
-        serializer->locations[location_id].address = 0;
-    }
-    serializer->locations_count = location_table_size;
-
-    // ---------------------------------------------------------------------
-    // Precompute stack/native stack lookups by id for fast access
-    // ---------------------------------------------------------------------
-    size_t ruby_stack_count = kh_size(session->stack_table);
-    struct pf2_stack_key *ruby_stacks = NULL;
-    if (ruby_stack_count > 0) {
-        ruby_stacks = malloc(sizeof(struct pf2_stack_key) * ruby_stack_count);
-        kh_foreach(session->stack_table, k) {
-            size_t stack_id = kh_val(session->stack_table, k);
-            ruby_stacks[stack_id] = kh_key(session->stack_table, k);
-        }
-    }
+        // Copy and process Ruby stack frames
+        ser_sample->stack = malloc(sizeof(size_t) * sample->depth);
+        ser_sample->stack_count = sample->depth;
+        for (int j = 0; j < sample->depth; j++) {
+            VALUE frame = sample->cmes[j];
+            int32_t lineno = sample->linenos[j];
 
-    size_t native_stack_count = kh_size(session->native_stack_table);
-    struct pf2_native_stack_key *native_stacks = NULL;
-    if (native_stack_count > 0) {
-        native_stacks = malloc(sizeof(struct pf2_native_stack_key) * native_stack_count);
-        kh_foreach(session->native_stack_table, k) {
-            size_t stack_id = kh_val(session->native_stack_table, k);
-            native_stacks[stack_id] = kh_key(session->native_stack_table, k);
-        }
-    }
+            struct pf2_ser_function func = extract_function_from_ruby_frame(frame);
+            size_t function_index = function_index_for(serializer, &func);
+            size_t location_index = location_index_for(serializer, function_index, lineno);
 
-    // ---------------------------------------------------------------------
-    // Process aggregated sample_table entries into serializer samples
-    // ---------------------------------------------------------------------
-    size_t total_samples = 0;
-    kh_foreach(session->sample_table, k) {
-        total_samples += kh_val(session->sample_table, k).timestamps_count;
-    }
-    if (total_samples > serializer->samples_capacity) {
-        serializer->samples_capacity = total_samples;
-        serializer->samples = realloc(
-            serializer->samples,
-            serializer->samples_capacity * sizeof(struct pf2_ser_sample)
-        );
-    }
-
-    kh_foreach(session->sample_table, k) {
-        struct pf2_combined_stack_key ckey = kh_key(session->sample_table, k);
-        struct pf2_sample_stats *stats = &kh_val(session->sample_table, k);
-
-        const struct pf2_stack_key *ruby_stack = ruby_stacks ? &ruby_stacks[ckey.ruby_stack_id] : NULL;
-        const struct pf2_native_stack_key *native_stack = native_stacks ? &native_stacks[ckey.native_stack_id] : NULL;
-
-        for (size_t t = 0; t < stats->timestamps_count; t++) {
-            ensure_samples_capacity(serializer);
-            struct pf2_ser_sample *ser_sample = &serializer->samples[serializer->samples_count++];
-
-            ser_sample->ruby_thread_id = stats->thread_ids ? stats->thread_ids[t] : 0;
-            ser_sample->elapsed_ns = stats->timestamps[t] - serializer->start_timestamp_ns;
+            ser_sample->stack[j] = location_index;
+        }
 
-            // Ruby stack
-            if (ruby_stack && ruby_stack->depth > 0) {
-                ser_sample->stack = malloc(sizeof(size_t) * ruby_stack->depth);
-                ser_sample->stack_count = ruby_stack->depth;
-                for (size_t j = 0; j < ruby_stack->depth; j++) {
-                    // location ids map directly to indices in serializer->locations
-                    ser_sample->stack[j] = ruby_stack->frames[j];
-                }
-            } else {
-                ser_sample->stack = NULL;
-                ser_sample->stack_count = 0;
-            }
+        // Copy and process native stack frames, if any
+        if (sample->native_stack_depth > 0) {
+            ser_sample->native_stack = malloc(sizeof(size_t) * sample->native_stack_depth);
+            ser_sample->native_stack_count = sample->native_stack_depth;
 
-            // Native stack
-            if (native_stack && native_stack->depth > 0) {
-                ser_sample->native_stack = malloc(sizeof(size_t) * native_stack->depth);
-                ser_sample->native_stack_count = native_stack->depth;
+            for (size_t j = 0; j < sample->native_stack_depth; j++) {
+                struct pf2_ser_function func = extract_function_from_native_pc(sample->native_stack[j]);
+                size_t function_index = function_index_for(serializer, &func);
+                size_t location_index = location_index_for(serializer, function_index, 0);
 
-                for (size_t j = 0; j < native_stack->depth; j++) {
-                    struct pf2_ser_function func = extract_function_from_native_pc(native_stack->frames[j]);
-                    size_t function_index = function_index_for(serializer, &func);
-                    size_t location_index = location_index_for(serializer, function_index, 0);
-                    ser_sample->native_stack[j] = location_index;
-                }
-            } else {
-                ser_sample->native_stack = NULL;
-                ser_sample->native_stack_count = 0;
+                ser_sample->native_stack[j] = location_index;
             }
+        } else {
+            ser_sample->native_stack = NULL;
+            ser_sample->native_stack_count = 0;
         }
-    }
 
-    free(ruby_stacks);
-    free(native_stacks);
+    }
 }
 
 VALUE
@@ -208,8 +127,6 @@ pf2_ser_to_ruby_hash(struct pf2_ser *serializer) {
     // Add metadata
     rb_hash_aset(hash, ID2SYM(rb_intern("start_timestamp_ns")), ULL2NUM(serializer->start_timestamp_ns));
     rb_hash_aset(hash, ID2SYM(rb_intern("duration_ns")), ULL2NUM(serializer->duration_ns));
-    rb_hash_aset(hash, ID2SYM(rb_intern("collected_sample_count")), ULL2NUM(serializer->collected_sample_count));
-    rb_hash_aset(hash, ID2SYM(rb_intern("dropped_sample_count")), ULL2NUM(serializer->dropped_sample_count));
 
     // Add samples
     VALUE samples = rb_ary_new_capa(serializer->samples_count);
@@ -228,7 +145,7 @@ pf2_ser_to_ruby_hash(struct pf2_ser *serializer) {
         VALUE native_stack = rb_ary_new_capa(sample->native_stack_count);
         if (sample->native_stack != NULL) {
             for (size_t j = 0; j < sample->native_stack_count; j++) {
-                rb_ary_push(native_stack, SIZET2NUM(sample->native_stack[j]));
+                rb_ary_push(native_stack, ULL2NUM(sample->native_stack[j]));
             }
         }
         rb_hash_aset(sample_hash, ID2SYM(rb_intern("native_stack")), native_stack);
@@ -237,7 +154,7 @@ pf2_ser_to_ruby_hash(struct pf2_ser *serializer) {
         rb_hash_aset(
             sample_hash,
             ID2SYM(rb_intern("ruby_thread_id")),
-            ULL2NUM(sample->ruby_thread_id)
+            sample->ruby_thread_id ? SIZET2NUM(sample->ruby_thread_id) : Qnil
         );
         rb_hash_aset(sample_hash, ID2SYM(rb_intern("elapsed_ns")), ULL2NUM(sample->elapsed_ns));
 
@@ -387,7 +304,7 @@ pf2_backtrace_syminfo_callback(void *data, uintptr_t pc, const char *symname, ui
 
 // Returns the index of the function in `functions`.
 // Calling this method will modify `serializer->profile` in place.
-static size_t
+static int
 function_index_for(struct pf2_ser *serializer, struct pf2_ser_function *function) {
     for (size_t i = 0; i < serializer->functions_count; i++) {
         struct pf2_ser_function *existing = &serializer->functions[i];
@@ -415,8 +332,8 @@ function_index_for(struct pf2_ser *serializer, struct pf2_ser_function *function
 
 // Returns the index of the location in `locations`.
 // Calling this method will modify `self.profile` in place.
-static size_t
-location_index_for(struct pf2_ser *serializer, size_t function_index, int32_t lineno) {
+static int
+location_index_for(struct pf2_ser *serializer, int function_index, int32_t lineno) {
     for (size_t i = 0; i < serializer->locations_count; i++) {
         struct pf2_ser_location *existing = &serializer->locations[i];
         if (existing->function_index == function_index && existing->lineno == lineno) {