airbnb-ruby-prof 0.0.1

data/lib/ruby-prof/printers/dot_printer.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+
+require 'set'
+
+module RubyProf
+  # Generates a graphviz graph in dot format.
+  # To use the dot printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::DotPrinter.new(result)
+  #   printer.print(STDOUT)
+  #
+  # You can use either dot viewer such as GraphViz, or the dot command line tool
+  # to reformat the output into a wide variety of outputs:
+  #
+  #   dot -Tpng graph.dot > graph.png
+  #
+  class DotPrinter < RubyProf::AbstractPrinter
+    CLASS_COLOR = '"#666666"'
+    EDGE_COLOR  = '"#666666"'
+
+    # Creates the DotPrinter using a RubyProf::Proile.
+    def initialize(result)
+      super(result)
+      @seen_methods = Set.new
+    end
+
+    # Print a graph report to the provided output.
+    #
+    # output - Any IO object, including STDOUT or a file. The default value is
+    # STDOUT.
+    #
+    # options - Hash of print options.  See #setup_options
+    # for more information.
+    #
+    # When profiling results that cover a large number of method calls it
+    # helps to use the :min_percent option, for example:
+    #
+    #   DotPrinter.new(result).print(STDOUT, :min_percent=>5)
+    #
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+
+      puts 'digraph "Profile" {'
+      #puts "label=\"#{mode_name} >=#{min_percent}%\\nTotal: #{total_time}\";"
+      puts "labelloc=t;"
+      puts "labeljust=l;"
+      print_threads
+      puts '}'
+    end
+
+    private
+
+    # Something of a hack, figure out which constant went with the
+    # RubyProf.measure_mode so that we can display it.  Otherwise it's easy to
+    # forget what measurement was made.
+    def mode_name
+      RubyProf.constants.find{|c| RubyProf.const_get(c) == RubyProf.measure_mode}
+    end
+
+    def print_threads
+      @result.threads.each do |thread|
+        puts "subgraph \"Thread #{thread.id}\" {"
+
+        print_thread(thread)
+        puts "}"
+
+        print_classes(thread)
+      end
+    end
+
+    # Determines an ID to use to represent the subject in the Dot file.
+    def dot_id(subject)
+      subject.object_id
+    end
+
+    def print_thread(thread)
+      total_time = thread.total_time
+      thread.methods.sort_by(&sort_method).reverse_each do |method|
+        total_percentage = (method.total_time/total_time) * 100
+
+        next if total_percentage < min_percent
+        name = method_name(method).split("#").last
+        puts "#{dot_id(method)} [label=\"#{name}\\n(#{total_percentage.round}%)\"];"
+        @seen_methods << method
+        print_edges(total_time, method)
+      end
+    end
+
+    def print_classes(thread)
+      grouped = {}
+      thread.methods.each{|m| grouped[m.klass_name] ||= []; grouped[m.klass_name] << m}
+      grouped.each do |cls, methods2|
+        # Filter down to just seen methods
+        big_methods = methods2.select{|m| @seen_methods.include? m}
+
+        if !big_methods.empty?
+          puts "subgraph cluster_#{cls.object_id} {"
+          puts "label = \"#{cls}\";"
+          puts "fontcolor = #{CLASS_COLOR};"
+          puts "fontsize = 16;"
+          puts "color = #{CLASS_COLOR};"
+          big_methods.each do |m|
+            puts "#{m.object_id};"
+          end
+          puts "}"
+        end
+      end
+    end
+
+    def print_edges(total_time, method)
+      method.aggregate_children.sort_by(&:total_time).reverse.each do |child|
+
+        target_percentage = (child.target.total_time / total_time) * 100.0
+        next if target_percentage < min_percent
+
+        # Get children method
+        puts "#{dot_id(method)} -> #{dot_id(child.target)} [label=\"#{child.called}/#{child.target.called}\" fontsize=10 fontcolor=#{EDGE_COLOR}];"
+      end
+    end
+
+    # Silly little helper for printing to the @output
+    def puts(str)
+      @output.puts(str)
+    end
+
+  end
+end

