vernier 1.8.1 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4be5edc549ea93934096d98e46c4ffcabc140d06e27303f6ec6b01de8201983c
-  data.tar.gz: a6322324723a2f31f15a0b7e98a6de72bf5c555e29e21951b7f466466ecedd6f
+  metadata.gz: c3aa6d3665db78499efc979f38af3d3a4f633e105ccd3a6a17b9e11ad19556cf
+  data.tar.gz: eb752d610602a89417c894a360ea46f7727ce9a9bd11a13a2f608d35d07d4680
 SHA512:
-  metadata.gz: 92377006ae54cc5cc89934cc3c393fdfe02746035235b507196ef9d360b6d843c50db4382e0b53ec253f1d08f10f78e28d7daf10979f26187bb7c925933dec56
-  data.tar.gz: 0e963a838d3c319d93d73ae224c9e11caa51562583ef37f2d5fff40781281d30ee714273a9ce021c9e8285942825a3356388d2f68b51315fb5275c5bb96b49a6
+  metadata.gz: 3a96e0d3fa78b72e3a54c05eb871af65d405c32c44e0c0d8bc5efbeffaad59bb8490ab5c599e1a435d755093927c623e813965cda31a9bbeda43e3c2c41945cc
+  data.tar.gz: 32355e62e58124b426899dc4c167139521081d8be2bcf454aa3b0fb4916fb92334464a5685cccf5b712ee2d3d23a328a804b96b12a79e85e590f30d31d28fc66

data/.ruby-version

@@ -1 +1 @@
-3.4.6
+3.4.7

data/Gemfile

@@ -6,6 +6,7 @@ source "https://rubygems.org"
 gemspec
 
 gem "rake", "~> 13.0"
+gem "cgi"
 
 gem "rake-compiler"
 gem "benchmark-ips"

data/README.md

@@ -126,6 +126,71 @@ ruby -r vernier -e 'Vernier.trace_retained(out: "irb_profile.json") { require "i
 > [!NOTE]
 > Retained-memory flamegraphs must be interpreted a little differently than a typical profiling flamegraph. In a retained-memory flamegraph, the x-axis represents a proportion of memory in bytes,  _not time or samples_ The topmost boxes on the y-axis represent the retained objects, with their stacktrace below; their width represents the percentage of overall retained memory each object occupies.
 
