airbnb-ruby-prof 0.0.1

data/lib/ruby-prof/profile.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'ruby-prof/profile/exclude_common_methods'
+module RubyProf
+  class Profile
+    # 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,201 @@
+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)
+          exclude_methods NewRelic::Agent::Instrumentation::MiddlewareTracing, [
+            :call
+          ]
+
+          exclude_methods NewRelic::Agent::MethodTracerHelpers, [
+            :trace_execution_scoped,
+            :log_errors,
+          ]
+
+          exclude_singleton_methods NewRelic::Agent::MethodTracerHelpers, [
+            :trace_execution_scoped,
+            :log_errors,
+          ]
+
+          exclude_methods NewRelic::Agent::MethodTracer, [
+            :trace_execution_scoped,
+            :trace_execution_unscoped,
+          ]
+        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/rack.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+require 'tmpdir'
+
+module Rack
+  class RubyProf
+    def initialize(app, options = {})
+      @app = app
+      @options = options
+      @options[:min_percent] ||= 1
+
+      @tmpdir = options[:path] || Dir.tmpdir
+      FileUtils.mkdir_p(@tmpdir)
+
+      @printer_klasses = @options[:printers]  || {::RubyProf::FlatPrinter => 'flat.txt',
+                                                  ::RubyProf::GraphPrinter => 'graph.txt',
+                                                  ::RubyProf::GraphHtmlPrinter => 'graph.html',
+                                                  ::RubyProf::CallStackPrinter => 'call_stack.html'}
+
+      @skip_paths = options[:skip_paths] || [%r{^/assets}, %r{\.(css|js|png|jpeg|jpg|gif)$}]
+      @only_paths = options[:only_paths]
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      if should_profile?(request.path)
+        begin
+          result = nil
+          data = ::RubyProf::Profile.profile(profiling_options) do
+            result = @app.call(env)
+          end
+
+          path = request.path.gsub('/', '-')
+          path.slice!(0)
+
+          print(data, path)
+          result
+        end
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    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
+
+    def profiling_options
+      options = {}
+      options[:measure_modes] = [::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 print(data, path)
+      @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.print(@options.merge(:profile => "#{path}-#{base_name}"))
+        elsif printer_klass == ::RubyProf::CallTreePrinter
+          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+        else
+          file_name = ::File.join(@tmpdir, "#{path}-#{base_name}")
+          ::File.open(file_name, 'wb') do |file|
+            printer.print(file, @options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby-prof/task.rb

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'rake'
+require 'rake/testtask'
+require 'fileutils'
+
+module RubyProf
+
+  # Define a task library for profiling unit tests with ruby-prof.
+  #
+  # All of the options provided by
+  # the Rake:TestTask are supported except the loader
+  # which is set to ruby-prof.  For detailed information
+  # please refer to the Rake:TestTask documentation.
+  #
+  # ruby-prof specific options include:
+  #
+  #   output_dir - For each file specified an output
+  #                file with profile information will be
+  #                written to the output directory.
+  #                By default, the output directory is
+  #                called "profile" and is created underneath
+  #                the current working directory.
+  #
+  #   printer - Specifies the output printer.  Valid values include
+  #             :flat, :graph, :graph_html and :call_tree.
+  #
+  #   min_percent - Methods that take less than the specified percent
+  #                 will not be written out.
+  #
+  # Example:
+  #
+  #   require 'ruby-prof/task'
+  #
+  #   RubyProf::ProfileTask.new do |t|
+  #     t.test_files = FileList['test/test*.rb']
+  #     t.output_dir = "c:/temp"
+  #     t.printer = :graph
+  #     t.min_percent = 10
+  #   end
+  #
+  # If rake is invoked with a "TEST=filename" command line option,
+  # then the list of test files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one test.
+  #
+  # If rake is invoked with a "TESTOPTS=options" command line option,
+  # then the given options are passed to the test process after a
+  # '--'.  This allows Test::Unit options to be passed to the test
+  # suite.
+  #
+  # Examples:
+  #
+  #   rake profile                           # run tests normally
+  #   rake profile TEST=just_one_file.rb     # run just one test file.
+  #   rake profile TESTOPTS="-v"             # run in verbose mode
+  #   rake profile TESTOPTS="--runner=fox"   # use the fox test runner
+
+  class ProfileTask < Rake::TestTask
+    attr_accessor :output_dir
+    attr_accessor :min_percent
+    attr_accessor :printer
+
+    def initialize(name = :profile)
+      super(name)
+    end
+
+    # Create the tasks defined by this task lib.
+    def define
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      desc "Profile" + (@name==:profile ? "" : " for #{@name}")
+
+      task @name do
+        create_output_directory
+
+        @ruby_opts.unshift( "-I#{lib_path}" )
+        @ruby_opts.unshift( "-w" ) if @warning
+        @ruby_opts.push("-S ruby-prof")
+        @ruby_opts.push("--printer #{@printer}")
+        @ruby_opts.push("--min_percent #{@min_percent}")
+
+        file_list.each do |file_path|
+          run_script(file_path)
+        end
+      end
+      self
+    end
+
+    # Run script
+    def run_script(script_path)
+      run_code = ''
+      RakeFileUtils.verbose(@verbose) do
+        file_name = File.basename(script_path, File.extname(script_path))
+        case @printer
+          when :flat, :graph, :call_tree
+            file_name += ".txt"
+          when :graph_html
+            file_name += ".html"
+          else
+            file_name += ".txt"
+        end
+
+        output_file_path = File.join(output_directory, file_name)
+
+        command_line = @ruby_opts.join(" ") +
+                      " --file=" + output_file_path +
+                      " " + script_path
+
+        puts "ruby " + command_line
+        # We have to catch the exeption to continue on.  However,
+        # the error message will have been output to STDERR
+        # already by the time we get here so we don't have to
+        # do that again
+        begin
+          ruby command_line
+        rescue => e
+          STDOUT << e << "\n"
+          STDOUT.flush
+        end
+        puts ""
+        puts ""
+      end
+    end
+
+    def output_directory
+      File.expand_path(@output_dir)
+    end
+
+    def create_output_directory
+      if not File.exist?(output_directory)
+        Dir.mkdir(output_directory)
+      end
+    end
+
+    def clean_output_directory
+      if File.exist?(output_directory)
+        files = Dir.glob(output_directory + '/*')
+        FileUtils.rm(files)
+      end
+    end
+
+    def option_list # :nodoc:
+      ENV['OPTIONS'] || @options.join(" ") || ""
+    end
+  end
+end