vernier 1.9.0 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3aa6d3665db78499efc979f38af3d3a4f633e105ccd3a6a17b9e11ad19556cf
-  data.tar.gz: eb752d610602a89417c894a360ea46f7727ce9a9bd11a13a2f608d35d07d4680
+  metadata.gz: d1af998d7d2517b6c73e0ef7ec8a3e0762c9c0ca23dd859d3c268842f064612f
+  data.tar.gz: 558ad40b4ca261719e241f22806112e9ff18b2ba0e1a65d5c24067deee0803e0
 SHA512:
-  metadata.gz: 3a96e0d3fa78b72e3a54c05eb871af65d405c32c44e0c0d8bc5efbeffaad59bb8490ab5c599e1a435d755093927c623e813965cda31a9bbeda43e3c2c41945cc
-  data.tar.gz: 32355e62e58124b426899dc4c167139521081d8be2bcf454aa3b0fb4916fb92334464a5685cccf5b712ee2d3d23a328a804b96b12a79e85e590f30d31d28fc66
+  metadata.gz: 58a0c75db2f1ffb90017f887c4e6813653ef908efc4601cbe6fe105aa1493c5344028355d1ec68658e59c34d36b885fcd59340de553bfffc1a72fcadd7668398
+  data.tar.gz: a80cd4ab4c0da94d3799cbedfe93de02788dc48bb7626565eff62cfc7606aa75c93892f5dab17d6b076abf6ea361cbf9231940cfb40384c8116490aff5dee79e

data/.ruby-version

