ruby-prof 0.18.0-x64-mingw32

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

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module RubyProf
+  # Helper class to simplify printing profiles of several types from
+  # one profiling run. Currently prints a flat profile, a callgrind
+  # profile, a call stack profile and a graph profile.
+  class MultiPrinter
+    def initialize(result, printers = [:stack, :graph, :tree, :flat])
+      @stack_printer = CallStackPrinter.new(result) if printers.include?(:stack)
+      @graph_printer = GraphHtmlPrinter.new(result) if printers.include?(:graph)
+      @tree_printer = CallTreePrinter.new(result) if printers.include?(:tree)
+      @flat_printer = FlatPrinter.new(result) if printers.include?(:flat)
+    end
+
+    def self.needs_dir?
+      true
+    end
+
+    # create profile files under options[:path] or the current
+    # directory. options[:profile] is used as the base name for the
+    # pofile file, defaults to "profile".
+    def print(options)
+      validate_print_params(options)
+
+      @profile = options.delete(:profile) || "profile"
+      @directory = options.delete(:path) || File.expand_path(".")
+
+      print_to_stack(options) if @stack_printer
+      print_to_graph(options) if @graph_printer
+      print_to_tree(options) if @tree_printer
+      print_to_flat(options) if @flat_printer
+    end
+
+    # the name of the call stack profile file
+    def stack_profile
+      "#{@directory}/#{@profile}.stack.html"
+    end
+
+    # the name of the graph profile file
+    def graph_profile
+      "#{@directory}/#{@profile}.graph.html"
+    end
+
+    # the name of the callgrind profile file
+    def tree_profile
+      "#{@directory}/#{@profile}.callgrind.out.#{$$}"
+    end
+
+    # the name of the flat profile file
+    def flat_profile
+      "#{@directory}/#{@profile}.flat.txt"
+    end
+
+    def print_to_stack(options)
+      File.open(stack_profile, "w") do |f|
+        @stack_printer.print(f, options.merge(:graph => "#{@profile}.graph.html"))
+      end
+    end
+
+    def print_to_graph(options)
+      File.open(graph_profile, "w") do |f|
+        @graph_printer.print(f, options)
+      end
+    end
+
+    def print_to_tree(options)
+      @tree_printer.print(options.merge(:path => @directory, :profile => @profile))
+    end
+
+    def print_to_flat(options)
+      File.open(flat_profile, "w") do |f|
+        @flat_printer.print(f, options)
+      end
+    end
+
+    def validate_print_params(options)
+      if options.is_a?(IO)
+        raise ArgumentError, "#{self.class.name}#print cannot print to IO objects"
+      elsif !options.is_a?(Hash)
+        raise ArgumentError, "#{self.class.name}#print requires an options hash"
+      end
+    end
+  end
+end

data/lib/ruby-prof/profile.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'ruby-prof/profile/exclude_common_methods'
+require 'ruby-prof/profile/legacy_method_elimination'
+
+module RubyProf
+  class Profile
+    include LegacyMethodElimination
+
+    # Hides methods that, when represented as a call graph, have
+    # extremely large in and out degrees and make navigation impossible.
+    def exclude_common_methods!
+      ExcludeCommonMethods.apply!(self)
+    end
+
+    def exclude_methods!(mod, *method_or_methods)
+      [method_or_methods].flatten.each do |name|
+        exclude_method!(mod, name)
+      end
+    end
+
+    def exclude_singleton_methods!(mod, *method_or_methods)
+      exclude_methods!(mod.singleton_class, *method_or_methods)
+    end
+  end
+end

data/lib/ruby-prof/profile/exclude_common_methods.rb

