rperf 0.8.0 → 0.9.0

data/ext/rperf/rperf.c

@@ -25,8 +25,10 @@
 #ifdef __linux__
 #define RPERF_USE_TIMER_SIGNAL 1
 #define RPERF_TIMER_SIGNAL_DEFAULT (SIGRTMIN + 8)
+#define RPERF_COND_CLOCK CLOCK_MONOTONIC
 #else
 #define RPERF_USE_TIMER_SIGNAL 0
+#define RPERF_COND_CLOCK CLOCK_REALTIME  /* macOS lacks pthread_condattr_setclock */
 #endif
 
 #define RPERF_MAX_STACK_DEPTH 512
@@ -51,6 +53,11 @@ enum rperf_vm_state {
 /* ---- Data structures ---- */
 
 
+enum rperf_mode {
+    RPERF_MODE_CPU  = 0,
+    RPERF_MODE_WALL = 1,
+};
+
 enum rperf_gc_phase {
     RPERF_GC_NONE     = 0,
     RPERF_GC_MARKING  = 1,
@@ -83,7 +90,7 @@ typedef struct rperf_sample_buffer {
 
 typedef struct rperf_frame_table {
     _Atomic(VALUE *) keys;    /* unique VALUE array (GC mark target) */
-    size_t count;             /* = next frame_id */
+    _Atomic(size_t) count;    /* = next frame_id */
     size_t capacity;
     uint32_t *buckets;        /* open addressing: stores index into keys[] */
     size_t bucket_capacity;
@@ -119,7 +126,6 @@ typedef struct rperf_agg_table {
 
 typedef struct rperf_thread_data {
     int64_t prev_time_ns;
-    int64_t prev_wall_ns;
     /* GVL event tracking */
     int64_t suspended_at_ns;        /* wall time at SUSPENDED */
     int64_t ready_at_ns;            /* wall time at READY */
@@ -143,11 +149,12 @@ typedef struct rperf_stats {
     size_t sampling_count;
     int64_t sampling_total_ns;
     size_t dropped_samples;     /* samples lost due to allocation failure */
+    size_t dropped_aggregation; /* samples lost during aggregation (frame_table/agg_table full) */
 } rperf_stats_t;
 
 typedef struct rperf_profiler {
     int frequency;
-    int mode; /* 0 = cpu, 1 = wall */
+    enum rperf_mode mode;
     _Atomic int running;
     pthread_t worker_thread;     /* combined timer + aggregation */
 #if RPERF_USE_TIMER_SIGNAL
@@ -217,7 +224,7 @@ rperf_profiler_mark(void *ptr)
      * If we see an old count, both old and new keys arrays have valid
      * data (old keys are kept alive in old_keys[]). */
     {
-        size_t ft_count = __atomic_load_n(&prof->frame_table.count, __ATOMIC_ACQUIRE);
+        size_t ft_count = atomic_load_explicit(&prof->frame_table.count, memory_order_acquire);
         VALUE *ft_keys = atomic_load_explicit(&prof->frame_table.keys, memory_order_acquire);
         if (ft_keys && ft_count > 0) {
             rb_gc_mark_locations(ft_keys, ft_keys + ft_count);
@@ -225,12 +232,42 @@ rperf_profiler_mark(void *ptr)
     }
 }
 
+static size_t
+rperf_profiler_memsize(const void *ptr)
+{
+    const rperf_profiler_t *prof = (const rperf_profiler_t *)ptr;
+    size_t size = sizeof(rperf_profiler_t);
+    int i;
+
+    /* Double-buffered sample storage */
+    for (i = 0; i < 2; i++) {
+        const rperf_sample_buffer_t *buf = &prof->buffers[i];
+        size += buf->sample_capacity * sizeof(rperf_sample_t);
+        size += buf->frame_pool_capacity * sizeof(VALUE);
+    }
+
+    /* Frame table */
+    size += prof->frame_table.capacity * sizeof(VALUE);           /* keys */
+    size += prof->frame_table.bucket_capacity * sizeof(uint32_t); /* buckets */
+    for (i = 0; i < prof->frame_table.old_keys_count; i++) {
+        /* old_keys entries are previous keys arrays; exact sizes unknown,
+         * but the pointer array itself is accounted for below. */
+    }
+    size += prof->frame_table.old_keys_capacity * sizeof(VALUE *); /* old_keys */
+
+    /* Aggregation table */
+    size += prof->agg_table.bucket_capacity * sizeof(rperf_agg_entry_t);
+    size += prof->agg_table.stack_pool_capacity * sizeof(uint32_t);
+
+    return size;
+}
+
 static const rb_data_type_t rperf_profiler_type = {
     .wrap_struct_name = "rperf_profiler",
     .function = {
         .dmark = rperf_profiler_mark,
         .dfree = NULL,
-        .dsize = NULL,
+        .dsize = rperf_profiler_memsize,
     },
 };
 
@@ -259,7 +296,7 @@ rperf_wall_time_ns(void)
 static int64_t
 rperf_current_time_ns(rperf_profiler_t *prof)
 {
-    if (prof->mode == 0) {
+    if (prof->mode == RPERF_MODE_CPU) {
         return rperf_cpu_time_ns();
     } else {
         return rperf_wall_time_ns();
@@ -300,7 +337,7 @@ static int
 rperf_ensure_sample_capacity(rperf_sample_buffer_t *buf)
 {
     if (buf->sample_count >= buf->sample_capacity) {
-        if (buf->sample_capacity > SIZE_MAX / 2) return -1;
+        if (buf->sample_capacity > SIZE_MAX / (2 * sizeof(rperf_sample_t))) return -1;
         size_t new_cap = buf->sample_capacity * 2;
         rperf_sample_t *new_samples = (rperf_sample_t *)realloc(
             buf->samples,
@@ -319,7 +356,7 @@ static int
 rperf_ensure_frame_pool_capacity(rperf_sample_buffer_t *buf, int needed)
 {
     while (buf->frame_pool_count + (size_t)needed > buf->frame_pool_capacity) {
-        if (buf->frame_pool_capacity > SIZE_MAX / 2) return -1;
+        if (buf->frame_pool_capacity > SIZE_MAX / (2 * sizeof(VALUE))) return -1;
         size_t new_cap = buf->frame_pool_capacity * 2;
         VALUE *new_pool = (VALUE *)realloc(
             buf->frame_pool,
@@ -438,7 +475,7 @@ rperf_frame_table_insert(rperf_frame_table_t *ft, VALUE fval)
     keys[frame_id] = fval;
     /* Store fence: ensure keys[frame_id] is visible before count is incremented,
      * so GC dmark never reads uninitialized keys[count-1]. */
-    __atomic_store_n(&ft->count, ft->count + 1, __ATOMIC_RELEASE);
+    atomic_store_explicit(&ft->count, ft->count + 1, memory_order_release);
     ft->buckets[idx] = frame_id;
 
     /* Rehash if load factor > 0.7 */
@@ -494,7 +531,7 @@ rperf_agg_table_free(rperf_agg_table_t *at)
 static void
 rperf_agg_table_rehash(rperf_agg_table_t *at)
 {
-    if (at->bucket_capacity > SIZE_MAX / 2) return;
+    if (at->bucket_capacity > SIZE_MAX / (2 * sizeof(rperf_agg_entry_t))) return;
     size_t new_cap = at->bucket_capacity * 2;
     rperf_agg_entry_t *new_buckets = (rperf_agg_entry_t *)calloc(new_cap, sizeof(rperf_agg_entry_t));
     if (!new_buckets) return; /* keep using current buckets at higher load factor */
@@ -519,7 +556,7 @@ static int
 rperf_agg_ensure_stack_pool(rperf_agg_table_t *at, int needed)
 {
     while (at->stack_pool_count + (size_t)needed > at->stack_pool_capacity) {
-        if (at->stack_pool_capacity > SIZE_MAX / 2) return -1;
+        if (at->stack_pool_capacity > SIZE_MAX / (2 * sizeof(uint32_t))) return -1;
         size_t new_cap = at->stack_pool_capacity * 2;
         uint32_t *new_pool = (uint32_t *)realloc(at->stack_pool,
                                                   new_cap * sizeof(uint32_t));
@@ -530,8 +567,9 @@ rperf_agg_ensure_stack_pool(rperf_agg_table_t *at, int needed)
     return 0;
 }
 
-/* Insert or merge a stack into the aggregation table */
-static void
+/* Insert or merge a stack into the aggregation table.
+ * Returns 0 on success, -1 on failure (table full or allocation failure). */
+static int
 rperf_agg_table_insert(rperf_agg_table_t *at, const uint32_t *frame_ids,
                        int depth, int thread_seq, int label_set_id,
                        enum rperf_vm_state vm_state, int64_t weight, uint32_t hash)
@@ -548,14 +586,14 @@ rperf_agg_table_insert(rperf_agg_table_t *at, const uint32_t *frame_ids,
                    depth * sizeof(uint32_t)) == 0) {
             /* Match — merge weight */
             e->weight += weight;
-            return;
+            return 0;
         }
         idx = (idx + 1) % at->bucket_capacity;
-        if (++probes >= at->bucket_capacity) return; /* table full, drop sample */
+        if (++probes >= at->bucket_capacity) return -1; /* table full */
     }
 
     /* New entry — append frame_ids to stack_pool */
-    if (rperf_agg_ensure_stack_pool(at, depth) < 0) return;
+    if (rperf_agg_ensure_stack_pool(at, depth) < 0) return -1;
 
     rperf_agg_entry_t *e = &at->buckets[idx];
     e->frame_start = (uint32_t)at->stack_pool_count;
@@ -576,6 +614,7 @@ rperf_agg_table_insert(rperf_agg_table_t *at, const uint32_t *frame_ids,
     if (at->count * 10 > at->bucket_capacity * 7) {
         rperf_agg_table_rehash(at);
     }
+    return 0;
 }
 
 /* ---- Aggregation: process a sample buffer into frame_table + agg_table ---- */
@@ -598,25 +637,32 @@ rperf_aggregate_buffer(rperf_profiler_t *prof, rperf_sample_buffer_t *buf)
         /* Convert VALUE frames to frame_ids */
         int overflow = 0;
         for (j = 0; j < s->depth; j++) {
+            if (s->frame_start + j >= buf->frame_pool_count) break;
             VALUE fval = buf->frame_pool[s->frame_start + j];
             uint32_t fid = rperf_frame_table_insert(&prof->frame_table, fval);
             if (fid == RPERF_FRAME_TABLE_EMPTY) { overflow = 1; break; }
             temp_ids[j] = fid;
         }
-        if (overflow) break; /* frame_table full, stop aggregating this buffer */
+        if (overflow) {
+            /* frame_table full — count remaining samples as dropped */
+            prof->stats.dropped_aggregation += buf->sample_count - i;
+            break;
+        }
 
         hash = rperf_fnv1a_u32(temp_ids, s->depth, s->thread_seq, s->label_set_id, s->vm_state);
 
-        rperf_agg_table_insert(&prof->agg_table, temp_ids, s->depth,
+        if (rperf_agg_table_insert(&prof->agg_table, temp_ids, s->depth,
                                s->thread_seq, s->label_set_id, s->vm_state,
-                               s->weight, hash);
+                               s->weight, hash) < 0) {
+            prof->stats.dropped_aggregation++;
+        }
     }
 
     /* Reset buffer for reuse.
      * Release fence: ensure all frame_table inserts are visible (to GC dmark)
      * before frame_pool_count is cleared, so dmark always has at least one
      * source (frame_table or frame_pool) covering each VALUE. */
-    __atomic_thread_fence(__ATOMIC_RELEASE);
+    atomic_thread_fence(memory_order_release);
     buf->sample_count = 0;
     buf->frame_pool_count = 0;
 }
@@ -693,8 +739,9 @@ rperf_thread_data_create(rperf_profiler_t *prof, VALUE thread)
 {
     rperf_thread_data_t *td = (rperf_thread_data_t *)calloc(1, sizeof(rperf_thread_data_t));
     if (!td) return NULL;
-    td->prev_time_ns = rperf_current_time_ns(prof);
-    td->prev_wall_ns = rperf_wall_time_ns();
+    int64_t t = rperf_current_time_ns(prof);
+    if (t < 0) { free(td); return NULL; }
+    td->prev_time_ns = t;
     td->thread_seq = ++prof->next_thread_seq;
     rb_internal_thread_specific_set(thread, prof->ts_key, td);
     return td;
@@ -737,7 +784,6 @@ rperf_handle_suspended(rperf_profiler_t *prof, VALUE thread, rperf_thread_data_t
     /* Save timestamp for READY/RESUMED */
     td->suspended_at_ns = wall_now;
     td->prev_time_ns = time_now;
-    td->prev_wall_ns = wall_now;
 }
 
 static void
@@ -768,7 +814,7 @@ rperf_handle_resumed(rperf_profiler_t *prof, VALUE thread, rperf_thread_data_t *
      * Both samples are written directly into the same buffer before calling
      * rperf_try_swap, so that a swap triggered by the first sample cannot
      * move the second into a different buffer with a stale frame_start. */
-    if (prof->mode == 1 && td->suspended_at_ns > 0 && !RPERF_PAUSED(prof)) {
+    if (prof->mode == RPERF_MODE_WALL && td->suspended_at_ns > 0 && !RPERF_PAUSED(prof)) {
         rperf_sample_buffer_t *buf = &prof->buffers[atomic_load_explicit(&prof->active_idx, memory_order_relaxed)];
         if (rperf_ensure_frame_pool_capacity(buf, RPERF_MAX_STACK_DEPTH) < 0) goto skip_gvl;
         size_t frame_start = buf->frame_pool_count;
@@ -798,7 +844,6 @@ skip_gvl:
     /* Reset prev times to current — next timer sample measures from resume */
     int64_t time_now = rperf_current_time_ns(prof);
     if (time_now >= 0) td->prev_time_ns = time_now;
-    td->prev_wall_ns = wall_now;
 
     /* Clear suspended state */
     td->suspended_at_ns = 0;
@@ -895,17 +940,15 @@ rperf_gc_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID id, VALUE
 
 /* ---- Sampling callback (postponed job) — current thread only ---- */
 
-static void
-rperf_sample_job(void *arg)
+/* Core sampling logic, parameterized by mode constant.
+ * Called from rperf_sample_cpu/rperf_sample_wall so the compiler
+ * can inline and eliminate mode branches at compile time. */
+static inline void
+rperf_sample_core(rperf_profiler_t *prof, enum rperf_mode mode)
 {
-    rperf_profiler_t *prof = (rperf_profiler_t *)arg;
-
-    if (!prof->running) return;
-    if (RPERF_PAUSED(prof)) return;
-
-    /* Measure sampling overhead */
+    /* Measure sampling overhead (wall time — runs under GVL, no I/O) */
     struct timespec ts_start, ts_end;
-    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_start);
+    clock_gettime(CLOCK_MONOTONIC, &ts_start);
 
     VALUE thread = rb_thread_current();
 
@@ -917,12 +960,11 @@ rperf_sample_job(void *arg)
         return; /* Skip first sample for this thread */
     }
 
-    int64_t time_now = rperf_current_time_ns(prof);
+    int64_t time_now = (mode == RPERF_MODE_CPU) ? rperf_cpu_time_ns() : rperf_wall_time_ns();
     if (time_now < 0) return;
 
     int64_t weight = time_now - td->prev_time_ns;
     td->prev_time_ns = time_now;
-    td->prev_wall_ns = rperf_wall_time_ns();
 
     if (weight <= 0) return;
 
@@ -938,13 +980,33 @@ rperf_sample_job(void *arg)
 
     rperf_record_sample(prof, frame_start, depth, weight, RPERF_VM_STATE_NORMAL, td->thread_seq, td->label_set_id);
 
-    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts_end);
+    clock_gettime(CLOCK_MONOTONIC, &ts_end);
     prof->stats.sampling_count++;
     prof->stats.sampling_total_ns +=
         ((int64_t)ts_end.tv_sec - ts_start.tv_sec) * 1000000000LL +
         (ts_end.tv_nsec - ts_start.tv_nsec);
 }
 
+static void
+rperf_sample_cpu(rperf_profiler_t *prof) { rperf_sample_core(prof, RPERF_MODE_CPU); }
+
+static void
+rperf_sample_wall(rperf_profiler_t *prof) { rperf_sample_core(prof, RPERF_MODE_WALL); }
+
+static void
+rperf_sample_job(void *arg)
+{
+    rperf_profiler_t *prof = (rperf_profiler_t *)arg;
+
+    if (!prof->running) return;
+    if (RPERF_PAUSED(prof)) return;
+
+    if (prof->mode == RPERF_MODE_CPU)
+        rperf_sample_cpu(prof);
+    else
+        rperf_sample_wall(prof);
+}
+
 /* ---- Worker thread: timer + aggregation ---- */
 
 #if RPERF_USE_TIMER_SIGNAL
@@ -990,7 +1052,7 @@ rperf_worker_nanosleep_func(void *arg)
     struct timespec deadline;
     long interval_ns = 1000000000L / prof->frequency;
 
-    clock_gettime(CLOCK_REALTIME, &deadline);
+    clock_gettime(RPERF_COND_CLOCK, &deadline);
     deadline.tv_nsec += interval_ns;
     if (deadline.tv_nsec >= 1000000000L) {
         deadline.tv_sec++;
@@ -1005,7 +1067,7 @@ rperf_worker_nanosleep_func(void *arg)
             CHECKED(pthread_cond_wait(&prof->worker_cond, &prof->worker_mutex));
             prof->worker_paused = 0;
             /* Reset deadline on wake to avoid burst of catch-up triggers */
-            clock_gettime(CLOCK_REALTIME, &deadline);
+            clock_gettime(RPERF_COND_CLOCK, &deadline);
             deadline.tv_nsec += interval_ns;
             if (deadline.tv_nsec >= 1000000000L) {
                 deadline.tv_sec++;
@@ -1076,13 +1138,15 @@ rperf_build_aggregated_result(rperf_profiler_t *prof)
     result = rb_hash_new();
 
     rb_hash_aset(result, ID2SYM(rb_intern("mode")),
-                 ID2SYM(rb_intern(prof->mode == 1 ? "wall" : "cpu")));
+                 ID2SYM(rb_intern(prof->mode == RPERF_MODE_WALL ? "wall" : "cpu")));
     rb_hash_aset(result, ID2SYM(rb_intern("frequency")), INT2NUM(prof->frequency));
     rb_hash_aset(result, ID2SYM(rb_intern("trigger_count")), SIZET2NUM(prof->stats.trigger_count));
     rb_hash_aset(result, ID2SYM(rb_intern("sampling_count")), SIZET2NUM(prof->stats.sampling_count));
     rb_hash_aset(result, ID2SYM(rb_intern("sampling_time_ns")), LONG2NUM(prof->stats.sampling_total_ns));
     if (prof->stats.dropped_samples > 0)
         rb_hash_aset(result, ID2SYM(rb_intern("dropped_samples")), SIZET2NUM(prof->stats.dropped_samples));
+    if (prof->stats.dropped_aggregation > 0)
+        rb_hash_aset(result, ID2SYM(rb_intern("dropped_aggregation")), SIZET2NUM(prof->stats.dropped_aggregation));
     rb_hash_aset(result, ID2SYM(rb_intern("detected_thread_count")), INT2NUM(prof->next_thread_seq));
     rb_hash_aset(result, ID2SYM(rb_intern("unique_frames")),
                  SIZET2NUM(prof->frame_table.count));
@@ -1154,7 +1218,7 @@ static VALUE
 rb_rperf_start(VALUE self, VALUE vfreq, VALUE vmode, VALUE vagg, VALUE vsig, VALUE vdefer)
 {
     int frequency = NUM2INT(vfreq);
-    int mode = NUM2INT(vmode);
+    enum rperf_mode mode = (enum rperf_mode)NUM2INT(vmode);
     int aggregate = RTEST(vagg) ? 1 : 0;
 #if RPERF_USE_TIMER_SIGNAL
     int sig = NUM2INT(vsig);
@@ -1173,13 +1237,26 @@ rb_rperf_start(VALUE self, VALUE vfreq, VALUE vmode, VALUE vagg, VALUE vsig, VAL
     g_profiler.stats.sampling_total_ns = 0;
     g_profiler.stats.trigger_count = 0;
     g_profiler.stats.dropped_samples = 0;
+    g_profiler.stats.dropped_aggregation = 0;
     atomic_store_explicit(&g_profiler.active_idx, 0, memory_order_relaxed);
     atomic_store_explicit(&g_profiler.swap_ready, 0, memory_order_relaxed);
     g_profiler.label_sets = Qnil;
 
     /* Initialize worker mutex/cond */
     CHECKED(pthread_mutex_init(&g_profiler.worker_mutex, NULL));
+#ifdef __linux__
+    {
+        /* Use CLOCK_MONOTONIC for pthread_cond_timedwait so that
+         * system clock adjustments (NTP etc.) don't affect timer intervals. */
+        pthread_condattr_t cond_attr;
+        CHECKED(pthread_condattr_init(&cond_attr));
+        CHECKED(pthread_condattr_setclock(&cond_attr, CLOCK_MONOTONIC));
+        CHECKED(pthread_cond_init(&g_profiler.worker_cond, &cond_attr));
+        CHECKED(pthread_condattr_destroy(&cond_attr));
+    }
+#else
     CHECKED(pthread_cond_init(&g_profiler.worker_cond, NULL));
+#endif
 
     /* Initialize sample buffer(s) */
     if (rperf_sample_buffer_init(&g_profiler.buffers[0]) < 0) {
@@ -1436,13 +1513,15 @@ rb_rperf_stop(VALUE self)
 
         result = rb_hash_new();
         rb_hash_aset(result, ID2SYM(rb_intern("mode")),
-                     ID2SYM(rb_intern(g_profiler.mode == 1 ? "wall" : "cpu")));
+                     ID2SYM(rb_intern(g_profiler.mode == RPERF_MODE_WALL ? "wall" : "cpu")));
         rb_hash_aset(result, ID2SYM(rb_intern("frequency")), INT2NUM(g_profiler.frequency));
         rb_hash_aset(result, ID2SYM(rb_intern("trigger_count")), SIZET2NUM(g_profiler.stats.trigger_count));
         rb_hash_aset(result, ID2SYM(rb_intern("sampling_count")), SIZET2NUM(g_profiler.stats.sampling_count));
         rb_hash_aset(result, ID2SYM(rb_intern("sampling_time_ns")), LONG2NUM(g_profiler.stats.sampling_total_ns));
         if (g_profiler.stats.dropped_samples > 0)
             rb_hash_aset(result, ID2SYM(rb_intern("dropped_samples")), SIZET2NUM(g_profiler.stats.dropped_samples));
+        if (g_profiler.stats.dropped_aggregation > 0)
+            rb_hash_aset(result, ID2SYM(rb_intern("dropped_aggregation")), SIZET2NUM(g_profiler.stats.dropped_aggregation));
         rb_hash_aset(result, ID2SYM(rb_intern("detected_thread_count")), INT2NUM(g_profiler.next_thread_seq));
         {
             struct timespec stop_monotonic;
@@ -1508,6 +1587,7 @@ rperf_clear_aggregated_data(rperf_profiler_t *prof)
     prof->stats.sampling_count = 0;
     prof->stats.sampling_total_ns = 0;
     prof->stats.dropped_samples = 0;
+    prof->stats.dropped_aggregation = 0;
 
     /* Reset start timestamps so next snapshot's duration_ns covers
      * only the period since this clear. */
@@ -1652,7 +1732,6 @@ rperf_reset_thread_times(rperf_profiler_t *prof)
         rperf_thread_data_t *td = (rperf_thread_data_t *)rb_internal_thread_specific_get(thread, prof->ts_key);
         if (td) {
             td->prev_time_ns = rperf_current_time_ns(prof);
-            td->prev_wall_ns = rperf_wall_time_ns();
         }
     }
 }
@@ -1692,6 +1771,12 @@ rb_rperf_running_p(VALUE self)
     return g_profiler.running ? Qtrue : Qfalse;
 }
 
+static VALUE
+rb_rperf_profiler_wrapper(VALUE self)
+{
+    return g_profiler_wrapper;
+}
+
 /* ---- Fork safety ---- */
 
 static void
@@ -1771,6 +1856,7 @@ Init_rperf(void)
     rb_define_module_function(mRperf, "_c_profile_inc", rb_rperf_profile_inc, 0);
     rb_define_module_function(mRperf, "_c_profile_dec", rb_rperf_profile_dec, 0);
     rb_define_module_function(mRperf, "_c_running?", rb_rperf_running_p, 0);
+    rb_define_module_function(mRperf, "_c_profiler_wrapper", rb_rperf_profiler_wrapper, 0);
 
     memset(&g_profiler, 0, sizeof(g_profiler));
     g_profiler.label_sets = Qnil;

data/lib/rperf/active_job.rb

@@ -1,4 +1,5 @@
 require "rperf"
+require "active_support/concern"
 
 module Rperf::ActiveJobMiddleware
   extend ActiveSupport::Concern

data/lib/rperf/version.rb

@@ -1,3 +1,3 @@
 module Rperf
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

data/lib/rperf/viewer.rb

@@ -3,6 +3,11 @@ require "json"
 
 # Rack middleware that serves flamegraph visualizations of rperf snapshots.
 #
+# *Security note*: This middleware exposes profiling data without
+# authentication. It is intended for development and staging environments.
+# In production, place it behind an authenticated reverse proxy or restrict
+# access by IP / VPN.
+#
 # Usage:
 #   require "rperf/viewer"
 #   use Rperf::Viewer                             # mount at /rperf (default)
@@ -25,6 +30,7 @@ class Rperf::Viewer
   attr_reader :max_snapshots, :path
 
   def initialize(app, path: "/rperf", max_snapshots: 24)
+    raise ArgumentError, "max_snapshots must be a positive integer, got #{max_snapshots.inspect}" unless max_snapshots.is_a?(Integer) && max_snapshots > 0
     @app = app
     @path = path.chomp("/")
     @max_snapshots = max_snapshots
@@ -81,6 +87,63 @@ class Rperf::Viewer
     end
   end
 
+  # Convert aggregated samples to JSON-friendly format.
+  # Stack is stored top-to-bottom (leaf first) in C; reverse to root-first for flamegraph.
+  # Label set keys are converted from symbols to strings for JSON.
+  def self.samples_to_json(samples, label_sets)
+    json_samples = samples.map do |frames, weight, thread_seq, label_set_id|
+      {
+        stack: frames.reverse.map { |_, label| label },
+        weight: weight,
+        thread_seq: thread_seq || 0,
+        label_set_id: label_set_id || 0,
+      }
+    end
+    json_label_sets = label_sets.map do |ls|
+      ls.is_a?(Hash) ? ls.transform_keys(&:to_s) : ls
+    end
+    [json_samples, json_label_sets]
+  end
+
+  # Generate a self-contained static HTML file with inline snapshot data.
+  # The HTML loads d3/d3-flamegraph from CDN but requires no server.
+  def self.render_static_html(data)
+    samples = data[:aggregated_samples] || []
+    label_sets = data[:label_sets] || []
+    json_samples, json_label_sets = samples_to_json(samples, label_sets)
+
+    json_snapshot = JSON.generate({
+      id: 1,
+      taken_at: Time.now.iso8601,
+      mode: data[:mode],
+      frequency: data[:frequency],
+      duration_ns: data[:duration_ns],
+      sampling_count: data[:sampling_count],
+      samples: json_samples,
+      label_sets: json_label_sets,
+    })
+
+    logo = LOGO_SVG.sub("<svg ", '<svg style="height:36px;width:auto" ')
+
+    html = VIEWER_HTML.sub("<!-- LOGO -->") { logo }
+
+    # Hide snapshot selector (single snapshot, no server)
+    html = html.sub('<select id="sel-snapshot"', '<select id="sel-snapshot" style="display:none"')
+
+    # Replace dynamic loading with inline data.
+    # Escape for safe embedding in <script>:
+    #  - "</" prevents closing </script> tag injection
+    #  - U+2028/U+2029 are line terminators in JS but valid in JSON
+    json_safe = json_snapshot
+      .gsub("</", "<\\/")
+      .gsub("\u2028", "\\u2028")
+      .gsub("\u2029", "\\u2029")
+    html = html.sub("loadSnapshotList();",
+      "currentData = #{json_safe}; updateTagDropdowns(); applyAndRender();")
+
+    html
+  end
+
   private
 
   LOGO_SVG = begin
@@ -119,24 +182,9 @@ class Rperf::Viewer
     return [404, { "content-type" => "text/plain" }, ["Snapshot not found"]] unless entry
 
     data = entry[:data]
-    samples = data[:aggregated_samples]
+    samples = data[:aggregated_samples] || []
     label_sets = data[:label_sets] || []
-
-    # Convert samples to JSON-friendly format.
-    # Stack is stored top-to-bottom (leaf first) in C; reverse to root-first for flamegraph.
-    json_samples = samples.map do |frames, weight, thread_seq, label_set_id|
-      {
-        stack: frames.reverse.map { |_, label| label },
-        weight: weight,
-        thread_seq: thread_seq || 0,
-        label_set_id: label_set_id || 0,
-      }
-    end
-
-    # Convert label_sets: symbol keys to string keys for JSON
-    json_label_sets = label_sets.map do |ls|
-      ls.is_a?(Hash) ? ls.transform_keys(&:to_s) : ls
-    end
+    json_samples, json_label_sets = self.class.samples_to_json(samples, label_sets)
 
     json_response({
       id: entry[:id],
@@ -162,6 +210,7 @@ class Rperf::Viewer
 <html lang="en">
 <head>
 <meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline' https://cdnjs.cloudflare.com https://cdn.jsdelivr.net; style-src 'unsafe-inline' https://cdn.jsdelivr.net; connect-src 'self'; img-src data:; frame-ancestors 'none'">
 <title>rperf Viewer</title>
 <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/d3-flame-graph@4/dist/d3-flamegraph.css" integrity="sha384-DgAQSBzzhv8bu6Qc6Lq08THluOr+kO5qLMHt1yv8A3my7Jz2OQv6aq/WSZRYIQkG" crossorigin="anonymous">
 <style>