vernier 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da42588d9f2409a9d82a79439014490ecd81f00cb74c975267d6568a6e343c46
-  data.tar.gz: 921543f2b8cfec4e5803c4a47c8953df1acff567b88ddce2e1a65faad9e7c895
+  metadata.gz: b9ba6d060b4eb230a865df67f378f81b08721d36a9f8cf394f9a8d5d0455b844
+  data.tar.gz: d01c209f5fab9bc99940fb5b967a722f69c75376dd6aba0c3e7759a9c52bc698
 SHA512:
-  metadata.gz: a674536e944ef26f2db5893821d9d643fc8f651d45b7a72923ae9ab7c01f270431f0e5fadea76e3bb3feeabe30edde203b520310cbbbae6a53f03edb148db570
-  data.tar.gz: 1f39e9f04a2fd1c80525a72ce27aca6e8d614dfa9a4ba9f9721beff08f11a41431f6690c6215f0592dcc7923e49e516a4a0ddb812b493820877ceca81b4373ab
+  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

@@ -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,
@@ -782,15 +828,12 @@ class Thread {
 
         unique_ptr<MarkerTable> markers;
 
-        std::string name;
-
         // 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) {
             ruby_thread_id = rb_obj_id(ruby_thread);
             //ruby_thread_id = ULL2NUM(ruby_thread);
             native_tid = get_native_thread_id();
             started_at = state_changed_at = TimeStamp::Now();
-            name = "";
             markers = std::make_unique<MarkerTable>();
 
             if (state == State::STARTED) {
@@ -798,6 +841,14 @@ class Thread {
             }
         }
 
+        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;
@@ -866,6 +917,10 @@ class Thread {
             state_changed_at = now;
         }
 
+        bool is_main() {
+            return rb_thread_main() == ruby_thread;
+        }
+
         bool running() {
             return state != State::STOPPED;
         }
@@ -1281,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:
@@ -1470,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;
@@ -1502,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);
@@ -1524,6 +1620,7 @@ class TimeCollector : public BaseCollector {
         for (const auto& thread: this->threads.list) {
             VALUE hash = rb_hash_new();
             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));
@@ -1531,7 +1628,7 @@ class TimeCollector : public BaseCollector {
             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);
 
         }
 
@@ -1627,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.1"
+  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.1
+  version: 0.6.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-28 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
@@ -67,8 +85,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
-summary: An experimental profiler
+summary: A next generation CRuby profiler
 test_files: []