@@ -1 +1 @@
-3.4.7
+4.0

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() {
@@ -140,6 +138,9 @@ class HeapTracker {
       if (RTEST(tp_newobj)) {
         rb_tracepoint_disable(tp_newobj);
         tp_newobj = Qnil;
+        if (tombstones * 10 > object_list.size()) {
+          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/firefox.rb

@@ -267,6 +267,11 @@ module Vernier
       end
 
       class Thread
+        SAMPLE_CATEGORY_NAMES = {
+          1 => "Idle",
+          2 => "Stalled"
+        }.freeze
+
         attr_reader :profile, :is_start
 
         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, is_start: nil)
@@ -355,6 +360,31 @@ module Vernier
           @frame_subcategories = @stack_table_hash[:frame_table].fetch(:func).map do |func_idx|
             func_subcategories[func_idx]
           end
+
+          @sample_category_idx = SAMPLE_CATEGORY_NAMES.transform_values do |name|
+            @categorizer.get_category(name).idx
+          end
+
+          @samples.zip(@sample_categories).each do |sample, raw_category|
+            next if raw_category == 0
+
+            @categorized_stacks[[sample, raw_category]]
+          end
+
+          base_stack_frames = @stack_table_hash[:stack_table].fetch(:frame)
+          base_frame_count = @stack_table_hash[:frame_table].fetch(:func).size
+          @extra_frames = []
+          @categorized_frame_map = {}
+
+          @categorized_stacks.each_key do |(stack, raw_category)|
+            original_frame_idx = base_stack_frames[stack]
+            key = [original_frame_idx, raw_category]
+            next if @categorized_frame_map.key?(key)
+
+            new_frame_idx = base_frame_count + @extra_frames.size
+            @categorized_frame_map[key] = new_frame_idx
+            @extra_frames << [original_frame_idx, @sample_category_idx[raw_category]]
+          end
         end
 
         def categorize_filename(filename)
@@ -377,7 +407,7 @@ module Vernier
         def find_category_and_subcategory(filename, categories)
           categories.each do |category_name|
             category = @categorizer.get_category(category_name)
-            subcategory = category.subcategories.detect {|c| c.matches?(filename) }&.idx
+            subcategory = category.subcategories.detect { |c| c.matches?(filename) }&.idx
             return category, subcategory if subcategory
           end
           [nil, nil]
@@ -430,7 +460,7 @@ module Vernier
           categories = []
           data = []
 
-          @markers.each_with_index do |(_, name, start, finish, phase, datum), i|
+          @markers.each do |(_, name, start, finish, phase, datum)|
             string_indexes << @strings[name]
             start_times << (start / 1_000_000.0)
 
@@ -463,12 +493,14 @@ module Vernier
         end
 
         def allocations_table
-          return nil if !@allocations
+          return nil unless @allocations
+
           samples, weights, timestamps = @allocations.values_at(:samples, :weights, :timestamps)
-          return nil if samples.size == 0
+          return nil if samples.empty?
+
           size = samples.size
           timestamps = timestamps.map { _1 / 1_000_000.0 }
-          ret = {
+          {
             "time": timestamps,
             "className": ["Object"]*size,
             "typeName": ["JSObject"]*size,
@@ -478,7 +510,6 @@ module Vernier
             "stack": samples,
             "length": size
           }
-          ret
         end
 
         def samples_table
@@ -518,21 +549,22 @@ module Vernier
         end
 
         def stack_table
-          frames =   @stack_table_hash[:stack_table].fetch(:frame).dup
+          base_frames = @stack_table_hash[:stack_table].fetch(:frame)
+          frames = base_frames.dup
           prefixes = @stack_table_hash[:stack_table].fetch(:parent).dup
-          categories  = frames.map{|idx| @frame_categories[idx].idx }
-          subcategories  = frames.map{|idx| @frame_subcategories[idx] }
+          categories = frames.map { |idx| @frame_categories[idx].idx }
+          subcategories = frames.map { |idx| @frame_subcategories[idx] }
 
-          @categorized_stacks.each_key do |(stack, category)|
-            frames << frames[stack]
+          @categorized_stacks.each_key do |(stack, raw_category)|
+            original_frame_idx = base_frames[stack]
+            frames << @categorized_frame_map[[original_frame_idx, raw_category]]
             prefixes << prefixes[stack]
-            categories << category
+            categories << @sample_category_idx[raw_category]
             subcategories << 0
           end
 
-          size = frames.length
-          raise unless frames.size == size
-          raise unless prefixes.size == size
+          raise unless prefixes.size == frames.size
+
           {
             frame: frames,
             category: categories,
@@ -543,18 +575,27 @@ module Vernier
         end
 
         def frame_table
-          funcs = @stack_table_hash[:frame_table].fetch(:func)
-          lines = @stack_table_hash[:frame_table].fetch(:line)
+          funcs = @stack_table_hash[:frame_table].fetch(:func).dup
+          lines = @stack_table_hash[:frame_table].fetch(:line).dup
           raise unless lines.size == funcs.size
 
+          categories = @frame_categories.map(&:idx)
+          subcategories = @frame_subcategories.dup
+          implementations = @frame_implementations.dup
+
+          @extra_frames.each do |(frame_idx, category_idx)|
+            funcs << funcs[frame_idx]
+            lines << lines[frame_idx]
+            categories << category_idx
+            subcategories << 0
+            implementations << implementations[frame_idx]
+          end
+
           size = funcs.size
           none = [nil] * size
           default = [0] * size
           unidentified = [-1] * size
 
-          categories = @frame_categories.map(&:idx)
-          subcategories = @frame_subcategories
-
           {
             address: unidentified,
             inlineDepth: default,
@@ -563,7 +604,7 @@ module Vernier
             func: funcs,
             nativeSymbol: none,
             innerWindowID: none,
-            implementation: @frame_implementations,
+            implementation: implementations,
             line: lines,
             column: none,
             length: size
@@ -605,11 +646,8 @@ module Vernier
               else
                 string.scrub
               end
-            elsif string.encoding == Encoding::BINARY
-              # TODO: We might want to guess UTF-8 and escape the binary more explicitly
-              string.dup.force_encoding("UTF-8").scrub
             else
-              # TODO: ideally we should attempt to properly re-encode here, but right now I think this is dead code
+              # TODO: We might want to guess UTF-8 and escape the binary more explicitly
               string.dup.force_encoding("UTF-8").scrub
             end
           end

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.1"
 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.1
 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.6
 specification_version: 4
 summary: A next generation CRuby profiler
 test_files: []