hone 0.1.0

data/lib/hone/profilers/factory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hone
+  module Profilers
+    class Factory
+      DETECTORS = [
+        [Vernier, ->(data) { data.key?("threads") }],
+        [StackProf, ->(data) { data.key?("frames") || data.key?("methods") }]
+      ].freeze
+
+      def self.create(profile_path)
+        return nil if profile_path.nil?
+
+        data = JSON.parse(File.read(profile_path))
+        profiler_class = detect_profiler(data)
+
+        raise Hone::Error, "Unknown profile format in #{profile_path}" unless profiler_class
+
+        profiler_class.new(profile_path)
+      rescue JSON::ParserError => e
+        raise Hone::Error, "Invalid profile JSON: #{e.message}"
+      end
+
+      def self.detect_profiler(data)
+        DETECTORS.find { |_, detector| detector.call(data) }&.first
+      end
+    end
+  end
+end

data/lib/hone/profilers/memory_profiler.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Hone
+  module Profilers
+    class MemoryProfiler < Base
+      include MethodMatching
+
+      def initialize(profile_path)
+        super
+
+        parse_allocations
+      end
+
+      # Returns CPU percentage for a method (0.0-100.0)
+      # Always returns nil for MemoryProfiler since it tracks allocations, not CPU
+      def cpu_percent_for(_method_info)
+        nil
+      end
+
+      # Returns allocation percentage for a method (0.0-100.0)
+      # method_info can be a Hash with :name and/or :file keys, or a String method name
+      def alloc_percent_for(method_info)
+        frame = find_matching_frame(method_info)
+        return nil unless frame
+
+        frame[:alloc_percent]
+      end
+
+      # Returns array of HotspotInfo for frames above threshold
+      # For MemoryProfiler, threshold applies to allocation percentage
+      def hotspots(threshold: 1.0)
+        @frames
+          .select { |frame| frame[:alloc_percent] >= threshold }
+          .sort_by { |frame| -frame[:alloc_percent] }
+          .map { |frame| build_hotspot_info(frame) }
+      end
+
+      private
+
+      def parse_allocations
+        @frames = []
+        @total_allocations = 0
+
+        # MemoryProfiler can output in various formats
+        # Common structures include allocated_memory_by_location, allocated_objects_by_location
+        allocation_data = extract_allocation_data
+
+        # Calculate total allocations for percentage
+        @total_allocations = allocation_data.values.sum { |info| info[:count] }
+        @total_allocations = 1 if @total_allocations.zero?
+
+        # Build frames array from allocation data
+        allocation_data.each do |location, info|
+          alloc_percent = (info[:count].to_f / @total_allocations * 100).round(2)
+
+          @frames << {
+            name: info[:name],
+            file: info[:file],
+            line: info[:line],
+            samples: info[:count],
+            alloc_percent: alloc_percent,
+            cpu_percent: nil,
+            memory_allocated: info[:memory_allocated]
+          }
+        end
+
+        @frames.sort_by! { |f| -f[:alloc_percent] }
+      end
+
+      def extract_allocation_data
+        allocation_data = {}
+
+        # Try different MemoryProfiler output formats
+        if @data["allocated_objects_by_location"]
+          parse_by_location(@data["allocated_objects_by_location"], allocation_data)
+        elsif @data["allocated_memory_by_location"]
+          parse_by_location(@data["allocated_memory_by_location"], allocation_data, memory: true)
+        elsif @data["allocations"]
+          parse_allocations_array(@data["allocations"], allocation_data)
+        elsif @data["allocated_objects_by_gem"]
+          # Fallback to gem-level data if location data not available
+          parse_by_gem(@data["allocated_objects_by_gem"], allocation_data)
+        else
+          # Try to parse as raw location-based data
+          parse_raw_data(allocation_data)
+        end
+
+        allocation_data
+      end
+
+      def parse_by_location(location_data, allocation_data, memory: false)
+        location_data.each do |entry|
+          location = entry["location"] || entry["data"]
+          # Support both object count and byte count formats
+          count = entry["count"] || entry["value"] || entry["bytes"] || 1
+          memory_allocated = entry["memory"] || entry["memsize"] || entry["bytes"] || 0
+
+          file, line, name = parse_location(location)
+          key = "#{file}:#{line}"
+
+          if allocation_data[key]
+            allocation_data[key][:count] += count
+            allocation_data[key][:memory_allocated] += memory_allocated
+          else
+            allocation_data[key] = {
+              name: name,
+              file: file,
+              line: line,
+              count: count,
+              memory_allocated: memory_allocated
+            }
+          end
+        end
+      end
+
+      def parse_allocations_array(allocations, allocation_data)
+        allocations.each do |entry|
+          file = entry["file"] || entry["sourcefile"]
+          line = entry["line"] || entry["sourceline"]
+          name = entry["name"] || entry["class_name"] || entry["method"] || "#{file}:#{line}"
+          count = entry["count"] || entry["allocations"] || 1
+          memory_allocated = entry["memory"] || entry["memsize"] || entry["size"] || 0
+
+          key = "#{file}:#{line}"
+
+          if allocation_data[key]
+            allocation_data[key][:count] += count
+            allocation_data[key][:memory_allocated] += memory_allocated
+          else
+            allocation_data[key] = {
+              name: name,
+              file: file,
+              line: line.to_i,
+              count: count,
+              memory_allocated: memory_allocated
+            }
+          end
+        end
+      end
+
+      def parse_by_gem(gem_data, allocation_data)
+        gem_data.each do |entry|
+          gem_name = entry["gem"] || entry["data"] || "unknown"
+          count = entry["count"] || entry["value"] || 1
+
+          allocation_data[gem_name] = {
+            name: gem_name,
+            file: nil,
+            line: nil,
+            count: count,
+            memory_allocated: 0
+          }
+        end
+      end
+
+      def parse_raw_data(allocation_data)
+        # Handle case where data is a simple hash of location => count
+        @data.each do |key, value|
+          next unless value.is_a?(Integer) || value.is_a?(Hash)
+
+          if value.is_a?(Integer)
+            file, line, name = parse_location(key)
+            allocation_data[key] = {
+              name: name,
+              file: file,
+              line: line,
+              count: value,
+              memory_allocated: 0
+            }
+          elsif value.is_a?(Hash) && (value["count"] || value["allocations"])
+            file, line, name = parse_location(key)
+            allocation_data[key] = {
+              name: name,
+              file: file,
+              line: line,
+              count: value["count"] || value["allocations"] || 1,
+              memory_allocated: value["memory"] || value["memsize"] || 0
+            }
+          end
+        end
+      end
+
+      def parse_location(location)
+        return [nil, nil, location] unless location.is_a?(String)
+
+        # MemoryProfiler location format is typically "file:line" or "file:line:in `method'"
+        if location =~ /^(.+):(\d+)(?::in `(.+)')?$/
+          file = ::Regexp.last_match(1)
+          line = ::Regexp.last_match(2).to_i
+          method_name = ::Regexp.last_match(3)
+
+          name = method_name || "#{File.basename(file)}:#{line}"
+          [file, line, name]
+        else
+          [location, nil, location]
+        end
+      end
+
+      def build_hotspot_info(frame)
+        # Note: HotspotInfo.cpu_percent is used for allocation percentage here.
+        # The HotspotInfo structure is shared across profiler types and represents
+        # "impact percentage" - CPU for StackProf/Vernier, allocations for MemoryProfiler.
+        HotspotInfo.new(
+          name: frame[:name],
+          file: frame[:file],
+          line: frame[:line],
+          cpu_percent: frame[:alloc_percent],
+          samples: frame[:samples]
+        )
+      end
+    end
+  end
+end

data/lib/hone/profilers/stackprof.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Hone
+  module Profilers
+    class StackProf < Base
+      include MethodMatching
+
+      def initialize(profile_path)
+        super
+
+        # Prefer ruby_samples (excludes C frames) for more accurate Ruby percentages
+        @total_samples = @data["ruby_samples"] || @data["samples"] || calculate_total_samples
+        parse_frames
+      end
+
+      # Returns CPU percentage for a method (0.0-100.0)
+      # method_info can be a Hash with :name and/or :file keys, or a String method name
+      def cpu_percent_for(method_info)
+        frame = find_matching_frame(method_info)
+        return nil unless frame
+
+        frame[:cpu_percent]
+      end
+
+      # Returns array of HotspotInfo for frames above threshold
+      def hotspots(threshold: 1.0)
+        @frames
+          .select { |frame| frame[:cpu_percent] >= threshold }
+          .sort_by { |frame| -frame[:cpu_percent] }
+          .map { |frame| build_hotspot_info(frame) }
+      end
+
+      private
+
+      def parse_frames
+        @frames = []
+
+        if @data["frames"]
+          # Raw StackProf JSON format: frames is a hash with address keys
+          @data["frames"].each_value do |frame_data|
+            @frames << parse_frame_data(frame_data)
+          end
+        elsif @data["methods"]
+          # Pre-processed Hone format: methods is an array
+          @data["methods"].each do |method_data|
+            @frames << parse_method_data(method_data)
+          end
+        end
+
+        @frames.sort_by! { |f| -f[:cpu_percent] }
+      end
+
+      def parse_frame_data(frame_data)
+        samples = frame_data["samples"] || 0
+        cpu_percent = calculate_percent(samples)
+
+        {
+          name: frame_data["name"],
+          file: frame_data["file"],
+          line: frame_data["line"],
+          samples: samples,
+          total_samples: frame_data["total_samples"] || 0,
+          cpu_percent: cpu_percent
+        }
+      end
+
+      def parse_method_data(method_data)
+        samples = method_data["samples"] || 0
+        # Use pre-calculated percent if available, otherwise calculate
+        cpu_percent = method_data["percent"] || calculate_percent(samples)
+
+        {
+          name: method_data["name"],
+          file: method_data["file"],
+          line: method_data["line"],
+          samples: samples,
+          total_samples: method_data["total_samples"] || 0,
+          cpu_percent: cpu_percent.to_f
+        }
+      end
+
+      def calculate_total_samples
+        if @data["frames"]
+          @data["frames"].values.sum { |f| f["samples"] || 0 }
+        elsif @data["methods"]
+          @data["methods"].sum { |m| m["samples"] || 0 }
+        else
+          1 # Avoid division by zero
+        end
+      end
+
+      def calculate_percent(samples)
+        return 0.0 if @total_samples.zero?
+
+        (samples.to_f / @total_samples * 100).round(2)
+      end
+    end
+  end
+end

data/lib/hone/profilers/vernier.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Hone
+  module Profilers
+    class Vernier < Base
+      include MethodMatching
+
+      def initialize(profile_path)
+        super
+
+        parse_profile
+      end
+
+      # Returns CPU percentage for a method (0.0-100.0)
+      # method_info can be a Hash with :name and/or :file keys, or a String method name
+      def cpu_percent_for(method_info)
+        frame = find_matching_frame(method_info)
+        return nil unless frame
+
+        frame[:cpu_percent]
+      end
+
+      # Returns array of HotspotInfo for frames above threshold
+      def hotspots(threshold: 1.0)
+        @frames
+          .select { |frame| frame[:cpu_percent] >= threshold }
+          .sort_by { |frame| -frame[:cpu_percent] }
+          .map { |frame| build_hotspot_info(frame) }
+      end
+
+      private
+
+      def parse_profile
+        @frames = []
+        @total_samples = 0
+
+        # Vernier uses Firefox Profiler format
+        # The structure has: threads[], each with frameTable, funcTable, stackTable, samples
+        threads = @data["threads"] || []
+
+        # Aggregate samples across all threads
+        frame_samples = Hash.new(0)
+        frame_info = {}
+
+        threads.each do |thread|
+          parse_thread(thread, frame_samples, frame_info)
+        end
+
+        # Calculate total samples for percentage calculation
+        @total_samples = frame_samples.values.sum
+        @total_samples = 1 if @total_samples.zero?
+
+        # Build frames array
+        frame_samples.each do |frame_key, samples|
+          info = frame_info[frame_key]
+          cpu_percent = (samples.to_f / @total_samples * 100).round(2)
+
+          @frames << {
+            name: info[:name],
+            file: info[:file],
+            line: info[:line],
+            samples: samples,
+            cpu_percent: cpu_percent
+          }
+        end
+
+        @frames.sort_by! { |f| -f[:cpu_percent] }
+      end
+
+      def parse_thread(thread, frame_samples, frame_info)
+        frame_table = thread["frameTable"] || {}
+        func_table = thread["funcTable"] || {}
+        stack_table = thread["stackTable"] || {}
+        samples = thread["samples"] || {}
+
+        # Extract frame data arrays (Firefox Profiler format uses arrays)
+        frame_funcs = frame_table["func"] || []
+        frame_lines = frame_table["line"] || []
+
+        func_names = func_table["name"] || []
+        func_files = func_table["fileName"] || []
+        func_lines = func_table["lineNumber"] || []
+
+        # String table for resolving indices to actual strings
+        string_table = @data["stringTable"] || thread["stringTable"] || []
+
+        # Stack table: prefix and frame arrays define the stack structure
+        stack_prefixes = stack_table["prefix"] || []
+        stack_frames = stack_table["frame"] || []
+
+        # Samples: stack indices for each sample
+        sample_stacks = samples["stack"] || []
+
+        # Count samples per frame
+        sample_stacks.each do |stack_idx|
+          next if stack_idx.nil?
+
+          # Walk up the stack and count each frame
+          counted_frames = Set.new
+          current_stack = stack_idx
+
+          while current_stack && current_stack >= 0 && current_stack < stack_frames.size
+            frame_idx = stack_frames[current_stack]
+
+            # Only count each frame once per sample (avoid double-counting in recursion)
+            unless counted_frames.include?(frame_idx)
+              counted_frames.add(frame_idx)
+
+              # Get function info for this frame
+              func_idx = frame_funcs[frame_idx] if frame_idx && frame_idx < frame_funcs.size
+
+              if func_idx && func_idx < func_names.size
+                name_idx = func_names[func_idx]
+                file_idx = func_files[func_idx] if func_files
+                line = func_lines[func_idx] if func_lines
+
+                name = resolve_string(string_table, name_idx)
+                file = resolve_string(string_table, file_idx)
+
+                # Use frame line if available, otherwise function line
+                frame_line = frame_lines[frame_idx] if frame_idx && frame_idx < frame_lines.size
+                line = frame_line if frame_line && frame_line > 0
+
+                frame_key = "#{name}:#{file}:#{line}"
+                frame_samples[frame_key] += 1
+                frame_info[frame_key] ||= {name: name, file: file, line: line}
+              end
+            end
+
+            # Move to parent stack
+            prefix = stack_prefixes[current_stack]
+            current_stack = prefix
+          end
+        end
+      end
+
+      def resolve_string(string_table, index)
+        return nil if index.nil?
+        return index if index.is_a?(String)
+
+        string_table[index] if index >= 0 && index < string_table.size
+      end
+    end
+  end
+end