@@ -0,0 +1,207 @@
+require 'set'
+
+module RubyProf
+  class Profile
+    class ExcludeCommonMethods
+      ENUMERABLE_NAMES = Enumerable.instance_methods(false)
+
+      def self.apply!(profile)
+        new(profile).apply!
+      end
+
+      def initialize(profile)
+        @profile = profile
+      end
+
+      def apply!
+        ##
+        #  Kernel Methods
+        ##
+
+        exclude_methods Kernel, [
+          :dup,
+          :initialize_dup,
+          :tap,
+          :send,
+          :public_send,
+        ]
+
+        ##
+        #  Fundamental Types
+        ##
+
+        exclude_methods BasicObject,  :"!="
+        exclude_methods Method,       :"[]"
+        exclude_methods Module,       :new
+        exclude_methods Class,        :new
+        exclude_methods Proc,         :call, :yield
+        exclude_methods Range,        :each
+        exclude_methods Integer,      :times
+
+        ##
+        #  Value Types
+        ##
+
+        exclude_methods String, [
+          :sub,
+          :sub!,
+          :gsub,
+          :gsub!,
+        ]
+
+        ##
+        #  Emumerables
+        ##
+
+        exclude_enumerable Enumerable
+        exclude_enumerable Enumerator
+
+        ##
+        #  Collections
+        ##
+
+        exclude_enumerable Array, [
+          :each_index,
+          :map!,
+          :select!,
+          :reject!,
+          :collect!,
+          :sort!,
+          :sort_by!,
+          :index,
+          :delete_if,
+          :keep_if,
+          :drop_while,
+          :uniq,
+          :uniq!,
+          :"==",
+          :eql?,
+          :hash,
+          :to_json,
+          :as_json,
+          :encode_json,
+        ]
+
+        exclude_enumerable Hash, [
+          :dup,
+          :initialize_dup,
+          :fetch,
+          :"[]",
+          :"[]=",
+          :each_key,
+          :each_value,
+          :each_pair,
+          :map!,
+          :select!,
+          :reject!,
+          :collect!,
+          :delete_if,
+          :keep_if,
+          :slice,
+          :slice!,
+          :except,
+          :except!,
+          :"==",
+          :eql?,
+          :hash,
+          :to_json,
+          :as_json,
+          :encode_json,
+        ]
+
+        exclude_enumerable Set, [
+          :map!,
+          :select!,
+          :reject!,
+          :collect!,
+          :classify,
+          :delete_if,
+          :keep_if,
+          :divide,
+          :"==",
+          :eql?,
+          :hash,
+          :to_json,
+          :as_json,
+          :encode_json,
+        ]
+
+        ##
+        #  Garbage Collection
+        ##
+
+        exclude_singleton_methods GC, [
+          :start
+        ]
+
+        ##
+        #  Unicorn
+        ##
+
+        if defined?(Unicorn)
+          exclude_methods Unicorn::HttpServer, :process_client
+        end
+
+        if defined?(Unicorn::OobGC)
+          exclude_methods Unicorn::OobGC, :process_client
+        end
+
+        ##
+        #  New Relic
+        ##
+
+        if defined?(NewRelic::Agent)
+          if defined?(NewRelic::Agent::Instrumentation::MiddlewareTracing)
+            exclude_methods NewRelic::Agent::Instrumentation::MiddlewareTracing, [
+              :call
+            ]
+          end
+
+          if defined?(NewRelic::Agent::MethodTracerHelpers)
+            exclude_methods NewRelic::Agent::MethodTracerHelpers, [
+              :trace_execution_scoped,
+              :log_errors,
+            ]
+
+            exclude_singleton_methods NewRelic::Agent::MethodTracerHelpers, [
+              :trace_execution_scoped,
+              :log_errors,
+            ]
+          end
+
+          if defined?(NewRelic::Agent::MethodTracer)
+            exclude_methods NewRelic::Agent::MethodTracer, [
+              :trace_execution_scoped,
+              :trace_execution_unscoped,
+            ]
+          end
+        end
+
+          ##
+          #  Miscellaneous Methods
+          ##
+
+        if defined?(Mustache)
+          exclude_methods Mustache::Context, [
+            :fetch
+          ]
+        end
+      end
+
+      private
+
+      def exclude_methods(mod, *method_or_methods)
+        @profile.exclude_methods!(mod, method_or_methods)
+      end
+
+      def exclude_singleton_methods(mod, *method_or_methods)
+        @profile.exclude_singleton_methods!(mod, method_or_methods)
+      end
+
+      def exclude_enumerable(mod, *method_or_methods)
+        exclude_methods(mod, [:each, *method_or_methods])
+        exclude_methods(mod, ENUMERABLE_NAMES)
+      end
+    end
+  end
+end

data/lib/ruby-prof/profile/legacy_method_elimination.rb

