vernier 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f552d6fe2d529de743412cbc9975bfbd4ac87b894777a44ce26ef07dddc8e032
-  data.tar.gz: b9ddcd3e4ce0acb5ac53363e041d1bd9e3a2d4c5bf21b2bbe56c48ed5fef4cdd
+  metadata.gz: b9ba6d060b4eb230a865df67f378f81b08721d36a9f8cf394f9a8d5d0455b844
+  data.tar.gz: d01c209f5fab9bc99940fb5b967a722f69c75376dd6aba0c3e7759a9c52bc698
 SHA512:
-  metadata.gz: 1b0808ee6ae8e64866e81e7ba8ed4847788421a00517c00e7aacb54c2fdff16287f92eb10132b5802fcb93955c3e4cf1a8fe4cfc97f4a9742a8130341bea75f7
-  data.tar.gz: 686a7397043be44451cccf9380473cda1e350ee342878ca2428d8bcd6c69aeea36244d15c92e3f998d4b6245c46c37d74ac3aac18ed58c783c288501d0cf7243
+  metadata.gz: 65e359b25b1cc5a5e3dc2724ec7c98eb4f20203a98e0fd8f402b5875fe329afb6a20f6fc722f8da2febdd4cd30e8e2d56a00e42a4e5262baffb7a250fba79f3d
+  data.tar.gz: bf9ca5416e6b7b17d316eb9c762273ab711518c7ba50c862f803eed9e2d17fcbdeee378f9d6702d4029715926d105398105c5eb0f6aec046fa540611993ec89a

data/README.md

@@ -2,6 +2,8 @@
 
 Next-generation Ruby 3.2.1+ sampling profiler. Tracks multiple threads, GVL activity, GC pauses, idle time, and more.
 