data/lib/ruby-prof/printers/fast_call_tree_printer.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+require 'fiber'
+require 'thread'
+require 'fileutils'
+
+module RubyProf
+  # Optimized implementation of CallTreePrinter
+  class FastCallTreePrinter
+    def initialize(result)
+      @result = result
+      @output = nil
+    end
+
+    # Specify print options.
+    #
+    # options - Hash table
+    #
+    #   :only_threads - list of threads to print
+    def print(output = STDOUT, options = {})
+      @output = output
+      @options = options
+
+      determine_event_specification_and_value_scale
+      print_headers
+      print_threads
+    end
+
+    def determine_event_specification_and_value_scale
+      @value_scales = []
+      @event_specifications = ['events:']
+
+      @result.measure_modes.each do |measure_mode|
+        case measure_mode
+          when RubyProf::PROCESS_TIME
+            @value_scales << RubyProf::CLOCKS_PER_SEC
+            @event_specifications << 'process_time'
+          when RubyProf::WALL_TIME
+            @value_scales << 1_000_000
+            @event_specifications << 'wall_time'
+          when RubyProf.const_defined?(:CPU_TIME) && RubyProf::CPU_TIME
+            @value_scales << RubyProf.cpu_frequency
+            @event_specifications << 'cpu_time'
+          when RubyProf.const_defined?(:ALLOCATIONS) && RubyProf::ALLOCATIONS
+            @value_scales << 1
+            @event_specifications << 'allocations'
+          when RubyProf.const_defined?(:MEMORY) && RubyProf::MEMORY
+            @value_scales << 1
+            @event_specifications << 'memory'
+          when RubyProf.const_defined?(:GC_RUNS) && RubyProf::GC_RUNS
+            @value_scales << 1
+            @event_specifications << 'gc_runs'
+          when RubyProf.const_defined?(:GC_TIME) && RubyProf::GC_TIME
+            @value_scales << 1000000
+            @event_specifications << 'gc_time'
+          else
+            raise "Unknown measure mode: #{measure_mode}"
+        end
+      end
+    end
+
+    def print_threads
+      # TODO: merge fibers of a given thread here, instead of relying
+      # on the profiler to merge fibers.
+      printable_threads.each do |thread|
+        print_thread(thread)
+      end
+    end
+
+    def printable_threads
+      if @options[:only_threads]
+        only_thread_ids = @options[:only_threads].map(&:object_id)
+        @result.threads.select do |t|
+          only_thread_ids.include?(t.id)
+        end
+      else
+        @result.threads
+      end
+    end
+
+    def print_headers
+      @output << "#{@event_specifications.join(" ")}\n\n"
+      # this doesn't work. kcachegrind does not fully support the spec.
+      # output << "thread: #{thread.id}\n\n"
+    end
+  end # end class
+end # end packages

data/lib/ruby-prof/printers/flame_graph_html_printer.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+require 'erb'
+
+module RubyProf
+  class FlameGraphHtmlPrinter < AbstractPrinter
+    include ERB::Util
+
+    def setup_options(options={})
+      super(options)
+
+      ref = 'tmpl.html.erb'
+      template = read_asset(ref)
+      @erb = ERB.new(template)
+      @erb.filename = ref
+    end
+
+    def print(output=STDOUT, options={})
+      @output = output
+      setup_options(options)
+
+      str = @erb.result(binding)
+      @output << str.split("\n").map(&:rstrip).join("\n")
+      @output << "\n"
+    end
+
+    private
+
+    def css_libraries_html
+      read_asset('lib.css.html')
+    end
+
+    def js_libraries_html
+      read_asset('lib.js.html')
+    end
+
+    def js_code_html
+      read_asset('page.js.html')
+    end
+
+    def js_data_html
+      "<script type=\"text/javascript\">\n\n" \
+        "var data = #{data_json};\n\n" \
+        "</script>\n"
+    end
+
+    def data_json
+      StringIO.new.tap { |strio|
+        jp = FlameGraphJsonPrinter.new(@result)
+        jp.print(strio, @options)
+      }.string
+    end
+
+    def read_asset(ref)
+      base_path = File.expand_path('../../assets', __FILE__)
+      file_path = File.join(base_path, "flame_graph_printer.#{ref}")
+      File.open(file_path, 'rb').read.strip.untaint
+    end
+  end
+end

