lumitrace 0.4.2 → 0.6.0

data/lib/lumitrace/record_instrument.rb

@@ -7,6 +7,8 @@ module Lumitrace
   end
 
 module RecordInstrument
+  IDENTIFIER_METHOD_NAME_RE = /\A[a-z_]\w*[!?=]?\z/.freeze
+
   SKIP_NODE_CLASSES = [
     Prism::DefNode,
     Prism::ClassNode,
@@ -99,7 +101,7 @@ module RecordInstrument
         end
       end
 
-      node.child_nodes.each { |child| stack << [child, node] }
+      instrumentable_child_nodes(node).each { |child| stack << [child, node] }
     end
     locs
   end
@@ -136,7 +138,7 @@ module RecordInstrument
         end
       end
 
-      node.child_nodes.each { |child| stack << [child, node] }
+      instrumentable_child_nodes(node).each { |child| stack << [child, node] }
     end
 
     inserts
@@ -177,6 +179,8 @@ module RecordInstrument
   def self.wrap_expr?(node, parent = nil)
     return false unless node.respond_to?(:location)
     return false if literal_value_node?(node)
+    return false if command_style_call_node?(node)
+    return false if parent.is_a?(Prism::DefinedNode)
     if parent.is_a?(Prism::AliasGlobalVariableNode) || parent.is_a?(Prism::AliasMethodNode)
       return false
     end
@@ -196,6 +200,27 @@ module RecordInstrument
     WRAP_NODE_CLASSES.include?(node.class)
   end
 
+  def self.command_style_call_node?(node)
+    return false unless node.is_a?(Prism::CallNode)
+    return false unless node.respond_to?(:arguments) && node.arguments
+    return false if node.respond_to?(:opening_loc) && node.opening_loc
+
+    name = node.respond_to?(:name) ? node.name : nil
+    return false unless name
+
+    IDENTIFIER_METHOD_NAME_RE.match?(name.to_s)
+  end
+
+  def self.instrumentable_child_nodes(node)
+    return [] unless node
+    return [] if node.is_a?(Prism::DefinedNode)
+    if command_style_call_node?(node) && node.respond_to?(:block) && node.block
+      [node.block]
+    else
+      node.child_nodes
+    end
+  end
+
   def self.expr_location(node)
     loc = node.location
     return {
@@ -341,22 +366,31 @@ module RecordInstrument
 
   def self.events_from_ids
     out = []
-    @events_by_id.each_with_index do |e, id|
-      next unless e
-      loc = @loc_by_id[id]
+    summary_cache = {}
+    @loc_by_id.each_with_index do |loc, id|
       next unless loc
+
+      e = @events_by_id[id]
       case collect_mode
       when :history
-        raw_values = values_from_ring(e)
-        all_types = history_type_set(e)
-        if all_types.nil? || all_types.empty?
-          all_types = {}
-          raw_values.each do |v|
-            t = value_type_name(v)
-            all_types[t] = (all_types[t] || 0) + 1
+        if e
+          raw_values = values_from_ring(e)
+          all_types = history_type_set(e)
+          if all_types.nil? || all_types.empty?
+            all_types = {}
+            raw_values.each do |v|
+              t = value_type_name(v)
+              all_types[t] = (all_types[t] || 0) + 1
+            end
           end
+          max = history_ring_size(e)
+          total = e[max + 1]
+        else
+          raw_values = []
+          all_types = {}
+          total = 0
         end
-        max = history_ring_size(e)
+
         out << {
           file: loc[:file],
           start_line: loc[:start_line],
@@ -365,9 +399,20 @@ module RecordInstrument
           end_col: loc[:end_col],
           kind: loc[:kind].to_s,
           name: loc[:name],
-          sampled_values: raw_values.map { |v| summarize_value(v, type: value_type_name(v)) },
+          sampled_values: raw_values.map do |v|
+            key = v.__id__
+            cached = summary_cache[key]
+            if cached
+              cached.dup
+            else
+              type = value_type_name(v)
+              summary = summarize_value(v, type: type)
+              summary_cache[key] = summary
+              summary.dup
+            end
+          end,
           types: sorted_type_counts(all_types),
-          total: e[max + 1]
+          total: total
         }
       when :types
         out << {
@@ -378,12 +423,12 @@ module RecordInstrument
           end_col: loc[:end_col],
           kind: loc[:kind].to_s,
           name: loc[:name],
-          types: sorted_type_counts(e[:types]),
-          total: e[:total]
+          types: sorted_type_counts(e ? e[:types] : nil),
+          total: e ? e[:total] : 0
         }
       else # :last
-        last_raw = e[:last_value]
-        last_type = value_type_name(last_raw)
+        last_raw = e && e[:last_value]
+        last_type = value_type_name(last_raw) if e
         out << {
           file: loc[:file],
           start_line: loc[:start_line],
@@ -392,9 +437,21 @@ module RecordInstrument
           end_col: loc[:end_col],
           kind: loc[:kind].to_s,
           name: loc[:name],
-          last_value: summarize_value(last_raw, type: last_type),
-          types: sorted_type_counts(e[:types]),
-          total: e[:total]
+          last_value: if e
+            key = last_raw.__id__
+            cached = summary_cache[key]
+            if cached
+              cached.dup
+            else
+              summary = summarize_value(last_raw, type: last_type)
+              summary_cache[key] = summary
+              summary.dup
+            end
+          else
+            nil
+          end,
+          types: sorted_type_counts(e ? e[:types] : nil),
+          total: e ? e[:total] : 0
         }
       end
     end
@@ -438,10 +495,42 @@ module RecordInstrument
 
   def self.dump_events_json(events, path = nil)
     path ||= File.expand_path("lumitrace_recorded.json", Dir.pwd)
-    File.write(path, JSON.dump(events), perm: 0o600)
+    payload = {
+      version: 1,
+      events: events,
+      coverage: compute_coverage(events)
+    }
+    File.write(path, JSON.dump(payload), perm: 0o600)
     path
   end
 
+  def self.compute_coverage(events)
+    by_file = {}
+    events.each do |e|
+      file = e[:file] || e["file"]
+      next unless file
+      total = e[:total] || e["total"] || 0
+      start_line = e[:start_line] || e["start_line"]
+      next unless start_line
+
+      entry = (by_file[file] ||= { lines: {}, covered_lines: {} })
+      entry[:lines][start_line] = true
+      entry[:covered_lines][start_line] = true if total > 0
+    end
+
+    by_file.map do |file, entry|
+      total_lines = entry[:lines].size
+      covered_lines = entry[:covered_lines].size
+      pct = total_lines > 0 ? (covered_lines * 100.0 / total_lines).round(1) : 0.0
+      {
+        file: file,
+        total_lines: total_lines,
+        covered_lines: covered_lines,
+        coverage_percent: pct
+      }
+    end.sort_by { |e| e[:file] }
+  end
+
   def self.load_events_json(path)
     JSON.parse(File.read(path))
   end
@@ -629,25 +718,36 @@ module RecordInstrument
     events_from_ids
   end
 
+  KERNEL_INSPECT = ::Kernel.instance_method(:inspect)
+
+  def self.safe_inspect(v)
+    v.inspect
+  rescue ::NoMethodError
+    KERNEL_INSPECT.bind_call(v)
+  end
+
   def self.safe_value(v)
     case v
     when Numeric, TrueClass, FalseClass, NilClass
       v
     else
-      s = v.inspect
+      s = safe_inspect(v)
       s.bytesize > 1000 ? s[0, 1000] + "..." : s
     end
   end
 
+  KERNEL_CLASS = ::Kernel.instance_method(:class)
+
   def self.value_type_name(v)
-    name = v.class.name
-    name && !name.empty? ? name : v.class.to_s
+    klass = KERNEL_CLASS.bind_call(v)
+    name = klass.name
+    name && !name.empty? ? name : klass.to_s
   end
 
   def self.summarize_value(v, type: nil)
     type ||= value_type_name(v)
     preview_limit = 120
-    inspected = v.inspect
+    inspected = safe_inspect(v)
     if inspected.length > preview_limit
       {
         type: type,

data/lib/lumitrace/version.rb

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

data/lib/lumitrace.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "shellwords"
 require "tmpdir"
 require_relative "lumitrace/version"
 require_relative "lumitrace/record_instrument"
@@ -12,6 +13,8 @@ require_relative "lumitrace/ai_docs"
 
 module Lumitrace
   class Error < StandardError; end
+  KERNEL_CLASS = ::Kernel.instance_method(:class)
+
   @atexit_registered = false
   @atexit_output_root = nil
   @atexit_ranges_by_file = nil
@@ -34,6 +37,16 @@ module Lumitrace
     $stderr.puts("[lumitrace] #{message}")
   end
 
+  def self.current_command_text
+    argv0 = $0.to_s
+    args = Array(ARGV).map(&:to_s)
+    parts = []
+    parts << argv0 unless argv0.empty?
+    parts.concat(args)
+    return nil if parts.empty?
+    Shellwords.join(parts)
+  end
+
   def self.normalize_collect_mode(mode)
     m = mode.to_s.strip
     m = "last" if m.empty?
@@ -51,7 +64,7 @@ module Lumitrace
           def R(id, value)
             events_by_id = RecordInstrument.events_by_id
             entry = events_by_id[id]
-            klass = value.class
+            klass = KERNEL_CLASS.bind_call(value)
             type = klass.name
             type = klass.to_s if type.nil? || type.empty?
             if entry
@@ -70,7 +83,7 @@ module Lumitrace
           def R(id, value)
             events_by_id = RecordInstrument.events_by_id
             entry = events_by_id[id]
-            klass = value.class
+            klass = KERNEL_CLASS.bind_call(value)
             type = klass.name
             type = klass.to_s if type.nil? || type.empty?
             if entry
@@ -88,7 +101,7 @@ module Lumitrace
           def R(id, value)
             events_by_id = RecordInstrument.events_by_id
             entry = events_by_id[id]
-            klass = value.class
+            klass = KERNEL_CLASS.bind_call(value)
             type = klass.name
             type = klass.to_s if type.nil? || type.empty?
             if entry
@@ -459,13 +472,22 @@ module Lumitrace
             next
           end
 
+          events_collect_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           events = RecordInstrument.events
+          events_collect_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - events_collect_start) * 1000.0
+          verbose_log(format("events: collect %.1fms count=%d", events_collect_ms, events.length)) if @verbose_level.to_i > 0
+
+          detail_logger = (@verbose_level.to_i > 1 ? method(:verbose_log) : nil)
+
+          events_merge_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           events = RecordInstrument.merge_child_events(
             events,
             @results_dir,
             max_samples: @atexit_max_samples,
-            logger: method(:verbose_log)
+            logger: detail_logger
           )
+          events_merge_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - events_merge_start) * 1000.0
+          verbose_log(format("events: merge_children %.1fms count=%d", events_merge_ms, events.length)) if @verbose_level.to_i > 0
 
           if @atexit_json
             json_path = @atexit_json == true ? "lumitrace_recorded.json" : @atexit_json
@@ -476,7 +498,7 @@ module Lumitrace
           end
           if @atexit_text
             tty = @atexit_text == true ? $stdout.tty? : false
-            text = GenerateResultedHtml.render_text_all_from_events(
+            text = GenerateResultedHtml.render_text_all_from_normalized_events(
               events,
               root: @atexit_output_root,
               ranges_by_file: @atexit_ranges_by_file,
@@ -493,16 +515,23 @@ module Lumitrace
             end
           end
           if @atexit_html
-            html = GenerateResultedHtml.render_all_from_events(
+            html_render_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            html = GenerateResultedHtml.render_all_from_normalized_events(
               events,
               root: @atexit_output_root,
               ranges_by_file: @atexit_ranges_by_file,
               collect_mode: @atexit_collect_mode,
-              max_samples: @atexit_max_samples
+              max_samples: @atexit_max_samples,
+              logger: detail_logger,
+              command_text: current_command_text
             )
+            html_render_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - html_render_start) * 1000.0
             out_path = @atexit_html == true ? "lumitrace_recorded.html" : @atexit_html
             out_path = File.expand_path(out_path, @atexit_output_root)
+            html_write_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             File.write(out_path, html)
+            html_write_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - html_write_start) * 1000.0
+            verbose_log(format("html: render %.1fms write %.1fms bytes=%d", html_render_ms, html_write_ms, html.bytesize)) if @verbose_level.to_i > 0
             verbose_log("html: #{out_path}")
             notify_output_path("html", out_path)
           end