lumitrace 0.4.2 → 0.5.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

data/lib/lumitrace/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lumitrace
-  VERSION = "0.4.2"
+  VERSION = "0.5.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"
@@ -34,6 +35,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?
@@ -459,13 +470,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 +496,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 +513,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