+<img width="500" alt="Screenshot 2024-02-29 at 22 47 43" src="https://github.com/jhawthorn/vernier/assets/131752/aa995a41-d74f-405f-8ada-2522dd72c2c8">
+
 ## Examples
 
 [Livestreamed demo: Pairin' with Aaron (YouTube)](https://www.youtube.com/watch?v=9nvX3OHykGQ#t=27m43)
@@ -35,7 +37,7 @@ gem 'vernier'
 Vernier.trace(out: "time_profile.json") { some_slow_method }
 ```
 
-The output can then be viewed in the Firefox Profiler (demo) or the [`profile-viewer` gem](https://github.com/tenderlove/profiler/tree/ruby) (a Ruby-customized version of the firefox profiler.
+The output can be viewed in the web app at https://vernier.prof or locally using the [`profile-viewer` gem](https://github.com/tenderlove/profiler/tree/ruby) (both are lightly customized versions of the firefox profiler frontend, which profiles are also compatible with).
 
 - **Flame Graph**: Shows proportionally how much time is spent within particular stack frames. Frames are grouped together, which means that x-axis / left-to-right order is not meaningful.
 - **Stack Chart**: Shows the stack at each sample with the x-axis representing time and can be read left-to-right.

data/examples/rails.rb

@@ -59,12 +59,17 @@ end
 
 silence do
   ActiveRecord::Schema.define do
+    create_table :users, force: true do |t|
+      t.string :login
+    end
     create_table :posts, force: true do |t|
+      t.belongs_to :user
       t.string :title
       t.text :body
       t.integer :likes
     end
     create_table :comments, force: true do |t|
+      t.belongs_to :user
       t.belongs_to :post
       t.string :title
       t.text :body
@@ -73,25 +78,33 @@ silence do
   end
 end
 
+class User < ActiveRecord::Base
+end
+
 class Post < ActiveRecord::Base
   has_many :comments
+  belongs_to :user
 end
 
 class Comment < ActiveRecord::Base
   belongs_to :post
+  belongs_to :user
 end
 
+users = 0.upto(100).map do |i|
+  User.create!(login: "user#{i}")
+end
 0.upto(100) do |i|
-  post = Post.create!(title: "Post number #{i}", body: "blog " * 50, likes: ((i * 1337) % 30))
+  post = Post.create!(title: "Post number #{i}", body: "blog " * 50, likes: ((i * 1337) % 30), user: users.sample)
   5.times do
-    post.comments.create!(post: post, title: "nice post!", body: "keep it up!", posted_at: Time.now)
+    post.comments.create!(post: post, title: "nice post!", body: "keep it up!", posted_at: Time.now, user: users.sample)
   end
 end
 
 class HomeController < ActionController::Base
   def show
-    posts = Post.order(likes: :desc).includes(:comments).first(10)
-    render json: posts
+    posts = Post.order(likes: :desc).includes(:user, comments: :user).first(10)
+    render json: posts, include: [:user, comments: { include: :user } ]
   end
 end
 
@@ -110,15 +123,7 @@ end
 # warm up
 make_request.call
 
-Vernier.trace(out: "rails.json") do |collector|
-  ActiveSupport::Notifications.monotonic_subscribe do |name, start, finish, id, payload|
-    collector.add_marker(
-      name:,
-      start: (start * 1_000_000_000).to_i,
-      finish: (finish * 1_000_000_000).to_i,
-    )
-  end
-
+Vernier.trace(out: "rails.json", hooks: [:rails], allocation_sample_rate: 100) do |collector|
   1000.times do
     make_request.call
   end

data/examples/threaded_http_requests.rb

@@ -1,6 +1,6 @@
 require "vernier"
 
-Vernier.trace(out: "http_requests.json") do
+Vernier.trace(out: "http_requests.json", allocation_sample_rate: 100) do
 
 require "net/http"
 require "uri"

data/exe/vernier

@@ -16,6 +16,9 @@ parser = OptionParser.new(banner) do |o|
   o.on('--interval [MICROSECONDS]', Integer, "sampling interval (default 500)") do |i|
     options[:interval] = i
   end
+  o.on('--allocation_sample_rate [ALLOCATIONS]', Integer, "allocation sampling interval (default 0 disabled)") do |i|
+    options[:allocation_sample_rate] = i
+  end
   o.on('--signal [NAME]', String, "specify a signal to start and stop the profiler") do |s|
     options[:signal] = s
   end

data/ext/vernier/vernier.cc

@@ -331,7 +331,7 @@ struct RawSample {
 
     Frame frame(int i) const {
         int idx = len - i - 1;
-        if (idx < 0) throw std::out_of_range("out of range");
+        if (idx < 0) throw std::out_of_range("VERNIER BUG: index out of range");
         const Frame frame = {frames[idx], lines[idx]};
         return frame;
     }
@@ -446,7 +446,7 @@ struct FrameList {
 
     int stack_index(const RawSample &stack) {
         if (stack.empty()) {
-            throw std::runtime_error("empty stack");
+            throw std::runtime_error("VERNIER BUG: empty stack");
         }
 
         StackNode *node = &root_stack_node;
@@ -659,8 +659,8 @@ class Marker {
 
 class MarkerTable {
     public:
-        std::vector<Marker> list;
         std::mutex mutex;
+        std::vector<Marker> list;
 
         void record_interval(Marker::Type type, TimeStamp from, TimeStamp to, int stack_index = -1) {
             const std::lock_guard<std::mutex> lock(mutex);
@@ -693,6 +693,51 @@ enum Category{
 	CATEGORY_IDLE
 };
 
+class ObjectSampleList {
+    public:
+
+        std::vector<int> stacks;
+        std::vector<TimeStamp> timestamps;
+        std::vector<int> weights;
+
+        size_t size() {
+            return stacks.size();
+        }
+
+        bool empty() {
+            return size() == 0;
+        }
+
+        void record_sample(int stack_index, TimeStamp time, int weight) {
+            stacks.push_back(stack_index);
+            timestamps.push_back(time);
+            weights.push_back(1);
+        }
+
+        void write_result(VALUE result) const {
+            VALUE allocations = rb_hash_new();
+            rb_hash_aset(result, sym("allocations"), allocations);
+
+            VALUE samples = rb_ary_new();
+            rb_hash_aset(allocations, sym("samples"), samples);
+            for (auto& stack_index: this->stacks) {
+                rb_ary_push(samples, INT2NUM(stack_index));
+            }
+
+            VALUE weights = rb_ary_new();
+            rb_hash_aset(allocations, sym("weights"), weights);
+            for (auto& weight: this->weights) {
+                rb_ary_push(weights, INT2NUM(weight));
+            }
+
+            VALUE timestamps = rb_ary_new();
+            rb_hash_aset(allocations, sym("timestamps"), timestamps);
+            for (auto& timestamp: this->timestamps) {
+                rb_ary_push(timestamps, ULL2NUM(timestamp.nanoseconds()));
+            }
+        }
+};
+
 class SampleList {
     public:
 
@@ -758,6 +803,7 @@ class SampleList {
 class Thread {
     public:
         SampleList samples;
+        ObjectSampleList allocation_samples;
 
         enum State {
             STARTED,
@@ -780,25 +826,29 @@ class Thread {
         int stack_on_suspend_idx;
         SampleTranslator translator;
 
-        MarkerTable *markers;
-
-	std::string name;
+        unique_ptr<MarkerTable> markers;
 
-	// FIXME: don't use pthread at start
+        // FIXME: don't use pthread at start
         Thread(State state, pthread_t pthread_id, VALUE ruby_thread) : pthread_id(pthread_id), ruby_thread(ruby_thread), state(state), stack_on_suspend_idx(-1) {
-            name = Qnil;
             ruby_thread_id = rb_obj_id(ruby_thread);
-	    //ruby_thread_id = ULL2NUM(ruby_thread);
+            //ruby_thread_id = ULL2NUM(ruby_thread);
             native_tid = get_native_thread_id();
             started_at = state_changed_at = TimeStamp::Now();
-            name = "";
-            markers = new MarkerTable();
+            markers = std::make_unique<MarkerTable>();
 
             if (state == State::STARTED) {
                 markers->record(Marker::Type::MARKER_GVL_THREAD_STARTED);
             }
         }
 
+        void record_newobj(VALUE obj, FrameList &frame_list) {
+            RawSample sample;
+            sample.sample();
+
+            int stack_idx = translator.translate(frame_list, sample);
+            allocation_samples.record_sample(stack_idx, TimeStamp::Now(), 1);
+        }
+
         void set_state(State new_state) {
             if (state == Thread::State::STOPPED) {
                 return;
@@ -867,6 +917,10 @@ class Thread {
             state_changed_at = now;
         }
 
+        bool is_main() {
+            return rb_thread_main() == ruby_thread;
+        }
+
         bool running() {
             return state != State::STOPPED;
         }
@@ -879,15 +933,15 @@ class ThreadTable {
     public:
         FrameList &frame_list;
 
-        std::vector<Thread> list;
+        std::vector<std::unique_ptr<Thread> > list;
         std::mutex mutex;
 
         ThreadTable(FrameList &frame_list) : frame_list(frame_list) {
         }
 
         void mark() {
-            for (auto &thread : list) {
-                thread.mark();
+            for (const auto &thread : list) {
+                thread->mark();
             }
         }
 
@@ -923,7 +977,8 @@ class ThreadTable {
 
             //fprintf(stderr, "th %p (tid: %i) from %s to %s\n", (void *)th, native_tid, gvl_event_name(state), gvl_event_name(new_state));
 
-            for (auto &thread : list) {
+            for (auto &threadptr : list) {
+                auto &thread = *threadptr;
                 if (thread_equal(th, thread.ruby_thread)) {
                     if (new_state == Thread::State::SUSPENDED) {
 
@@ -950,7 +1005,7 @@ class ThreadTable {
             }
 
             //fprintf(stderr, "NEW THREAD: th: %p, state: %i\n", th, new_state);
-            list.emplace_back(new_state, pthread_self(), th);
+            list.push_back(std::make_unique<Thread>(new_state, pthread_self(), th));
         }
 
         bool thread_equal(VALUE a, VALUE b) {
@@ -1226,17 +1281,22 @@ class GlobalSignalHandler {
             if (count == 0) clear_signal_handler();
         }
 
-        void record_sample(LiveSample &sample, pthread_t pthread_id) {
+        bool record_sample(LiveSample &sample, pthread_t pthread_id) {
             const std::lock_guard<std::mutex> lock(mutex);
 
             assert(pthread_id);
 
             live_sample = &sample;
-            if (pthread_kill(pthread_id, SIGPROF)) {
-                rb_bug("pthread_kill failed");
+            int rc = pthread_kill(pthread_id, SIGPROF);
+            if (rc) {
+                fprintf(stderr, "VERNIER BUG: pthread_kill of %lu failed (%i)\n", (unsigned long)pthread_id, rc);
+                live_sample = NULL;
+                return false;
+            } else {
+                sample.wait();
+                live_sample = NULL;
+                return true;
             }
-            sample.wait();
-            live_sample = NULL;
         }
 
     private:
@@ -1276,9 +1336,40 @@ class TimeCollector : public BaseCollector {
     SamplerSemaphore thread_stopped;
 
     TimeStamp interval;
+    unsigned int allocation_sample_rate;
+    unsigned int allocation_sample_tick = 0;
+
+    VALUE tp_newobj = Qnil;
+
+    static void newobj_i(VALUE tpval, void *data) {
+        TimeCollector *collector = static_cast<TimeCollector *>(data);
+        rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+        VALUE obj = rb_tracearg_object(tparg);
+
+        collector->record_newobj(obj);
+    }
 
     public:
-    TimeCollector(TimeStamp interval) : interval(interval), threads(frame_list) {
+    TimeCollector(TimeStamp interval, unsigned int allocation_sample_rate) : interval(interval), allocation_sample_rate(allocation_sample_rate), threads(frame_list) {
+    }
+
+    void record_newobj(VALUE obj) {
+        if (++allocation_sample_tick < allocation_sample_rate) {
+            return;
+        }
+        allocation_sample_tick = 0;
+
+        VALUE current_thread = rb_thread_current();
+        threads.mutex.lock();
+        for (auto &threadptr : threads.list) {
+            auto &thread = *threadptr;
+            if (current_thread == thread.ruby_thread) {
+                thread.record_newobj(obj, threads.frame_list);
+                break;
+            }
+        }
+        threads.mutex.unlock();
+
     }
 
     private:
@@ -1307,9 +1398,9 @@ class TimeCollector : public BaseCollector {
             rb_ary_push(list, ary);
         }
         for (auto &thread : threads.list) {
-            for (auto& marker: thread.markers->list) {
+            for (auto& marker: thread->markers->list) {
                 VALUE ary = marker.to_array();
-                RARRAY_ASET(ary, 0, thread.ruby_thread_id);
+                RARRAY_ASET(ary, 0, thread->ruby_thread_id);
                 rb_ary_push(list, ary);
             }
         }
@@ -1325,14 +1416,21 @@ class TimeCollector : public BaseCollector {
             TimeStamp sample_start = TimeStamp::Now();
 
             threads.mutex.lock();
-            for (auto &thread : threads.list) {
+            for (auto &threadptr : threads.list) {
+                auto &thread = *threadptr;
+
                 //if (thread.state == Thread::State::RUNNING) {
                 //if (thread.state == Thread::State::RUNNING || (thread.state == Thread::State::SUSPENDED && thread.stack_on_suspend_idx < 0)) {
                 if (thread.state == Thread::State::RUNNING) {
                     //fprintf(stderr, "sampling %p on tid:%i\n", thread.ruby_thread, thread.native_tid);
-                    GlobalSignalHandler::get_instance()->record_sample(sample, thread.pthread_id);
-
-                    if (sample.sample.gc) {
+                    bool signal_sent = GlobalSignalHandler::get_instance()->record_sample(sample, thread.pthread_id);
+
+                    if (!signal_sent) {
+                        // The thread has died. We probably should have caught
+                        // that by the GVL instrumentation, but let's try to get
+                        // it to a consistent state and stop profiling it.
+                        thread.set_state(Thread::State::STOPPED);
+                    } else if (sample.sample.gc) {
                         // fprintf(stderr, "skipping GC sample\n");
                     } else {
                         record_sample(sample.sample, sample_start, thread, CATEGORY_NORMAL);
@@ -1458,6 +1556,11 @@ class TimeCollector : public BaseCollector {
             return false;
         }
 
+        if (allocation_sample_rate > 0) {
+            tp_newobj = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, this);
+            rb_tracepoint_enable(tp_newobj);
+        }
+
         GlobalSignalHandler::get_instance()->install();
 
         running = true;
@@ -1465,7 +1568,7 @@ class TimeCollector : public BaseCollector {
         int ret = pthread_create(&sample_thread, NULL, &sample_thread_entry, this);
         if (ret != 0) {
             perror("pthread_create");
-            rb_bug("pthread_create");
+            rb_bug("VERNIER: pthread_create failed");
         }
 
         // Set the state of the current Ruby thread to RUNNING, which we know it
@@ -1490,6 +1593,11 @@ class TimeCollector : public BaseCollector {
 
         GlobalSignalHandler::get_instance()->uninstall();
 
+        if (RTEST(tp_newobj)) {
+            rb_tracepoint_disable(tp_newobj);
+            tp_newobj = Qnil;
+        }
+
         rb_internal_thread_remove_event_hook(thread_hook);
         rb_remove_event_hook(internal_gc_event_cb);
         rb_remove_event_hook(internal_thread_event_cb);
@@ -1511,15 +1619,16 @@ class TimeCollector : public BaseCollector {
 
         for (const auto& thread: this->threads.list) {
             VALUE hash = rb_hash_new();
-            thread.samples.write_result(hash);
-
-            rb_hash_aset(threads, thread.ruby_thread_id, hash);
-            rb_hash_aset(hash, sym("tid"), ULL2NUM(thread.native_tid));
-            rb_hash_aset(hash, sym("started_at"), ULL2NUM(thread.started_at.nanoseconds()));
-            if (!thread.stopped_at.zero()) {
-                rb_hash_aset(hash, sym("stopped_at"), ULL2NUM(thread.stopped_at.nanoseconds()));
+            thread->samples.write_result(hash);
+            thread->allocation_samples.write_result(hash);
+
+            rb_hash_aset(threads, thread->ruby_thread_id, hash);
+            rb_hash_aset(hash, sym("tid"), ULL2NUM(thread->native_tid));
+            rb_hash_aset(hash, sym("started_at"), ULL2NUM(thread->started_at.nanoseconds()));
+            if (!thread->stopped_at.zero()) {
+                rb_hash_aset(hash, sym("stopped_at"), ULL2NUM(thread->stopped_at.nanoseconds()));
             }
-            rb_hash_aset(hash, sym("name"), rb_str_new(thread.name.data(), thread.name.length()));
+            rb_hash_aset(hash, sym("is_main"), thread->is_main() ? Qtrue : Qfalse);
 
         }
 
@@ -1615,12 +1724,20 @@ static VALUE collector_new(VALUE self, VALUE mode, VALUE options) {
         } else {
             interval = TimeStamp::from_microseconds(NUM2UINT(intervalv));
         }
-        collector = new TimeCollector(interval);
+
+        VALUE allocation_sample_ratev = rb_hash_aref(options, sym("allocation_sample_rate"));
+        unsigned int allocation_sample_rate;
+        if (NIL_P(allocation_sample_ratev)) {
+            allocation_sample_rate = 0;
+        } else {
+            allocation_sample_rate = NUM2UINT(allocation_sample_ratev);
+        }
+        collector = new TimeCollector(interval, allocation_sample_rate);
     } else {
         rb_raise(rb_eArgError, "invalid mode");
     }
     VALUE obj = TypedData_Wrap_Struct(self, &rb_collector_type, collector);
-    rb_funcall(obj, rb_intern("initialize"), 1, mode);
+    rb_funcall(obj, rb_intern("initialize"), 2, mode, options);
     return obj;
 }
 

data/lib/vernier/autorun.rb

@@ -17,10 +17,11 @@ module Vernier
 
     def self.start
       interval = options.fetch(:interval, 500).to_i
+      allocation_sample_rate = options.fetch(:allocation_sample_rate, 0).to_i
 
       STDERR.puts("starting profiler with interval #{interval}")
 
-      @collector = Vernier::Collector.new(:wall, interval:)
+      @collector = Vernier::Collector.new(:wall, interval:, allocation_sample_rate:)
       @collector.start
     end
 

data/lib/vernier/collector.rb

@@ -1,12 +1,34 @@
 # frozen_string_literal: true
 
 require_relative "marker"
+require_relative "thread_names"
 
 module Vernier
   class Collector
-    def initialize(mode)
+    def initialize(mode, options={})
       @mode = mode
       @markers = []
+      @hooks = []
+
+      @thread_names = ThreadNames.new
+
+      if options[:hooks]
+        Array(options[:hooks]).each do |hook|
+          add_hook(hook)
+        end
+      end
+      @hooks.each do |hook|
+        hook.enable
+      end
+    end
+
+    private def add_hook(hook)
+      case hook
+      when :rails, :activesupport
+        @hooks << Vernier::Hooks::ActiveSupport.new(self)
+      else
+        warn "Unknown hook: #{hook}"
+      end
     end
 
     ##
@@ -47,6 +69,18 @@ module Vernier
     def stop
       result = finish
 
+      @thread_names.finish
+
+      @hooks.each do |hook|
+        hook.disable
+      end
+
+      result.threads.each do |obj_id, thread|
+        thread[:name] ||= @thread_names[obj_id]
+      end
+
+      result.hooks = @hooks
+
       end_time = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
       result.pid = Process.pid
       result.end_time = end_time

data/lib/vernier/hooks/active_support.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Vernier
+  module Hooks
+    class ActiveSupport
+      FIREFOX_MARKER_SCHEMA = Ractor.make_shareable([
+        {
+          name: "sql.active_record",
+          display: [ "marker-chart", "marker-table" ],
+          data: [
+            { key: "sql", format: "string" },
+            { key: "name", format: "string" },
+            { key: "type_casted_binds", label: "binds", format: "string"
+            }
+          ]
+        },
+        {
+          name: "instantiation.active_record",
+          display: [ "marker-chart", "marker-table" ],
+          data: [
+            { key: "record_count", format: "integer" },
+            { key: "class_name", format: "string" }
+          ]
+        },
+        {
+          name: "process_action.action_controller",
+          display: [ "marker-chart", "marker-table" ],
+          data: [
+            { key: "controller", format: "string" },
+            { key: "action", format: "string" },
+            { key: "status", format: "integer" },
+            { key: "path", format: "string" },
+            { key: "method", format: "string" }
+          ]
+        },
+        {
+          name: "cache_read.active_support",
+          display: [ "marker-chart", "marker-table" ],
+          data: [
+            { key: "key", format: "string" },
+            { key: "store", format: "string" },
+            { key: "hit", format: "string" },
+            { key: "super_operation", format: "string" }
+          ]
+        },
+        {
+          name: "cache_read_multi.active_support",
+          display: [ "marker-chart", "marker-table" ],
+          data: [
+            { key: "key", format: "string" },
+            { key: "store", format: "string" },
+            { key: "hit", format: "string" },
+            { key: "super_operation", format: "string" }
+          ]
+        },
+        {
+          name: "cache_fetch_hit.active_support",
+          display: [ "marker-chart", "marker-table" ],
+          data: [
+            { key: "key", format: "string" },
+            { key: "store", format: "string" }
+          ]
+        }
+      ])
+
+      SERIALIZED_KEYS = FIREFOX_MARKER_SCHEMA.map do |format|
+        [
+          format[:name],
+          format[:data].map { _1[:key].to_sym }.freeze
+        ]
+      end.to_h.freeze
+
+      def initialize(collector)
+        @collector = collector
+      end
+
+      def enable
+        require "active_support"
+        @subscription = ::ActiveSupport::Notifications.monotonic_subscribe(/\A[^!]/) do |name, start, finish, id, payload|
+          # Notifications.publish API may reach here without proper timing information included
+          unless Float === start && Float === finish
+            next
+          end
+
+          data = { type: name }
+          if keys = SERIALIZED_KEYS[name]
+            keys.each do |key|
+              data[key] = payload[key]
+            end
+          end
+          @collector.add_marker(
+            name: name,
+            start: (start * 1_000_000_000.0).to_i,
+            finish: (finish * 1_000_000_000.0).to_i,
+            data: data
+          )
+        end
+      end
+
+      def disable
+        ::ActiveSupport::Notifications.unsubscribe(@subscription)
+        @subscription = nil
+      end
+
+      def firefox_marker_schema
+        FIREFOX_MARKER_SCHEMA
+      end
+    end
+  end
+end

data/lib/vernier/hooks.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Vernier
+  module Hooks
+    autoload :ActiveSupport, "vernier/hooks/active_support"
+  end
+end

data/lib/vernier/output/firefox.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "rbconfig"
 
 module Vernier
   module Output
@@ -133,7 +134,8 @@ module Vernier
                 color: category.color,
                 subcategories: []
               }
-            end
+            end,
+            sourceCodeIsNotOnSearchfox: true
           },
           libs: [],
           threads: thread_data
@@ -141,9 +143,15 @@ module Vernier
       end
 
       def marker_schema
+        hook_additions = profile.hooks.flat_map do |hook|
+          if hook.respond_to?(:firefox_marker_schema)
+            hook.firefox_marker_schema
+          end
+        end.compact
+
         [
           {
-            name: "GVL_THREAD_RESUMED",
+            name: "THREAD_RUNNING",
             display: [ "marker-chart", "marker-table" ],
             data: [
               {
@@ -151,19 +159,57 @@ module Vernier
                 value: "The thread has acquired the GVL and is executing"
               }
             ]
-          }
+          },
+          {
+            name: "THREAD_STALLED",
+            display: [ "marker-chart", "marker-table" ],
+            data: [
+              {
+                label: "Description",
+                value: "The thread is ready, but stalled waiting for the GVL to be available"
+              }
+            ]
+          },
+          {
+            name: "THREAD_SUSPENDED",
+            display: [ "marker-chart", "marker-table" ],
+            data: [
+              {
+                label: "Description",
+                value: "The thread has voluntarily released the GVL (ex. to sleep, for I/O, waiting on a lock)"
+              }
+            ]
+          },
+          {
+            name: "GC_PAUSE",
+            display: [ "marker-chart", "marker-table", "timeline-overview" ],
+            tooltipLabel: "{marker.name} - {marker.data.state}",
+            data: [
+              {
+                label: "Description",
+                value: "All threads are paused as GC is performed"
+              }
+            ]
+          },
+          *hook_additions
         ]
       end
 
       class Thread
         attr_reader :profile
 
-        def initialize(ruby_thread_id, profile, categorizer, name:, tid:, samples:, weights:, timestamps: nil, sample_categories: nil, markers:, started_at:, stopped_at: nil)
+        def initialize(ruby_thread_id, profile, categorizer, name:, tid:, samples:, weights:, timestamps: nil, sample_categories: nil, markers:, started_at:, stopped_at: nil, allocations: nil, is_main: nil)
           @ruby_thread_id = ruby_thread_id
           @profile = profile
           @categorizer = categorizer
           @tid = tid
-          @name = pretty_name(name)
+          @allocations = allocations
+          @name = name
+          @is_main = is_main
+          if is_main.nil?
+            @is_main = @ruby_thread_id == ::Thread.main.object_id
+          end
+          @is_main = true if profile.threads.size == 1
 
           timestamps ||= [0] * samples.size
           @samples, @weights, @timestamps = samples, weights, timestamps
@@ -184,7 +230,8 @@ module Vernier
           @func_names = names.map do |name|
             @strings[name]
           end
-          @filenames = filenames.map do |filename|
+
+          @filenames = filter_filenames(filenames).map do |filename|
             @strings[filename]
           end
 
@@ -211,10 +258,31 @@ module Vernier
           end
         end
 
+        def filter_filenames(filenames)
+          pwd = "#{Dir.pwd}/"
+          gem_regex = %r{\A#{Regexp.union(Gem.path)}/gems/}
+          gem_match_regex = %r{\A#{Regexp.union(Gem.path)}/gems/([a-zA-Z](?:[a-zA-Z0-9\.\_]|-[a-zA-Z])*)-([0-9][0-9A-Za-z\-_\.]*)/(.*)\z}
+          rubylibdir = "#{RbConfig::CONFIG["rubylibdir"]}/"
+
+          filenames.map do |filename|
+            if filename.match?(gem_regex)
+              gem_match_regex =~ filename
+              "gem:#$1-#$2:#$3"
+            elsif filename.start_with?(pwd)
+              filename.delete_prefix(pwd)
+            elsif filename.start_with?(rubylibdir)
+              path = filename.delete_prefix(rubylibdir)
+              "rubylib:#{RUBY_VERSION}:#{path}"
+            else
+              filename
+            end
+          end
+        end
+
         def data
           {
             name: @name,
-            isMainThread: @ruby_thread_id == ::Thread.main.object_id || (profile.threads.size == 1),
+            isMainThread: @is_main,
             processStartupTime: 0, # FIXME
             processShutdownTime: nil, # FIXME
             registerTime: (@started_at - 0) / 1_000_000.0,
@@ -226,6 +294,7 @@ module Vernier
             funcTable: func_table,
             nativeSymbols: {},
             samples: samples_table,
+            jsAllocations: allocations_table,
             stackTable: stack_table,
             resourceTable: {
               length: 0,
@@ -236,7 +305,7 @@ module Vernier
             },
             markers: markers_table,
             stringArray: string_table
-          }
+          }.compact
         end
 
         def markers_table
@@ -277,6 +346,25 @@ module Vernier
           }
         end
 
+        def allocations_table
+          return nil if !@allocations
+          samples, weights, timestamps = @allocations.values_at(:samples, :weights, :timestamps)
+          return nil if samples.size == 0
+          size = samples.size
+          timestamps = timestamps.map { _1 / 1_000_000.0 }
+          ret = {
+            "time": timestamps,
+            "className": ["Object"]*size,
+            "typeName": ["JSObject"]*size,
+            "coarseType": ["Object"]*size,
+            "weight": weights,
+            "inNursery": [false] * size,
+            "stack": samples,
+            "length": size
+          }
+          ret
+        end
+
         def samples_table
           samples = @samples
           weights = @weights
@@ -366,14 +454,21 @@ module Vernier
 
           cfunc_idx = @strings["<cfunc>"]
           is_js = @filenames.map { |fn| fn != cfunc_idx }
+          line_numbers = profile.func_table.fetch(:first_line).map.with_index do |line, i|
+            if is_js[i] || line != 0
+              line
+            else
+              nil
+            end
+          end
           {
             name: @func_names,
             isJS: is_js,
             relevantForJS: is_js,
             resource: [-1] * size, # set to unidentified for now
             fileName: @filenames,
-            lineNumber: profile.func_table.fetch(:first_line),
-            columnNumber: [0] * size,
+            lineNumber: line_numbers,
+            columnNumber: [nil] * size,
             #columnNumber: functions.map { _1.column },
             length: size
           }
@@ -385,25 +480,6 @@ module Vernier
 
         private
 
-        def pretty_name(name)
-          if name.empty?
-            begin
-              tr = ObjectSpace._id2ref(@ruby_thread_id)
-              name = tr.inspect if tr
-            rescue RangeError
-              # Thread was already GC'd
-            end
-          end
-          return name unless name.start_with?("#<Thread")
-          pretty = []
-          obj_address = name[/Thread:(0x\w+)/,1]
-          best_id = name[/\#<Thread:0x\w+@?\s?(.*)\s+\S+>/,1] || ""
-          Gem.path.each { |gem_dir| best_id = best_id.gsub(gem_dir, "...") }
-          pretty << best_id unless best_id.empty?
-          pretty << "(#{obj_address})"
-          pretty.join(' ')
-        end
-
         def gc_category
           @categorizer.get_category("GC")
         end

data/lib/vernier/result.rb

@@ -3,10 +3,16 @@ module Vernier
     attr_reader :stack_table, :frame_table, :func_table
     attr_reader :markers
 
+    attr_accessor :hooks
+
     attr_accessor :pid, :end_time
     attr_accessor :threads
     attr_accessor :meta
 
+    def main_thread
+      threads.values.detect {|x| x[:is_main] }
+    end
+
     # TODO: remove these
     def weights; threads.values.flat_map { _1[:weights] }; end
     def samples; threads.values.flat_map { _1[:samples] }; end

data/lib/vernier/thread_names.rb

@@ -0,0 +1,52 @@
+module Vernier
+  # Collects names of all seen threads
+  class ThreadNames
+    def initialize
+      @names = {}
+      @tp = TracePoint.new(:thread_end) do |e|
+        collect_thread(e.self)
+      end
+      @tp.enable
+    end
+
+    def [](object_id)
+      @names[object_id] || "unknown thread #{object_id}"
+    end
+
+    def finish
+      collect_running
+      @tp.disable
+    end
+
+    private
+
+    def collect_running
+      Thread.list.each do |th|
+        collect_thread(th)
+      end
+    end
+
+    def collect_thread(th)
+      @names[th.object_id] = pretty_name(th)
+    end
+
+    def pretty_name(thread)
+      name = thread.name
+      return name if name && !name.empty?
+
+      if thread == Thread.main
+        return "main"
+      end
+
+      name = Thread.instance_method(:inspect).bind_call(thread)
+      pretty = []
+      best_id = name[/\#<Thread:0x\w+@?\s?(.*)\s+\S+>/, 1]
+      if best_id
+        Gem.path.each { |gem_dir| best_id.gsub!(gem_dir, "") }
+        pretty << best_id unless best_id.empty?
+      end
+      pretty << "(#{thread.object_id})"
+      pretty.join(' ')
+    end
+  end
+end

data/lib/vernier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Vernier
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/vernier.rb

@@ -3,6 +3,7 @@
 require_relative "vernier/version"
 require_relative "vernier/collector"
 require_relative "vernier/result"
+require_relative "vernier/hooks"
 require_relative "vernier/vernier"
 require_relative "vernier/output/firefox"
 require_relative "vernier/output/top"
@@ -10,8 +11,8 @@ require_relative "vernier/output/top"
 module Vernier
   class Error < StandardError; end
 
-  def self.trace(mode: :wall, out: nil, interval: nil)
-    collector = Vernier::Collector.new(mode, { interval: })
+  def self.trace(mode: :wall, out: nil, **collector_options)
+    collector = Vernier::Collector.new(mode, collector_options)
     collector.start
 
     result = nil

data/vernier.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors = ["John Hawthorn"]
   spec.email = ["john@hawthorn.email"]
 
-  spec.summary = "An experimental profiler"
-  spec.description = spec.summary
+  spec.summary = "A next generation CRuby profiler"
+  spec.description = "Next-generation Ruby 3.2.1+ sampling profiler. Tracks multiple threads, GVL activity, GC pauses, idle time, and more."
   spec.homepage = "https://github.com/jhawthorn/vernier"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 3.2.1"
@@ -29,4 +29,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.extensions = ["ext/vernier/extconf.rb"]
+
+  spec.add_development_dependency "activesupport"
 end

metadata

@@ -1,16 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: vernier
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-27 00:00:00.000000000 Z
-dependencies: []
-description: An experimental profiler
+date: 2024-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Next-generation Ruby 3.2.1+ sampling profiler. Tracks multiple threads,
+  GVL activity, GC pauses, idle time, and more.
 email:
 - john@hawthorn.email
 executables:
@@ -39,10 +54,13 @@ files:
 - lib/vernier.rb
 - lib/vernier/autorun.rb
 - lib/vernier/collector.rb
+- lib/vernier/hooks.rb
+- lib/vernier/hooks/active_support.rb
 - lib/vernier/marker.rb
 - lib/vernier/output/firefox.rb
 - lib/vernier/output/top.rb
 - lib/vernier/result.rb
+- lib/vernier/thread_names.rb
 - lib/vernier/version.rb
 - vernier.gemspec
 homepage: https://github.com/jhawthorn/vernier
@@ -70,5 +88,5 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
-summary: An experimental profiler
+summary: A next generation CRuby profiler
 test_files: []