vernier 1.9.0 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3aa6d3665db78499efc979f38af3d3a4f633e105ccd3a6a17b9e11ad19556cf
-  data.tar.gz: eb752d610602a89417c894a360ea46f7727ce9a9bd11a13a2f608d35d07d4680
+  metadata.gz: a504e7ef885ed393a864128d15ca792af4e6ab60f30cdf90afbc36aa5d577b34
+  data.tar.gz: 87ab42b6cc3ea1effae71f3b95bdc4d90c117abf1aadc3d425bb30b4573dafa9
 SHA512:
-  metadata.gz: 3a96e0d3fa78b72e3a54c05eb871af65d405c32c44e0c0d8bc5efbeffaad59bb8490ab5c599e1a435d755093927c623e813965cda31a9bbeda43e3c2c41945cc
-  data.tar.gz: 32355e62e58124b426899dc4c167139521081d8be2bcf454aa3b0fb4916fb92334464a5685cccf5b712ee2d3d23a328a804b96b12a79e85e590f30d31d28fc66
+  metadata.gz: f52d1d392009084c1511b7b2cc24c51fdb5da983d0fe1dd60286ed9fe0564229ec409513cd179f2af3ceb96f9a085e2f9f48b556ac5ae6b597aba7c13bd56cf8
+  data.tar.gz: 7b8255043801305c221a967a25974ff1e5896393adf8c820784dd980a2eeecfa49f63509b7eeddf1c0f81a7279c29ea87ffa88622de306d0d5b430c23a40c109

data/ext/vernier/heap_tracker.cc