data/lib/ruby-prof/printers/flame_graph_json_printer.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+
+module RubyProf
+  class FlameGraphJsonPrinter < AbstractPrinter
+    def min_percent
+      @options[:min_percent] || 0.25
+    end
+
+    def min_self_time
+      @options[:min_self_time] || 0.001
+    end
+
+    def only_threads
+      @options[:only_threads]
+    end
+
+    def print_threads
+      @threads = @result.threads.dup
+      @threads.select! { |t| only_thread_ids.include?(t.id) } if only_threads
+
+      walker = FlameDataWalker.new(@output, @threads, {
+        min_percent: min_percent,
+        min_self_time: min_self_time
+      })
+
+      @output << "{\n"
+      @output << "  \"root\": "
+
+      walker.run
+
+      @output << ",\n"
+      @output << "  \"depth\": #{walker.height}\n"
+      @output << "}"
+    end
+
+    private
+
+    def only_thread_ids
+      only_threads && only_threads.map(&:object_id)
+    end
+
+    class FlameDataWalker < RubyProf::Walker
+      attr_reader :output
+      attr_reader :height
+
+      def initialize(output, threads, options={})
+        super(threads, options)
+        @output = output
+
+        @printer = FlameDataJsonPrinter.new(@output, {
+          depth: 1,
+          anchored: false
+        })
+
+        @height = 0
+        @depth = 0
+      end
+
+      def enter_frame(type, obj, name, called, self_value, total_value)
+        @depth += 1
+        @height = @depth if @height < @depth
+        @printer.enter(name, called, self_value, total_value)
+      end
+
+      def leave_frame(type, obj)
+        @printer.leave
+        @depth -= 1
+      end
+    end
+
+    class FlameDataJsonPrinter
+      attr_reader :output
+
+      def initialize(output, options={})
+        @output = output
+        @depth = options[:depth] || 0
+        @anchored = options.fetch(:anchored, false)
+        @pretty = options.fetch(:pretty, false)
+        @state = :root
+        update_layout
+      end
+
+      def enter(name, called, self_value, total_value)
+        case @state
+        when :enter
+          put_line ","
+          put_part "\"children\": ["
+          step_in(:enter)
+        when :leave
+          put_part ", "
+        end
+
+        put_line "{"
+        step_in(:enter)
+        put_line "\"name\": \"#{name}\","
+        put_line "\"called\": #{called},"
+        put_line "\"lost\": #{self_value},"
+        put_part "\"value\": #{total_value}"
+      end
+
+      def leave
+        case @state
+        when :enter
+          new_line
+        when :leave
+          step_out(:leave)
+          put_line "]"
+        end
+
+        step_out(:leave)
+        put_part "}"
+      end
+
+      private
+
+      def put_part(str)
+        @output << @indent if @anchored
+        @output << str
+        @anchored = false
+      end
+
+      def put_line(str)
+        @output << @indent if @anchored
+        @output << str
+        @output << @break
+        @anchored = true
+      end
+
+      def new_line
+        @output << @break if !@anchored
+        @anchored = true
+      end
+
+      def step_in(new_state)
+        @state = new_state
+        @depth += 1
+        update_layout
+      end
+
+      def step_out(new_state)
+        @state = new_state
+        @depth -=1
+        update_layout
+      end
+
+      def update_layout
+        if @pretty
+          @break = "\n"
+          @indent = ""
+        else
+          @break = " "
+          @indent = ""
+        end
+      end
+    end
+  end
+end

data/lib/ruby-prof/printers/flat_printer.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+module RubyProf
+  # Generates flat[link:files/examples/flat_txt.html] profile reports as text.
+  # To use the flat printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::FlatPrinter.new(result)
+  #   printer.print(STDOUT, {})
+  #
+  class FlatPrinter < AbstractPrinter
+    # Override for this printer to sort by self time by default
+    def sort_method
+      @options[:sort_method] || :self_time
+    end
+
+    private
+
+    #def print_threads
+    #  @result.threads.each do |thread|
+    #    print_thread(thread)
+    #    @output << "\n" * 2
+    #  end
+    #end
+
+    def print_header(thread)
+      @output << "Measure Mode: %s\n" % RubyProf.measure_mode_string
+      @output << "Thread ID: %d\n" % thread.id
+      @output << "Fiber ID: %d\n" % thread.fiber_id unless thread.id == thread.fiber_id
+      @output << "Total: %0.6f\n" % thread.total_time
+      @output << "Sort by: #{sort_method}\n"
+      @output << "\n"
+      @output << " %self      total      self      wait     child     calls  name\n"
+    end
+
+    def print_methods(thread)
+      total_time = thread.total_time
+      methods = thread.methods.sort_by(&sort_method).reverse
+
+      sum = 0
+      methods.each do |method|
+        self_percent = (method.self_time / total_time) * 100
+        next if self_percent < min_percent
+
+        sum += method.self_time
+        #self_time_called = method.called > 0 ? method.self_time/method.called : 0
+        #total_time_called = method.called > 0? method.total_time/method.called : 0
+
+        @output << "%6.2f  %9.3f %9.3f %9.3f %9.3f %8d  %s%s\n" % [
+                      method.self_time / total_time * 100, # %self
+                      method.total_time,                   # total
+                      method.self_time,                    # self
+                      method.wait_time,                    # wait
+                      method.children_time,                # children
+                      method.called,                       # calls
+                      method.recursive? ? "*" : " ",       # cycle
+                      method_name(method)                  # name
+                  ]
+      end
+    end
+
+    def print_footer(thread)
+      @output << "\n"
+      @output << "* indicates recursively called methods\n"
+    end
+  end
+end