Reduce CallLogger tracing overhead by 8.4×

Rotoscope's CallLogger adds significant overhead when tracing method-call-heavy
code — users reported it doubling test execution time. This was primarily caused
by excessive Ruby↔C transitions, per-event memory allocations, and redundant
work in the hot path that fires for every traced method call.

Key changes:

**Move CSV formatting entirely to C** — The old Ruby log_call method made ~10
round trips to C per event (calling receiver_class_name, method_name, caller_path,
etc. individually). A new C function builds the entire CSV line without returning
to Ruby, then writes it into a shared buffer that flushes at 64KB.

**Native logger bypass** — CallLogger now registers its IO/excludelist directly on
the C struct via set_native_logger. The event_hook calls the C formatting function
directly, never entering Ruby for the CallLogger path.

**Stack-derived caller info** — Instead of calling rb_profile_frames (which walks
Ruby's internal stack) for every event, derive the caller's method name and
singleton status from our own internal stack. rb_profile_frames is now only called
for Ruby CALL events where we need the caller's file path and line number.

**Eliminate wasted work** — Skip the excludelist regex match when no exclusions are
configured (was calling rb_funcall 1.4M times for an empty pattern that never
matches). Cache class names in stack frames. Pre-allocate frozen string constants.

Before: 2,111ms overhead (59× ratio) on method-call-heavy workload
After:    250ms overhead (10× ratio)

A test suite that took 20s with tracing now takes ~11s.

41 tests, 59 assertions, 0 failures, 0 errors.
100% Ruby line coverage. No memory leaks (macOS leaks tool).
No use-after-free (Guard Malloc). No buffer overflows.

Author: phaselockedloop

.gitignore

@@ -6,3 +6,4 @@ lib/rotoscope/rotoscope.so
 .rubocop-*
 Gemfile.lock
 .bundle
+coverage/

Rakefile

@@ -50,4 +50,13 @@ task :rubocop do
   RuboCop::RakeTask.new
 end
 
+# ==========================================================
+# Benchmarking
+# ==========================================================
+
+desc "Run benchmarks (set BENCH_N for iterations, default 10000)"
+task bench: :build do
+  ruby "bench/benchmark.rb"
+end
+
 task(default: [:test, :rubocop])

ext/rotoscope/callsite.c

@@ -4,49 +4,37 @@
 #include <ruby/debug.h>
 #include <stdbool.h>
 
-static VALUE caller_frame(int *line, bool ruby_call) {
-  VALUE frames[2] = {Qnil, Qnil};
-  int lines[2] = {0, 0};
+static VALUE caller_frame(int *line) {
+  VALUE frame = Qnil;
+  int frame_line = 0;
 
-  // At this point, for ruby calls, the top ruby stack frame is
-  // for the method being called, so we want to skip that frame
-  // and get the caller location. This is why we use 1 for ruby
-  // calls.
-  //
-  // However, for C call, the top stack frame is for the caller,
-  // so we don't want to have to skip over any extra stack frames
-  // for C calls.
-  int frame_index = ruby_call ? 1 : 0;
+  // For ruby calls, the top frame is the callee — skip it to get the caller.
+  // Ruby 4.0+ fixed rb_profile_frames start argument (ruby-lang bug #14607).
+  rb_profile_frames(1, 1, &frame, &frame_line);
 
-  // There is currently a bug in rb_profile_frames that
-  // causes the start argument to effectively always
-  // act as if it were 0, so we need to also get the top
-  // frame. (https://bugs.ruby-lang.org/issues/14607)
-  rb_profile_frames(0, frame_index + 1, frames, lines);
-
-  *line = lines[frame_index];
-  return frames[frame_index];
+  *line = frame_line;
+  return frame;
 }
 
 rs_callsite_t c_callsite(rb_trace_arg_t *trace_arg) {
-  int line;
-  VALUE frame = caller_frame(&line, false);
   return (rs_callsite_t){
       .filepath = rb_tracearg_path(trace_arg),
       .lineno = FIX2INT(rb_tracearg_lineno(trace_arg)),
-      .method_name = rb_profile_frame_method_name(frame),
-      .singleton_p = rb_profile_frame_singleton_method_p(frame),
+      .method_name = Qnil,
+      .singleton_p = Qnil,
+      .profile_frame = Qnil,
   };
 }
 
 rs_callsite_t ruby_callsite() {
   int line;
-  VALUE frame = caller_frame(&line, true);
+  VALUE frame = caller_frame(&line);
 
   return (rs_callsite_t){
       .filepath = rb_profile_frame_path(frame),
       .lineno = line,
-      .method_name = rb_profile_frame_method_name(frame),
-      .singleton_p = rb_profile_frame_singleton_method_p(frame),
+      .method_name = Qnil,  // filled from stack or profile_frame in event_hook
+      .singleton_p = Qnil,
+      .profile_frame = frame,
   };
 }

ext/rotoscope/callsite.h

@@ -9,6 +9,7 @@ typedef struct {
   unsigned int lineno;
   VALUE method_name;
   VALUE singleton_p;
+  VALUE profile_frame;  // for lazy method_name/singleton_p extraction
 } rs_callsite_t;
 
 rs_callsite_t c_callsite(rb_trace_arg_t *trace_arg);

ext/rotoscope/method_desc.c

@@ -8,4 +8,5 @@ VALUE rs_method_class(rs_method_desc_t *method) {
 void rs_method_desc_mark(rs_method_desc_t *method) {
   rb_gc_mark(method->receiver);
   rb_gc_mark(method->id);
+  rb_gc_mark(method->class_name);
 }

ext/rotoscope/method_desc.h

@@ -7,6 +7,7 @@
 typedef struct rs_method_desc_t {
   VALUE receiver;
   VALUE id;
+  VALUE class_name;
   bool singleton_p;
 } rs_method_desc_t;