@@ -47,8 +47,6 @@ class HeapTracker {
     }
 
     void record_newobj(VALUE obj) {
-      objects_allocated++;
-
       RawSample sample;
       sample.sample();
       if (sample.empty()) {
@@ -59,13 +57,13 @@ class HeapTracker {
       }
       int stack_index = stack_table->stack_index(sample);
 
+      objects_allocated++;
       int idx = object_list.size();
       object_list.push_back(obj);
       frame_list.push_back(stack_index);
       object_index.emplace(obj, idx);
 
-      assert(objects_allocated == frame_list.size());
-      assert(objects_allocated == object_list.size());
+      assert(frame_list.size() == object_list.size());
     }
 
     void rebuild() {

data/ext/vernier/vernier.cc

@@ -29,7 +29,9 @@
 #undef assert
 #define assert RUBY_ASSERT_ALWAYS
 
+#ifndef PTR2NUM
 # define PTR2NUM(x)   (rb_int2inum((intptr_t)(void *)(x)))
+#endif
 
 // Internal TracePoint events we'll monitor during profiling
 #define RUBY_INTERNAL_EVENTS \

data/lib/vernier/autorun.rb

@@ -48,8 +48,11 @@ module Vernier
         end
         prefix = "profile-"
         timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
-        suffix = if options[:format] == "cpuprofile"
+        suffix = case options[:format]
+        when "cpuprofile"
           ".vernier.cpuprofile"
+        when "markdown", "md"
+          ".vernier.md"
         else
           ".vernier.json.gz"
         end

data/lib/vernier/marker.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "vernier" # Make sure constants are loaded
+require "vernier/vernier"
 
 module Vernier
   module Marker

data/lib/vernier/middleware.rb

@@ -1,5 +1,10 @@
 module Vernier
   class Middleware
+    HOOKS = [
+      (:rails if defined?(Rails))
+    ].compact.freeze
+    private_constant :HOOKS
+
     def initialize(app, permit: ->(_env) { true })
       @app = app
       @permit = permit
@@ -15,7 +20,7 @@ module Vernier
       interval = request.GET.fetch("vernier_interval", 200).to_i
       allocation_interval = request.GET.fetch("vernier_allocation_interval", 200).to_i
 
-      result = Vernier.trace(interval:, allocation_interval:, hooks: [:rails]) do
+      result = Vernier.trace(interval:, allocation_interval:, hooks: HOOKS) do
         @app.call(env)
       end
       body = result.to_firefox(gzip: true)

data/lib/vernier/output/markdown.rb

@@ -0,0 +1,416 @@
+# frozen_string_literal: true
+
+require_relative "filename_filter"
+
+module Vernier
+  module Output
+    class Markdown
+      DEFAULT_TOP_N = 20
+      DEFAULT_LINES_PER_FILE = 5
+
+      def initialize(profile, top_n: DEFAULT_TOP_N, lines_per_file: DEFAULT_LINES_PER_FILE)
+        @profile = profile
+        @top_n = top_n
+        @lines_per_file = lines_per_file
+      end
+
+      def output
+        out = +""
+        out << build_title
+        out << build_summary
+        out << build_hotspots
+        out << build_threads
+        out << build_files
+        out
+      end
+
+      private
+
+      def build_title
+        "# Vernier Profile\n\n"
+      end
+
+      def build_summary
+        out = +"## Summary\n\n"
+
+        mode = @profile.meta[:mode] rescue nil
+        weight_unit = mode == :retained ? "bytes" : "samples"
+
+        out << "| Metric | Value |\n"
+        out << "|--------|-------|\n"
+        out << "| Mode | #{mode || 'unknown'} |\n"
+
+        if @profile.respond_to?(:elapsed_seconds)
+          begin
+            out << "| Duration | #{format("%.2f", @profile.elapsed_seconds)} seconds |\n"
+          rescue
+            # elapsed_seconds may fail if end_time not set
+          end
+        end
+
+        out << "| Total Samples | #{total_samples} |\n"
+        out << "| Total Unique Samples | #{@profile.total_unique_samples rescue 'N/A'} |\n"
+        out << "| Threads | #{thread_count} |\n"
+        out << "| Weight Unit | #{weight_unit} |\n"
+
+        if @profile.respond_to?(:pid) && @profile.pid
+          out << "| PID | #{@profile.pid} |\n"
+        end
+
+        out << "\n"
+
+        # User metadata if available
+        if @profile.respond_to?(:meta) && @profile.meta[:user_metadata]
+          metadata = @profile.meta[:user_metadata]
+          unless metadata.empty?
+            out << "### User Metadata\n\n"
+            out << "| Key | Value |\n"
+            out << "|-----|-------|\n"
+            metadata.each do |k, v|
+              out << "| #{escape_markdown(k.to_s)} | #{escape_markdown(v.to_s)} |\n"
+            end
+            out << "\n"
+          end
+        end
+
+        out
+      end
+
+      def build_hotspots
+        out = +"## Top Hotspots\n\n"
+
+        thread = main_thread
+        return out << "_No samples collected._\n\n" unless thread
+
+        stack_table = get_stack_table(thread)
+        samples = thread[:samples] || []
+        weights = thread[:weights] || []
+
+        return out << "_No samples collected._\n\n" if samples.empty?
+
+        # Compute self weights per function
+        total = weights.sum
+        return out << "_No samples collected._\n\n" if total == 0
+
+        top_by_func = Hash.new { |h, k| h[k] = { self: 0, total: 0, file: nil, line: nil } }
+
+        samples.zip(weights).each do |stack_idx, weight|
+          # Self time: top frame only
+          frame_idx = stack_table.stack_frame_idx(stack_idx)
+          func_idx = stack_table.frame_func_idx(frame_idx)
+          name = stack_table.func_name(func_idx)
+          filename = stack_table.func_filename(func_idx)
+          first_lineno = stack_table.func_first_lineno(func_idx)
+
+          top_by_func[name][:self] += weight
+          top_by_func[name][:file] ||= filename
+          top_by_func[name][:line] ||= first_lineno
+
+          # Total time: walk up the stack
+          seen = {}
+          current_stack_idx = stack_idx
+          while current_stack_idx
+            frame_idx = stack_table.stack_frame_idx(current_stack_idx)
+            func_idx = stack_table.frame_func_idx(frame_idx)
+            func_name = stack_table.func_name(func_idx)
+
+            unless seen[func_name]
+              seen[func_name] = true
+              top_by_func[func_name][:total] += weight
+              top_by_func[func_name][:file] ||= stack_table.func_filename(func_idx)
+              top_by_func[func_name][:line] ||= stack_table.func_first_lineno(func_idx)
+            end
+
+            current_stack_idx = stack_table.stack_parent_idx(current_stack_idx)
+          end
+        end
+
+        out << top_functions_table("By Self Time", top_by_func, total, :self)
+        out << top_functions_table("By Total Time", top_by_func, total, :total)
+
+        out
+      end
+
+      def top_functions_table(title, funcs, total, sort_key)
+        out = +"### #{title}\n\n"
+        sorted = funcs.sort_by { |_, v| -v[sort_key] }.first(@top_n)
+
+        primary = sort_key == :self ? "Self" : "Total"
+        secondary = sort_key == :self ? "Total" : "Self"
+        out << "| Rank | #{primary} % | #{secondary} % | Function | Location |\n"
+        out << "|------|--------|---------|----------|----------|\n"
+
+        sorted.each_with_index do |(name, data), idx|
+          self_pct = 100.0 * data[:self] / total
+          total_pct = 100.0 * data[:total] / total
+          primary_pct = sort_key == :self ? self_pct : total_pct
+          secondary_pct = sort_key == :self ? total_pct : self_pct
+          location = format_location(data[:file], data[:line])
+          out << "| #{idx + 1} | #{format("%.1f", primary_pct)}% | #{format("%.1f", secondary_pct)}% | #{format_code_span(name)} | #{escape_markdown(location)} |\n"
+        end
+
+        out << "\n"
+        out
+      end
+
+      def build_threads
+        out = +"## Threads\n\n"
+
+        threads_data = get_threads
+        return out << "_No thread information available._\n\n" if threads_data.empty?
+
+        threads_data.each do |thread_id, thread|
+          name = get_thread_name(thread) || "Thread #{thread_id}"
+          is_main = get_thread_main(thread) ? "yes" : "no"
+          tid = get_thread_tid(thread) || thread_id
+
+          samples = thread[:samples] || []
+          weights = thread[:weights] || []
+          sample_count = samples.size
+          weight_sum = weights.sum
+
+          out << "### #{escape_markdown(name)}\n\n"
+          out << "| Property | Value |\n"
+          out << "|----------|-------|\n"
+          out << "| TID | #{tid} |\n"
+          out << "| Main Thread | #{is_main} |\n"
+          out << "| Samples | #{sample_count} |\n"
+          out << "| Total Weight | #{weight_sum} |\n"
+          out << "\n"
+        end
+
+        out
+      end
+
+      def build_files
+        out = +"## Hot Files\n\n"
+
+        thread = main_thread
+        return out << "_No file information available._\n\n" unless thread
+
+        stack_table = get_stack_table(thread)
+        samples = thread[:samples] || []
+        weights = thread[:weights] || []
+
+        return out << "_No samples collected._\n\n" if samples.empty?
+
+        total = weights.sum
+        return out << "_No samples collected._\n\n" if total == 0
+
+        # Build samples by file and line (similar to FileListing)
+        samples_by_frame = Hash.new { |h, k| h[k] = { self: 0, total: 0 } }
+
+        samples.zip(weights).each do |stack_idx, weight|
+          # Self time: top frame only
+          top_frame_idx = stack_table.stack_frame_idx(stack_idx)
+          samples_by_frame[top_frame_idx][:self] += weight
+
+          # Total time: walk up the stack
+          current_stack_idx = stack_idx
+          while current_stack_idx
+            frame_idx = stack_table.stack_frame_idx(current_stack_idx)
+            samples_by_frame[frame_idx][:total] += weight
+            current_stack_idx = stack_table.stack_parent_idx(current_stack_idx)
+          end
+        end
+
+        # Group by file
+        samples_by_file = Hash.new { |h, k| h[k] = Hash.new { |h2, k2| h2[k2] = { self: 0, total: 0 } } }
+
+        samples_by_frame.each do |frame_idx, data|
+          func_idx = stack_table.frame_func_idx(frame_idx)
+          filename = stack_table.func_filename(func_idx)
+          line = stack_table.frame_line_no(frame_idx)
+
+          filename = filter_filename(filename)
+          samples_by_file[filename][line][:self] += data[:self]
+          samples_by_file[filename][line][:total] += data[:total]
+        end
+
+        # Filter to relevant files (>1% self time, exclude gem/rubylib/<)
+        relevant_files = samples_by_file.select do |filename, lines|
+          next false if filename.start_with?("gem:")
+          next false if filename.start_with?("rubylib:")
+          next false if filename.start_with?("<")
+
+          lines.values.map { |d| d[:self] }.max > total * 0.01
+        end
+
+        if relevant_files.empty?
+          return out << "_No significant file hotspots found._\n\n"
+        end
+
+        # Sort files by total weight
+        sorted_files = relevant_files.sort_by { |_, lines| -lines.values.map { |d| d[:self] }.sum }
+
+        sorted_files.each do |filename, lines|
+          out << "### #{escape_markdown(filename)}\n\n"
+
+          # Get top lines by self weight
+          sorted_lines = lines.sort_by { |_, d| -d[:self] }.first(@lines_per_file)
+
+          out << "| Line | Self % | Total % | Code |\n"
+          out << "|------|--------|---------|------|\n"
+
+          sorted_lines.each do |line_no, data|
+            self_pct = 100.0 * data[:self] / total
+            total_pct = 100.0 * data[:total] / total
+
+            source_line = read_source_line(filename, line_no)
+            code = source_line ? truncate_code(source_line) : "_source unavailable_"
+
+            out << "| #{line_no} | #{format("%.1f", self_pct)}% | #{format("%.1f", total_pct)}% | #{format_code_span(code)} |\n"
+          end
+
+          out << "\n"
+        end
+
+        out
+      end
+
+      # Helper methods
+
+      def main_thread
+        @profile.main_thread
+      end
+
+      def get_threads
+        if @profile.respond_to?(:threads)
+          threads = @profile.threads
+          if threads.is_a?(Hash)
+            threads
+          elsif threads.is_a?(Array)
+            # ParsedProfile returns array
+            threads.each_with_index.to_h { |t, i| [i, t] }
+          else
+            {}
+          end
+        else
+          {}
+        end
+      end
+
+      def get_stack_table(thread)
+        if thread.respond_to?(:stack_table)
+          thread.stack_table
+        else
+          @profile._stack_table
+        end
+      end
+
+      def get_thread_name(thread)
+        if thread.is_a?(Hash)
+          thread[:name]
+        elsif thread.respond_to?(:data)
+          thread.data["name"]
+        end
+      end
+
+      def get_thread_main(thread)
+        if thread.is_a?(Hash)
+          thread[:is_main]
+        elsif thread.respond_to?(:main_thread?)
+          thread.main_thread?
+        end
+      end
+
+      def get_thread_tid(thread)
+        if thread.is_a?(Hash)
+          thread[:tid]
+        elsif thread.respond_to?(:data)
+          thread.data["tid"]
+        end
+      end
+
+      def total_samples
+        if @profile.respond_to?(:total_samples)
+          @profile.total_samples
+        else
+          main = main_thread
+          main ? (main[:samples]&.size || 0) : 0
+        end
+      end
+
+      def thread_count
+        threads = get_threads
+        threads.is_a?(Hash) ? threads.size : threads.length
+      end
+
+      def filter_filename(filename)
+        @filename_filter ||= if live_profile?
+          FilenameFilter.new
+        else
+          ->(x) { x }
+        end
+        @filename_filter.call(filename)
+      end
+
+      def live_profile?
+        thread = main_thread
+        thread.is_a?(Hash)
+      end
+
+      def format_location(file, line)
+        return "unknown" unless file
+        filtered = filter_filename(file)
+        line ? "#{filtered}:#{line}" : filtered
+      end
+
+      def read_source_line(filename, line_no)
+        return nil unless line_no && line_no > 0
+
+        # For filtered filenames, try to resolve back to real path
+        real_path = resolve_filename(filename)
+        return nil unless real_path && File.exist?(real_path)
+
+        lines = File.readlines(real_path)
+        lines[line_no - 1]&.chomp
+      rescue
+        nil
+      end
+
+      def resolve_filename(filename)
+        return nil if filename.start_with?("gem:", "rubylib:", "<")
+        return filename if File.exist?(filename)
+
+        # Try expanding relative to cwd
+        expanded = File.expand_path(filename)
+        return expanded if File.exist?(expanded)
+
+        nil
+      end
+
+      def truncate_code(code, max_length: 60)
+        code = code.strip
+        if code.length > max_length
+          code[0, max_length - 3] + "..."
+        else
+          code
+        end
+      end
+
+      def format_code_span(text)
+        content = text.to_s.gsub("|", "\\|")
+
+        # Find longest run of consecutive backticks in content
+        max_run = content.scan(/`+/).map(&:length).max || 0
+        delimiter = "`" * (max_run + 1)
+
+        if delimiter.length > 1
+          "#{delimiter} #{content} #{delimiter}"
+        else
+          "#{delimiter}#{content}#{delimiter}"
+        end
+      end
+
+      def escape_markdown(text)
+        return "" unless text
+        text.to_s
+          .gsub("&", "&amp;")
+          .gsub("<", "&lt;")
+          .gsub(">", "&gt;")
+          .gsub(/([|`*_\[\]])/, '\\\\\1')
+      end
+    end
+  end
+end

data/lib/vernier/parsed_profile.rb

@@ -29,7 +29,7 @@ module Vernier
         @frame_lines   = thread_data["frameTable"]["line"]
         @func_names    = thread_data["funcTable"]["name"]
         @func_filenames = thread_data["funcTable"]["fileName"]
-        #@func_first_linenos = thread_data["funcTable"]["first"]
+        @func_first_linenos = thread_data["funcTable"]["lineNumber"]
         @strings  = thread_data["stringArray"]
       end
 
@@ -49,7 +49,7 @@ module Vernier
       def func_filename_idx(idx) = @func_filenames[idx]
       def func_name(idx) = @strings[func_name_idx(idx)]
       def func_filename(idx) = @strings[func_filename_idx(idx)]
-      def func_first_lineno(idx) = @func_first_lineno[idx]
+      def func_first_lineno(idx) = @func_first_linenos[idx]
 
       include StackTableHelpers
     end

data/lib/vernier/result.rb

@@ -30,6 +30,10 @@ module Vernier
       Output::Cpuprofile.new(self).output
     end
 
+    def to_markdown(top_n: 20, lines_per_file: 5)
+      Output::Markdown.new(self, top_n: top_n, lines_per_file: lines_per_file).output
+    end
+
     def write(out:, format: "firefox")
       case format
       when "cpuprofile"
@@ -38,6 +42,12 @@ module Vernier
         else
           File.binwrite(out, to_cpuprofile)
         end
+      when "markdown", "md"
+        if out.respond_to?(:write)
+          out.write(to_markdown)
+        else
+          File.binwrite(out, to_markdown)
+        end
       when "firefox", nil
         if out.respond_to?(:write)
           out.write(to_firefox)

data/lib/vernier/version.rb

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

data/lib/vernier.rb

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
 
-require_relative "vernier/version"
-require_relative "vernier/collector"
-require_relative "vernier/stack_table"
-require_relative "vernier/heap_tracker"
-require_relative "vernier/memory_leak_detector"
-require_relative "vernier/parsed_profile"
-require_relative "vernier/result"
-require_relative "vernier/hooks"
-require_relative "vernier/vernier"
-require_relative "vernier/output/firefox"
-require_relative "vernier/output/cpuprofile"
-require_relative "vernier/output/top"
-require_relative "vernier/output/file_listing"
-require_relative "vernier/output/filename_filter"
+require "vernier/version"
+require "vernier/collector"
+require "vernier/stack_table"
+require "vernier/heap_tracker"
+require "vernier/memory_leak_detector"
+require "vernier/parsed_profile"
+require "vernier/result"
+require "vernier/hooks"
+require "vernier/output/firefox"
+require "vernier/output/cpuprofile"
+require "vernier/output/top"
+require "vernier/output/file_listing"
+require "vernier/output/filename_filter"
+require "vernier/output/markdown"
+require "vernier/vernier"
 
 module Vernier
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vernier
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.10.0
 platform: ruby
 authors:
 - John Hawthorn
@@ -104,6 +104,7 @@ files:
 - lib/vernier/output/file_listing.rb
 - lib/vernier/output/filename_filter.rb
 - lib/vernier/output/firefox.rb
+- lib/vernier/output/markdown.rb
 - lib/vernier/output/top.rb
 - lib/vernier/parsed_profile.rb
 - lib/vernier/result.rb
@@ -133,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A next generation CRuby profiler
 test_files: []