+### Hooks
+
+Hooks automatically add markers to profiles based on application events:
+
+```ruby
+Vernier.profile(hooks: [:activesupport, MyHook]) do
+  # code to profile
+end
+```
+
+#### Built-in hooks
+
+- `:activesupport` (`:rails`) - ActiveSupport notifications
+- `:memory_usage` - Memory usage tracking
+
+#### Custom hooks
+
+Define a class with `initialize(collector)`, `enable`, and `disable` methods:
+
+```ruby
+class MyHook
+  def initialize(collector)
+    @collector = collector
+  end
+
+  def enable
+    # Set up event listeners
+  end
+
+  def disable
+    # Clean up
+  end
+end
+```
+
+For Firefox profiler integration, add `firefox_marker_schema` or `firefox_counters` methods (see [Firefox profiler docs](https://profiler.firefox.com/docs/#/) for format details):
+
+```ruby
+def firefox_marker_schema
+  [{
+    name: "my_event",
+    display: ["marker-chart", "marker-table"],
+    tooltipLabel: "{marker.data.name}",
+    data: [
+      { key: "name", format: "string" }
+    ]
+  }]
+end
+
+def firefox_counters
+  {
+    name: "my_counter",
+    category: "Custom",
+    description: "My custom counter",
+    samples: {
+      time: [0, 1000, 2000],
+      count: [10, 20, 30],
+      length: 3
+    }
+  }
+end
+```
+
+See [`examples/custom_hook.rb`](examples/custom_hook.rb) for a complete example.
+
 ### Options
 
 | Option                | Middleware Param              | Description                                                   | Default (Middleware Default) |

data/examples/custom_hook.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require "vernier"
+
+class CustomHook
+  def initialize(collector)
+    @collector = collector
+    @events = []
+  end
+
+  def enable
+    # Simulate subscribing to application events
+    @thread = Thread.new do
+      3.times do |i|
+        sleep 0.03
+        start_time = @collector.current_time
+        sleep 0.01 # Simulate work
+        @collector.add_marker(
+          name: "custom_event",
+          start: start_time,
+          finish: @collector.current_time,
+          data: { type: "custom_event", event_id: i + 1 }
+        )
+      end
+    end
+  end
+
+  def disable
+    @thread&.join
+  end
+end
+
+result = Vernier.profile(hooks: [CustomHook]) do
+  sleep 0.15
+end
+
+puts "Profile complete with custom events"

data/ext/vernier/heap_tracker.cc

@@ -0,0 +1,277 @@
+#include "vernier.hh"
+#include "stack_table.hh"
+
+static VALUE rb_cHeapTracker;
+
+static void heap_tracker_mark(void *data);
+static void heap_tracker_free(void *data);
+static size_t heap_tracker_memsize(const void *data);
+static void heap_tracker_compact(void *data);
+
+static const rb_data_type_t rb_heap_tracker_type = {
+    .wrap_struct_name = "vernier/heap_tracker",
+    .function = {
+        .dmark = heap_tracker_mark,
+        .dfree = heap_tracker_free,
+        .dsize = heap_tracker_memsize,
+        .dcompact = heap_tracker_compact,
+    },
+};
+
+class HeapTracker {
+  public:
+    VALUE stack_table_value;
+    StackTable *stack_table;
+
+    unsigned long long objects_freed = 0;
+    unsigned long long objects_allocated = 0;
+    unsigned long long tombstones = 0;
+
+    std::unordered_map<VALUE, int> object_index;
+    std::vector<VALUE> object_list;
+    std::vector<int> frame_list;
+
+    static VALUE rb_new(VALUE self, VALUE stack_table_value) {
+      HeapTracker *heap_tracker = new HeapTracker();
+      heap_tracker->stack_table_value = stack_table_value;
+      heap_tracker->stack_table = get_stack_table(stack_table_value);
+      VALUE obj = TypedData_Wrap_Struct(rb_cHeapTracker, &rb_heap_tracker_type, heap_tracker);
+      rb_ivar_set(obj, rb_intern("@stack_table"), stack_table_value);
+      return obj;
+    }
+
+    static HeapTracker *get(VALUE obj) {
+      HeapTracker *heap_tracker;
+      TypedData_Get_Struct(obj, HeapTracker, &rb_heap_tracker_type, heap_tracker);
+      return heap_tracker;
+    }
+
+    void record_newobj(VALUE obj) {
+      objects_allocated++;
+
+      RawSample sample;
+      sample.sample();
+      if (sample.empty()) {
+        // During thread allocation we allocate one object without a frame
+        // (as of Ruby 3.3)
+        // Ideally we'd allow empty samples to be represented
+        return;
+      }
+      int stack_index = stack_table->stack_index(sample);
+
+      int idx = object_list.size();
+      object_list.push_back(obj);
+      frame_list.push_back(stack_index);
+      object_index.emplace(obj, idx);
+
+      assert(objects_allocated == frame_list.size());
+      assert(objects_allocated == object_list.size());
+    }
+
+    void rebuild() {
+      object_index.clear();
+
+      size_t j = 0;
+      for (size_t i = 0; i < object_list.size(); i++) {
+        VALUE obj = object_list[i];
+        if (obj != Qfalse) {
+          object_list[j] = obj;
+          frame_list[j] = frame_list[i];
+          object_index.emplace(obj, j);
+          j++;
+        }
+      }
+
+      object_list.resize(j);
+      frame_list.resize(j);
+      tombstones = 0;
+    }
+
+    void record_freeobj(VALUE obj) {
+      auto it = object_index.find(obj);
+      if (it != object_index.end()) {
+        int index = it->second;
+        object_list[index] = Qfalse;
+        objects_freed++;
+        tombstones++;
+        object_index.erase(it);
+
+        if (tombstones * 2 > object_list.size()) {
+          rebuild();
+        }
+      }
+    }
+
+    static void newobj_i(VALUE tpval, void *data) {
+        HeapTracker *tracer = static_cast<HeapTracker *>(data);
+        rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+        VALUE obj = rb_tracearg_object(tparg);
+
+        tracer->record_newobj(obj);
+    }
+
+    static void freeobj_i(VALUE tpval, void *data) {
+        HeapTracker *tracer = static_cast<HeapTracker *>(data);
+        rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+        VALUE obj = rb_tracearg_object(tparg);
+
+        tracer->record_freeobj(obj);
+    }
+
+    bool stopped = false;
+    VALUE tp_newobj = Qnil;
+    VALUE tp_freeobj = Qnil;
+
+    void collect() {
+      if (!RTEST(tp_newobj)) {
+        tp_newobj = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, this);
+        tp_freeobj = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_FREEOBJ, freeobj_i, this);
+
+        rb_tracepoint_enable(tp_newobj);
+        rb_tracepoint_enable(tp_freeobj);
+      }
+    }
+    static VALUE collect(VALUE self) {
+      get(self)->collect();
+      return self;
+    }
+
+    void drain() {
+      if (RTEST(tp_newobj)) {
+        rb_tracepoint_disable(tp_newobj);
+        tp_newobj = Qnil;
+      }
+    }
+
+    static VALUE drain(VALUE self) {
+      get(self)->drain();
+      return self;
+    }
+
+    void lock() {
+      drain();
+      if (RTEST(tp_freeobj)) {
+        rb_tracepoint_disable(tp_freeobj);
+        tp_freeobj = Qnil;
+      }
+      stopped = true;
+    }
+
+    static VALUE lock(VALUE self) {
+      get(self)->lock();
+      return self;
+    }
+
+    static VALUE stack_idx(VALUE self, VALUE obj) {
+      auto tracer = get(self);
+      auto iter = tracer->object_index.find(obj);
+      if (iter == tracer->object_index.end()) {
+        return Qnil;
+      } else {
+        int index = iter->second;
+        return INT2NUM(tracer->frame_list[index]);
+      }
+    }
+
+    VALUE data() {
+      assert(stopped);
+      VALUE hash = rb_hash_new();
+      VALUE samples = rb_ary_new();
+      rb_hash_aset(hash, sym("samples"), samples);
+      VALUE weights = rb_ary_new();
+      rb_hash_aset(hash, sym("weights"), weights);
+
+      for (int i = 0; i < object_list.size(); i++) {
+        VALUE obj = object_list[i];
+        if (obj == Qfalse) continue;
+        VALUE stack_index = frame_list[i];
+
+        rb_ary_push(samples, INT2NUM(stack_index));
+        rb_ary_push(weights, INT2NUM(rb_obj_memsize_of(obj)));
+      }
+      return hash;
+    }
+
+    static VALUE data(VALUE self) {
+      return get(self)->data();
+    }
+
+    static VALUE allocated_objects(VALUE self) {
+      return ULL2NUM(get(self)->objects_allocated);
+    }
+
+    static VALUE freed_objects(VALUE self) {
+      return ULL2NUM(get(self)->objects_freed);
+    }
+
+    void mark() {
+      rb_gc_mark(stack_table_value);
+
+      rb_gc_mark(tp_newobj);
+      rb_gc_mark(tp_freeobj);
+
+      if (stopped) {
+        for (auto obj: object_list) {
+          rb_gc_mark_movable(obj);
+        }
+      }
+    }
+
+    void compact() {
+      object_index.clear();
+      for (int i = 0; i < object_list.size(); i++) {
+        VALUE obj = object_list[i];
+        VALUE reloc_obj = rb_gc_location(obj);
+
+        object_list[i] = reloc_obj;
+        object_index.emplace(reloc_obj, i);
+      }
+    }
+};
+
+static void
+heap_tracker_mark(void *data) {
+    HeapTracker *heap_tracker = static_cast<HeapTracker *>(data);
+    heap_tracker->mark();
+}
+
+static void
+heap_tracker_free(void *data) {
+    HeapTracker *heap_tracker = static_cast<HeapTracker *>(data);
+    delete heap_tracker;
+}
+
+static size_t
+heap_tracker_memsize(const void *data) {
+    const HeapTracker *heap_tracker = static_cast<const HeapTracker *>(data);
+    size_t size = sizeof(HeapTracker);
+
+    size += heap_tracker->object_index.bucket_count() * sizeof(void*);
+    size += heap_tracker->object_index.size() * (sizeof(VALUE) + sizeof(int) + sizeof(void*));
+
+    size += heap_tracker->object_list.capacity() * sizeof(VALUE);
+    size += heap_tracker->frame_list.capacity() * sizeof(int);
+
+    return size;
+}
+
+static void
+heap_tracker_compact(void *data) {
+    HeapTracker *heap_tracker = static_cast<HeapTracker *>(data);
+    heap_tracker->compact();
+}
+
+void
+Init_heap_tracker() {
+  rb_cHeapTracker = rb_define_class_under(rb_mVernier, "HeapTracker", rb_cObject);
+  rb_define_method(rb_cHeapTracker, "collect", HeapTracker::collect, 0);
+  rb_define_method(rb_cHeapTracker, "drain", HeapTracker::drain, 0);
+  rb_define_method(rb_cHeapTracker, "lock", HeapTracker::lock, 0);
+  rb_define_method(rb_cHeapTracker, "data", HeapTracker::data, 0);
+  rb_define_method(rb_cHeapTracker, "stack_idx", HeapTracker::stack_idx, 1);
+  rb_undef_alloc_func(rb_cHeapTracker);
+  rb_define_singleton_method(rb_cHeapTracker, "_new", HeapTracker::rb_new, 1);
+
+  rb_define_method(rb_cHeapTracker, "allocated_objects", HeapTracker::allocated_objects, 0);
+  rb_define_method(rb_cHeapTracker, "freed_objects", HeapTracker::freed_objects, 0);
+}

data/ext/vernier/memory.cc

@@ -85,9 +85,9 @@ class MemoryTracker : public PeriodicThread {
 static const rb_data_type_t rb_memory_tracker_type = {
     .wrap_struct_name = "vernier/memory_tracker",
     .function = {
-        //.dmemsize = memory_tracker_memsize,
         //.dmark = memory_tracker_mark,
         //.dfree = memory_tracker_free,
+        //.dsize = memory_tracker_memsize,
     },
 };