@@ -0,0 +1,50 @@
+module RubyProf
+  class Profile
+    module LegacyMethodElimination
+      # eliminate some calls from the graph by merging the information into callers.
+      # matchers can be a list of strings or regular expressions or the name of a file containing regexps.
+      def eliminate_methods!(matchers)
+        RubyProf.deprecation_warning(
+          "Method 'eliminate_methods!' is deprecated",
+          "Please call 'exclude_methods!' before starting the profile run instead."
+        )
+        matchers = read_regexps_from_file(matchers) if matchers.is_a?(String)
+        eliminated = []
+        threads.each do |thread|
+          matchers.each{ |matcher| eliminated.concat(eliminate_methods(thread.methods, matcher)) }
+        end
+        eliminated
+      end
+
+      private
+
+      # read regexps from file
+      def read_regexps_from_file(file_name)
+        matchers = []
+        File.open(file_name).each_line do |l|
+          next if (l =~ /^(#.*|\s*)$/) # emtpy lines and lines starting with #
+          matchers << Regexp.new(l.strip)
+        end
+        matchers
+      end
+
+      # eliminate methods matching matcher
+      def eliminate_methods(methods, matcher)
+        eliminated = []
+        i = 0
+        while i < methods.size
+          method_info = methods[i]
+          method_name = method_info.full_name
+          if matcher === method_name
+            raise "can't eliminate root method" if method_info.root?
+            eliminated << methods.delete_at(i)
+            method_info.eliminate!
+          else
+            i += 1
+          end
+        end
+        eliminated
+      end
+    end
+  end
+end

data/lib/ruby-prof/rack.rb

@@ -0,0 +1,174 @@
+# encoding: utf-8
+require 'tmpdir'
+
+module Rack
+  class RubyProf
+    def initialize(app, options = {})
+      @app = app
+
+      options[:min_percent] ||= 1
+
+      options[:path] ||= Dir.tmpdir
+      FileUtils.mkdir_p(options[:path])
+
+      @skip_paths = options[:skip_paths] || [%r{^/assets}, %r{\.(css|js|png|jpeg|jpg|gif)$}]
+      @only_paths = options[:only_paths]
+
+      @max_requests = options[:max_requests]
+
+      @options = options
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      if should_profile?(request.path)
+        profiler.resume
+        begin
+          result = @app.call(env)
+        ensure
+          profiler.pause
+        end
+
+        if profiler.max_requests_reached?
+          prefix = if aggregate_requests?
+              nil
+            else
+              request.path.gsub('/', '-')[1..-1]
+            end
+
+          profiler.print!(prefix)
+          delete_profiler!
+        end
+
+        result
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    class RackProfiler
+      def initialize(options)
+        @options = options
+
+        @profile = ::RubyProf::Profile.new(profiling_options)
+        @profile.start
+        @profile.pause
+
+        @printer_klasses = options[:printers] || default_printers
+
+        @tmpdir = options[:path]
+
+        @max_requests = options[:max_requests] || 1
+        @requests_count = 0
+
+        @printed = false
+        # if running across multiple requests, we want to make sure that the
+        # ongoing profile is not lost if the process shuts down before the
+        # max request count is reached
+        ObjectSpace.define_finalizer(self, proc { print! })
+      end
+
+      def resume
+        @profile.resume
+      end
+
+      def pause
+        @profile.pause
+        @requests_count += 1
+      end
+
+      def max_requests_reached?
+        @requests_count >= @max_requests
+      end
+
+      def print!(prefix = nil)
+        return false if @printed || @requests_count == 0
+
+        data = @profile.stop
+
+        prefix ||= "multi-requests-#{@requests_count}"
+
+        @printer_klasses.each do |printer_klass, base_name|
+          printer = printer_klass.new(data)
+
+          if base_name.respond_to?(:call)
+            base_name = base_name.call
+          end
+
+          if printer_klass == ::RubyProf::MultiPrinter \
+              || printer_klass == ::RubyProf::CallTreePrinter
+            printer.print(@options.merge(:profile => "#{prefix}-#{base_name}"))
+          else
+            file_name = ::File.join(@tmpdir, "#{prefix}-#{base_name}")
+            ::File.open(file_name, 'wb') do |file|
+              printer.print(file, @options)
+            end
+          end
+        end
+
+        @printed = true
+      end
+
+      private
+
+      def profiling_options
+        options = {}
+        options[:measure_mode] = ::RubyProf.measure_mode
+        options[:exclude_threads] =
+          if @options[:ignore_existing_threads]
+            Thread.list.select{|t| t != Thread.current}
+          else
+            ::RubyProf.exclude_threads
+          end
+        if @options[:request_thread_only]
+          options[:include_threads] = [Thread.current]
+        end
+        if @options[:merge_fibers]
+          options[:merge_fibers] = true
+        end
+        options
+      end
+
+      def default_printers
+        {::RubyProf::FlatPrinter => 'flat.txt',
+         ::RubyProf::GraphPrinter => 'graph.txt',
+         ::RubyProf::GraphHtmlPrinter => 'graph.html',
+         ::RubyProf::CallStackPrinter => 'call_stack.html'}
+      end
+    end
+
+    def profiler
+      if aggregate_requests?
+        @@_shared_profiler ||= RackProfiler.new(@options)
+      else
+        @_profiler ||= RackProfiler.new(@options)
+      end
+    end
+
+    def delete_profiler!
+      if aggregate_requests?
+        @@_shared_profiler.print! if @@_shared_profiler
+        @@_shared_profiler = nil
+      else
+        @_profiler = nil
+      end
+    end
+
+    def aggregate_requests?
+      !@max_requests.nil?
+    end
+
+    def should_profile?(path)
+      return false if paths_match?(path, @skip_paths)
+
+      @only_paths ? paths_match?(path, @only_paths) : true
+    end
+
+    def paths_match?(path, paths)
+      paths.any? { |skip_path| skip_path =~ path }
+    end
+  end
+end