vernier 0.7.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4988794520691870cb34178385be791e28fa4806eb1f6934b0d0abf52c8a070c
-  data.tar.gz: b1e63c6f5398f61fb68d634f17f33dc6aa7461344cb8acf446dd75ca52395818
+  metadata.gz: 682bc2ce2b915b0fa21db46232322f1bafba1916fc4e1b58cbaeafe3631ab3f2
+  data.tar.gz: af659f7fe18efa70c41fa178ff6ed52244292287f1b59e4950fcad6db0a1675e
 SHA512:
-  metadata.gz: '082561b2a381f88c540e607d1dd9c0d42d841a0de82fc61471fb2d67754ee14a4fd1e87fa71896b586077664e61fd1db623fd250cd13064d198c9dc91d3f13ed'
-  data.tar.gz: a28c197d405e4f52d999db3ae73187047886e1fcfb7d353d13f26ad5ba4b61f0675daf617119b37d72ad3760bd0dffcae234f2dcb0a0e960a60046dfb87dd784
+  metadata.gz: a373326fd6ddb7043b57b5e0b8f8ddc96c666368ae38fbd8398df29e09fffea9141bc9a4166e6f0970817685c86e93c9cf3fc1312ca49fb9ae9ba1ba49dd60f8
+  data.tar.gz: 59026602a1d4103e0b245e7fa63fd7168bfa9c57913d1d7a003349f4818c7b303da050b19c4c31523f853e81715ab56e425bccfa77eee8053486e4dc12ea864f

data/exe/vernier

@@ -25,6 +25,9 @@ parser = OptionParser.new(banner) do |o|
   o.on('--start-paused', "don't automatically start the profiler") do
     options[:start_paused] = true
   end
+  o.on('--hooks [HOOKS]', String, "Enable instrumentation hooks. Currently supported: rails") do |s|
+    options[:hooks] = s
+  end
 end
 
 parser.parse!

data/ext/vernier/vernier.cc

@@ -59,6 +59,8 @@ static VALUE rb_mVernierMarkerType;
 static VALUE rb_cVernierCollector;
 static VALUE rb_cStackTable;
 
+static VALUE sym_state, sym_gc_by;
+
 static const char *gvl_event_name(rb_event_flag_t event) {
     switch (event) {
       case RUBY_INTERNAL_THREAD_EVENT_STARTED:
@@ -796,6 +798,12 @@ static native_thread_id_t get_native_thread_id() {
 #endif
 }
 
+union MarkerInfo {
+    struct {
+        VALUE gc_by;
+        VALUE gc_state;
+    } gc_data;
+};
 
 class Marker {
     public:
@@ -833,8 +841,10 @@ class Marker {
     //native_thread_id_t thread_id;
     int stack_index = -1;
 
+    MarkerInfo extra_info;
+
     VALUE to_array() {
-        VALUE record[6] = {0};
+        VALUE record[7] = {0};
         record[0] = Qnil; // FIXME
         record[1] = INT2NUM(type);
         record[2] = INT2NUM(phase);
@@ -848,7 +858,14 @@ class Marker {
         }
         record[5] = stack_index == -1 ? Qnil : INT2NUM(stack_index);
 
-        return rb_ary_new_from_values(6, record);
+        if (type == Marker::MARKER_GC_PAUSE) {
+            VALUE hash = rb_hash_new();
+            record[6] = hash;
+
+            rb_hash_aset(hash, sym_gc_by, extra_info.gc_data.gc_by);
+            rb_hash_aset(hash, sym_state, extra_info.gc_data.gc_state);
+        }
+        return rb_ary_new_from_values(7, record);
     }
 };
 
@@ -863,7 +880,7 @@ class MarkerTable {
             list.push_back({ type, Marker::INTERVAL, from, to, stack_index });
         }
 
-        void record(Marker::Type type, int stack_index = -1) {
+        void record(Marker::Type type, int stack_index = -1, MarkerInfo extra_info = {}) {
             const std::lock_guard<std::mutex> lock(mutex);
 
             list.push_back({ type, Marker::INSTANT, TimeStamp::Now(), TimeStamp(), stack_index });
@@ -874,18 +891,41 @@ class GCMarkerTable: public MarkerTable {
     TimeStamp last_gc_entry;
 
     public:
+        void record_gc_start() {
+            record(Marker::Type::MARKER_GC_START);
+        }
+
         void record_gc_entered() {
           last_gc_entry = TimeStamp::Now();
         }
 
         void record_gc_leave() {
-          list.push_back({ Marker::MARKER_GC_PAUSE, Marker::INTERVAL, last_gc_entry, TimeStamp::Now(), -1 });
+            VALUE gc_state = rb_gc_latest_gc_info(sym_state);
+            VALUE gc_by = rb_gc_latest_gc_info(sym_gc_by);
+            union MarkerInfo info = {
+                .gc_data = {
+                    .gc_by = gc_by,
+                    .gc_state = gc_state
+                }
+            };
+            list.push_back({ Marker::MARKER_GC_PAUSE, Marker::INTERVAL, last_gc_entry, TimeStamp::Now(), -1, info });
+        }
+
+        void record_gc_end_mark() {
+            record_gc_leave();
+            record(Marker::Type::MARKER_GC_END_MARK);
+            record_gc_entered();
+        }
+
+        void record_gc_end_sweep() {
+            record(Marker::Type::MARKER_GC_END_SWEEP);
         }
 };
 
 enum Category{
-	CATEGORY_NORMAL,
-	CATEGORY_IDLE
+    CATEGORY_NORMAL,
+    CATEGORY_IDLE,
+    CATEGORY_STALLED
 };
 
 class ObjectSampleList {
@@ -1002,7 +1042,8 @@ class Thread {
             RUNNING,
             READY,
             SUSPENDED,
-            STOPPED
+            STOPPED,
+            INITIAL,
         };
 
         VALUE ruby_thread;
@@ -1058,12 +1099,14 @@ class Thread {
             }
 
             switch (new_state) {
+                case State::INITIAL:
+                    break;
                 case State::STARTED:
                     markers->record(Marker::Type::MARKER_GVL_THREAD_STARTED);
                     return; // no mutation of current state
                     break;
                 case State::RUNNING:
-                    assert(state == State::READY || state == State::RUNNING);
+                    assert(state == INITIAL || state == State::READY || state == State::RUNNING);
                     pthread_id = pthread_self();
                     native_tid = get_native_thread_id();
 
@@ -1081,7 +1124,7 @@ class Thread {
                     // Threads can be preempted, which means they will have been in "Running"
                     // state, and then the VM was like "no I need to stop you from working,
                     // so I'll put you in the 'ready' (or stalled) state"
-                    assert(state == State::STARTED || state == State::SUSPENDED || state == State::RUNNING);
+                    assert(state == State::INITIAL || state == State::STARTED || state == State::SUSPENDED || state == State::RUNNING);
                     if (state == State::SUSPENDED) {
                         markers->record_interval(Marker::Type::MARKER_THREAD_SUSPENDED, from, now, stack_on_suspend_idx);
                     }
@@ -1091,12 +1134,12 @@ class Thread {
                     break;
                 case State::SUSPENDED:
                     // We can go from RUNNING or STARTED to SUSPENDED
-                    assert(state == State::RUNNING || state == State::STARTED || state == State::SUSPENDED);
+                    assert(state == State::INITIAL || state == State::RUNNING || state == State::STARTED || state == State::SUSPENDED);
                     markers->record_interval(Marker::Type::MARKER_THREAD_RUNNING, from, now);
                     break;
                 case State::STOPPED:
                     // We can go from RUNNING or STARTED or SUSPENDED to STOPPED
-                    assert(state == State::RUNNING || state == State::STARTED || state == State::SUSPENDED);
+                    assert(state == State::INITIAL || state == State::RUNNING || state == State::STARTED || state == State::SUSPENDED);
                     markers->record_interval(Marker::Type::MARKER_THREAD_RUNNING, from, now);
                     markers->record(Marker::Type::MARKER_GVL_THREAD_EXITED);
 
@@ -1137,6 +1180,10 @@ class ThreadTable {
             }
         }
 
+        void initial(VALUE th) {
+            set_state(Thread::State::INITIAL, th);
+        }
+
         void started(VALUE th) {
             //list.push_back(Thread{pthread_self(), Thread::State::SUSPENDED});
             set_state(Thread::State::STARTED, th);
@@ -1172,7 +1219,7 @@ class ThreadTable {
             for (auto &threadptr : list) {
                 auto &thread = *threadptr;
                 if (thread_equal(th, thread.ruby_thread)) {
-                    if (new_state == Thread::State::SUSPENDED) {
+                    if (new_state == Thread::State::SUSPENDED || new_state == Thread::State::READY && (thread.state != Thread::State::SUSPENDED)) {
 
                         RawSample sample;
                         sample.sample();
@@ -1636,6 +1683,11 @@ class TimeCollector : public BaseCollector {
                             thread.stack_on_suspend_idx,
                             sample_start,
                             CATEGORY_IDLE);
+                } else if (thread.state == Thread::State::READY) {
+                    thread.samples.record_sample(
+                            thread.stack_on_suspend_idx,
+                            sample_start,
+                            CATEGORY_STALLED);
                 } else {
                 }
             }
@@ -1688,13 +1740,13 @@ class TimeCollector : public BaseCollector {
 
         switch (event) {
             case RUBY_INTERNAL_EVENT_GC_START:
-                collector->gc_markers.record(Marker::Type::MARKER_GC_START);
+                collector->gc_markers.record_gc_start();
                 break;
             case RUBY_INTERNAL_EVENT_GC_END_MARK:
-                collector->gc_markers.record(Marker::Type::MARKER_GC_END_MARK);
+                collector->gc_markers.record_gc_end_mark();
                 break;
             case RUBY_INTERNAL_EVENT_GC_END_SWEEP:
-                collector->gc_markers.record(Marker::Type::MARKER_GC_END_SWEEP);
+                collector->gc_markers.record_gc_end_sweep();
                 break;
             case RUBY_INTERNAL_EVENT_GC_ENTER:
                 collector->gc_markers.record_gc_entered();
@@ -1751,6 +1803,13 @@ class TimeCollector : public BaseCollector {
             return false;
         }
 
+        // Record one sample from each thread
+        VALUE all_threads = rb_funcall(rb_path2class("Thread"), rb_intern("list"), 0);
+        for (int i = 0; i < RARRAY_LEN(all_threads); i++) {
+            VALUE thread = RARRAY_AREF(all_threads, i);
+            this->threads.initial(thread);
+        }
+
         if (allocation_sample_rate > 0) {
             tp_newobj = rb_tracepoint_new(0, RUBY_INTERNAL_EVENT_NEWOBJ, newobj_i, this);
             rb_tracepoint_enable(tp_newobj);
@@ -1978,6 +2037,10 @@ Init_consts(VALUE rb_mVernierMarkerPhase) {
 extern "C" void
 Init_vernier(void)
 {
+    sym_state = sym("state");
+    sym_gc_by = sym("gc_by");
+    rb_gc_latest_gc_info(sym_state); // HACK: needs to be warmed so that it can be called during GC
+
   rb_mVernier = rb_define_module("Vernier");
   rb_cVernierResult = rb_define_class_under(rb_mVernier, "Result", rb_cObject);
   VALUE rb_mVernierMarker = rb_define_module_under(rb_mVernier, "Marker");

data/lib/vernier/autorun.rb

@@ -18,10 +18,11 @@ module Vernier
     def self.start
       interval = options.fetch(:interval, 500).to_i
       allocation_sample_rate = options.fetch(:allocation_sample_rate, 0).to_i
+      hooks = options.fetch(:hooks, "").split(",")
 
       STDERR.puts("starting profiler with interval #{interval}")
 
-      @collector = Vernier::Collector.new(:wall, interval:, allocation_sample_rate:)
+      @collector = Vernier::Collector.new(:wall, interval:, allocation_sample_rate:, hooks:)
       @collector.start
     end
 
@@ -29,8 +30,8 @@ module Vernier
       result = @collector.stop
       @collector = nil
       output_path = options[:output]
-      output_path ||= Tempfile.create(["profile", ".vernier.json"]).path
-      File.write(output_path, Vernier::Output::Firefox.new(result).output)
+      output_path ||= Tempfile.create(["profile", ".vernier.json.gz"]).path
+      result.write(out: output_path)
 
       STDERR.puts(result.inspect)
       STDERR.puts("written to #{output_path}")
@@ -57,7 +58,7 @@ end
 if signal = Vernier::Autorun.options[:signal]
   STDERR.puts "to toggle profiler: kill -#{signal} #{Process.pid}"
   trap(signal) do
-    Vernier::Autorun.toggle
+    Thread.new { Vernier::Autorun.toggle }
   end
 end
 

data/lib/vernier/collector.rb

@@ -29,11 +29,11 @@ module Vernier
     end
 
     private def add_hook(hook)
-      case hook
+      case hook.to_sym
       when :rails, :activesupport
         @hooks << Vernier::Hooks::ActiveSupport.new(self)
       else
-        warn "Unknown hook: #{hook}"
+        warn "Unknown hook: #{hook.inspect}"
       end
     end
 
@@ -94,11 +94,12 @@ module Vernier
 
       marker_strings = Marker.name_table
 
-      markers = self.markers.map do |(tid, type, phase, ts, te, stack)|
+      markers = self.markers.map do |(tid, type, phase, ts, te, stack, extra_info)|
         name = marker_strings[type]
         sym = Marker::MARKER_SYMBOLS[type]
         data = { type: sym }
         data[:cause] = { stack: stack } if stack
+        data.merge!(extra_info) if extra_info
         [tid, name, ts, te, phase, data]
       end
 

data/lib/vernier/hooks/active_support.rb

@@ -7,9 +7,12 @@ module Vernier
         {
           name: "sql.active_record",
           display: [ "marker-chart", "marker-table" ],
+          tooltipLabel: "{marker.data.name}",
+          chartLabel: "{marker.data.name}",
+          tableLabel: "{marker.data.sql}",
           data: [
-            { key: "sql", format: "string" },
-            { key: "name", format: "string" },
+            { key: "sql", format: "string", searchable: true },
+            { key: "name", format: "string", searchable: true },
             { key: "type_casted_binds", label: "binds", format: "string"
             }
           ]
@@ -17,25 +20,50 @@ module Vernier
         {
           name: "instantiation.active_record",
           display: [ "marker-chart", "marker-table" ],
+          tooltipLabel: "{marker.data.record_count} × {marker.data.class_name}",
+          chartLabel: "{marker.data.record_count} × {marker.data.class_name}",
+          tableLabel: "Instantiate {marker.data.record_count} × {marker.data.class_name}",
           data: [
             { key: "record_count", format: "integer" },
             { key: "class_name", format: "string" }
           ]
         },
+        {
+          name: "start_processing.action_controller",
+          display: [ "marker-chart", "marker-table" ],
+          tooltipLabel: '{marker.data.method} {marker.data.controller}#{marker.data.action}',
+          chartLabel:   '{marker.data.method} {marker.data.controller}#{marker.data.action}',
+          tableLabel:   '{marker.data.method} {marker.data.controller}#{marker.data.action}',
+          data: [
+            { key: "controller", format: "string" },
+            { key: "action", format: "string" },
+            { key: "status", format: "integer" },
+            { key: "path", format: "string" },
+            { key: "method", format: "string" },
+            { key: "format", format: "string" }
+          ]
+        },
         {
           name: "process_action.action_controller",
           display: [ "marker-chart", "marker-table" ],
+          tooltipLabel: '{marker.data.method} {marker.data.controller}#{marker.data.action}',
+          chartLabel:   '{marker.data.method} {marker.data.controller}#{marker.data.action}',
+          tableLabel:   '{marker.data.method} {marker.data.controller}#{marker.data.action}',
           data: [
             { key: "controller", format: "string" },
             { key: "action", format: "string" },
             { key: "status", format: "integer" },
             { key: "path", format: "string" },
-            { key: "method", format: "string" }
+            { key: "method", format: "string" },
+            { key: "format", format: "string" }
           ]
         },
         {
           name: "cache_read.active_support",
           display: [ "marker-chart", "marker-table" ],
+          tooltipLabel: '{marker.data.super_operation} {marker.data.key}',
+          chartLabel:   '{marker.data.super_operation} {marker.data.key}',
+          tableLabel:   '{marker.data.super_operation} {marker.data.key}',
           data: [
             { key: "key", format: "string" },
             { key: "store", format: "string" },
@@ -55,11 +83,65 @@ module Vernier
         },
         {
           name: "cache_fetch_hit.active_support",
+          tooltipLabel: 'HIT {marker.data.key}',
+          chartLabel:   'HIT {marker.data.key}',
+          tableLabel:   'HIT {marker.data.key}',
           display: [ "marker-chart", "marker-table" ],
           data: [
             { key: "key", format: "string" },
             { key: "store", format: "string" }
           ]
+        },
+        {
+          name: "render_template.action_view",
+          display: [ "marker-chart", "marker-table" ],
+          tooltipLabel: '{marker.data.identifier}',
+          chartLabel:   '{marker.data.identifier}',
+          tableLabel:   '{marker.data.identifier}',
+          data: [
+            { key: "identifier", format: "string" }
+          ]
+        },
+        {
+          name: "render_layout.action_view",
+          display: [ "marker-chart", "marker-table" ],
+          tooltipLabel: '{marker.data.identifier}',
+          chartLabel:   '{marker.data.identifier}',
+          tableLabel:   '{marker.data.identifier}',
+          data: [
+            { key: "identifier", format: "string" }
+          ]
+        },
+        {
+          name: "render_partial.action_view",
+          display: [ "marker-chart", "marker-table" ],
+          tooltipLabel: '{marker.data.identifier}',
+          chartLabel:   '{marker.data.identifier}',
+          tableLabel:   '{marker.data.identifier}',
+          data: [
+            { key: "identifier", format: "string" }
+          ]
+        },
+        {
+          name: "render_collection.action_view",
+          display: [ "marker-chart", "marker-table" ],
+          tooltipLabel: '{marker.data.identifier}',
+          chartLabel:   '{marker.data.identifier}',
+          tableLabel:   '{marker.data.identifier}',
+          data: [
+            { key: "identifier", format: "string" },
+            { key: "count", format: "integer" }
+          ]
+        },
+        {
+          name: "load_config_initializer.railties",
+          display: [ "marker-chart", "marker-table" ],
+          tooltipLabel: '{marker.data.initializer}',
+          chartLabel:   '{marker.data.initializer}',
+          tableLabel:   '{marker.data.initializer}',
+          data: [
+            { key: "initializer", format: "string" }
+          ]
         }
       ])
 

data/lib/vernier/middleware.rb

@@ -18,10 +18,10 @@ module Vernier
       result = Vernier.trace(interval:, allocation_sample_rate:, hooks: [:rails]) do
         @app.call(env)
       end
-      body = result.to_gecko
-      filename = "#{request.path.gsub("/", "_")}_#{DateTime.now.strftime("%Y-%m-%d-%H-%M-%S")}.vernier.json"
+      body = result.to_gecko(gzip: true)
+      filename = "#{request.path.gsub("/", "_")}_#{DateTime.now.strftime("%Y-%m-%d-%H-%M-%S")}.vernier.json.gz"
       headers = {
-        "Content-Type" => "application/json; charset=utf-8",
+        "Content-Type" => "application/octet-stream",
         "Content-Disposition" => "attachment; filename=\"#{filename}\"",
         "Content-Length" => body.bytesize.to_s
       }

data/lib/vernier/output/firefox.rb

@@ -14,35 +14,29 @@ module Vernier
           @categories = []
           @categories_by_name = {}
 
-          add_category(name: "Default", color: "grey")
+          add_category(name: "Ruby", color: "grey") do |c|
+            rails_components = %w[ activesupport activemodel activerecord
+              actionview actionpack activejob actionmailer actioncable
+              activestorage actionmailbox actiontext railties ]
+            c.add_subcategory(
+              name: "Rails",
+              matcher: gem_path(*rails_components)
+            )
+            c.add_subcategory(
+              name: "gem",
+              matcher: starts_with(*Gem.path)
+            )
+            c.add_subcategory(
+              name: "stdlib",
+              matcher: starts_with(RbConfig::CONFIG["rubylibdir"])
+            )
+          end
           add_category(name: "Idle", color: "transparent")
+          add_category(name: "Stalled", color: "transparent")
 
           add_category(name: "GC", color: "red")
-          add_category(
-            name: "stdlib",
-            color: "red",
-            matcher: starts_with(RbConfig::CONFIG["rubylibdir"])
-          )
           add_category(name: "cfunc", color: "yellow", matcher: "<cfunc>")
 
-          rails_components = %w[ activesupport activemodel activerecord
-          actionview actionpack activejob actionmailer actioncable
-          activestorage actionmailbox actiontext railties ]
-          add_category(
-            name: "Rails",
-            color: "green",
-            matcher: gem_path(*rails_components)
-          )
-          add_category(
-            name: "gem",
-            color: "red",
-            matcher: starts_with(*Gem.path)
-          )
-          add_category(
-            name: "Application",
-            color: "purple"
-          )
-
           add_category(name: "Thread", color: "grey")
         end
 
@@ -50,6 +44,8 @@ module Vernier
           category = Category.new(@categories.length, name: name, **kw)
           @categories << category
           @categories_by_name[name] = category
+          category.add_subcategory(name: "Other")
+          yield category if block_given?
           category
         end
 
@@ -70,12 +66,17 @@ module Vernier
         end
 
         class Category
-          attr_reader :idx, :name, :color, :matcher
+          attr_reader :idx, :name, :color, :matcher, :subcategories
           def initialize(idx, name:, color:, matcher: nil)
             @idx = idx
             @name = name
             @color = color
             @matcher = matcher
+            @subcategories = []
+          end
+
+          def add_subcategory(**args)
+            @subcategories << Category.new(@subcategories.size, color: nil, **args)
           end
 
           def matches?(path)
@@ -89,8 +90,13 @@ module Vernier
         @categorizer = Categorizer.new
       end
 
-      def output
-        ::JSON.fast_generate(data)
+      def output(gzip: false)
+        result = ::JSON.fast_generate(data)
+        if gzip
+          require "zlib"
+          result = Zlib.gzip(result)
+        end
+        result
       end
 
       private
@@ -132,7 +138,7 @@ module Vernier
               {
                 name: category.name,
                 color: category.color,
-                subcategories: []
+                subcategories: category.subcategories.map(&:name)
               }
             end,
             sourceCodeIsNotOnSearchfox: true
@@ -152,7 +158,7 @@ module Vernier
         [
           {
             name: "THREAD_RUNNING",
-            display: [ "marker-chart", "marker-table" ],
+            display: [ "marker-chart" ],
             data: [
               {
                 label: "Description",
@@ -162,7 +168,7 @@ module Vernier
           },
           {
             name: "THREAD_STALLED",
-            display: [ "marker-chart", "marker-table" ],
+            display: [ "marker-chart" ],
             data: [
               {
                 label: "Description",
@@ -172,7 +178,7 @@ module Vernier
           },
           {
             name: "THREAD_SUSPENDED",
-            display: [ "marker-chart", "marker-table" ],
+            display: [ "marker-chart" ],
             data: [
               {
                 label: "Description",
@@ -188,7 +194,9 @@ module Vernier
               {
                 label: "Description",
                 value: "All threads are paused as GC is performed"
-              }
+              },
+              { key: "state", format: "string" },
+              { key: "gc_by", format: "string" },
             ]
           },
           *hook_additions
@@ -251,12 +259,22 @@ module Vernier
             func_implementations[func_idx]
           end
 
+          cfunc_category = @categorizer.get_category("cfunc")
+          ruby_category = @categorizer.get_category("Ruby")
           func_categories = filenames.map do |filename|
-            @categorizer.categorize(filename)
+            filename == "<cfunc>" ? cfunc_category : ruby_category
+          end
+          func_subcategories = filenames.map do |filename|
+            next 0 if filename == "<cfunc>"
+
+            (ruby_category.subcategories.detect {|c| c.matches?(filename) } || ruby_category.subcategories.first).idx
           end
           @frame_categories = profile.frame_table.fetch(:func).map do |func_idx|
             func_categories[func_idx]
           end
+          @frame_subcategories = profile.frame_table.fetch(:func).map do |func_idx|
+            func_subcategories[func_idx]
+          end
         end
 
         def filter_filenames(filenames)
@@ -412,11 +430,13 @@ module Vernier
           frames = profile.stack_table.fetch(:frame).dup
           prefixes = profile.stack_table.fetch(:parent).dup
           categories  = frames.map{|idx| @frame_categories[idx].idx }
+          subcategories  = frames.map{|idx| @frame_subcategories[idx] }
 
-          @categorized_stacks.keys.each do |(stack, category)|
+          @categorized_stacks.each_key do |(stack, category)|
             frames << frames[stack]
             prefixes << prefixes[stack]
             categories << category
+            subcategories << 0
           end
 
           size = frames.length
@@ -425,7 +445,7 @@ module Vernier
           {
             frame: frames,
             category: categories,
-            subcategory: [0] * size,
+            subcategory: subcategories,
             prefix: prefixes,
             length: prefixes.length
           }

data/lib/vernier/result.rb

@@ -37,12 +37,13 @@ module Vernier
       (current_time_real_ns - current_time_mono_ns + started_at_mono_ns)
     end
 
-    def to_gecko
-      Output::Firefox.new(self).output
+    def to_gecko(gzip: false)
+      Output::Firefox.new(self).output(gzip:)
     end
 
     def write(out:)
-      File.write(out, to_gecko)
+      gzip = out.end_with?(".gz")
+      File.write(out, to_gecko(gzip:))
     end
 
     def elapsed_seconds
@@ -50,7 +51,7 @@ module Vernier
     end
 
     def inspect
-      "#<#{self.class} #{elapsed_seconds} seconds, #{threads.count} threads, #{weights.sum} samples, #{samples.uniq.size} unique>"
+      "#<#{self.class} #{elapsed_seconds} seconds, #{threads.count} threads, #{samples.count} samples, #{samples.uniq.size} unique>"
     end
 
     def each_sample

data/lib/vernier/stack_table.rb

@@ -1,5 +1,9 @@
 module Vernier
   class StackTable
+    def inspect
+      "#<#{self.class.name} #{stack_count} stacks, #{frame_count} frames, #{func_count} funcs>"
+    end
+
     def to_h
       {
         stack_table: {

data/lib/vernier/thread_names.rb

@@ -35,7 +35,7 @@ module Vernier
       return name if name && !name.empty?
 
       if thread == Thread.main
-        return "main"
+        return $0
       end
 
       name = Thread.instance_method(:inspect).bind_call(thread)

data/lib/vernier/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vernier
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 1.0.0
 platform: ruby
 authors:
 - John Hawthorn
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-13 00:00:00.000000000 Z
+date: 2024-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport