benchmark_for_rails 1.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,12 @@
+BenchmarkForRails
+=================
+
+Automatic Rails benchmarking for:
+* Before Filters
+* After Filters
+* Session Initialization
+* ActiveRecord finds (not just DB access!)
+* ... and easily add your own
+
+
+Copyright (c) 2007 Lance Ivy, released under the MIT license

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the benchmark_for_rails plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the benchmark_for_rails plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'BenchmarkForRails'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/benchmark_for_rails.rb

@@ -0,0 +1,72 @@
+require File.dirname(__FILE__) + '/benchmark_for_rails/rewatching'
+
+# BenchmarkForRails addresses a few issues with ActionController's benchmarking:
+# * hidden query costs (ActiveRecord's cost of building a query)
+# * no visibility on the cost of before/after filters
+# * no visibility on cost of session management
+#
+# Other strengths:
+# * very easy to benchmark new things without implementing your own alias_method_chain (use BenchmarkForRails.watch)
+# * automatically handles methods called multiple times (e.g. ActiveRecord::Base#find)
+module BenchmarkForRails
+  class << self
+    # Starts benchmarking for some method. Results will be automatically
+    # logged after the request finishes processing.
+    #
+    # Arguments:
+    # * name: how to refer to this benchmark in the logs
+    # * obj: the object that defines the method
+    # * method: the name of the method to be benchmarked
+    # * instance: whether the method is an instance method or not
+    def watch(name, obj, method, instance = true)
+      rewatchable(name, obj.to_s, method, instance) if ActiveSupport::Dependencies.will_unload?(obj)
+
+      obj.class_eval <<-EOL, __FILE__, __LINE__
+        #{"class << self" unless instance}
+        def #{method}_with_benchmark_for_rails(*args, &block)
+          BenchmarkForRails.measure(#{name.inspect}) {#{method}_without_benchmark_for_rails(*args, &block)}
+        end
+
+        alias_method_chain :#{method}, :benchmark_for_rails
+        #{"end" unless instance}
+      EOL
+    end
+
+    def results #:nodoc:
+      Thread.current[:results] ||= Hash.new(0)
+    end
+
+    # Used by watch to record the time of a method call without losing the
+    # method's return value
+    def measure(name, &block)
+      if self.running? name
+        yield
+      else
+        result = nil
+        self.running << name
+        begin
+          self.results[name] += Benchmark.ms{result = yield} / 1000
+        rescue
+          raise
+        ensure
+          self.running.delete(name)
+        end
+        result
+      end
+    end
+
+    def logger #:nodoc:
+      Rails.logger
+    end
+
+    protected
+
+    def running?(name)
+      running.include? name
+    end
+
+    def running
+      Thread.current[:running] ||= []
+    end
+  end
+end

data/lib/benchmark_for_rails/log_parser.rb

@@ -0,0 +1,117 @@
+module BenchmarkForRails
+  class LogParser
+    # The log file to be read.
+    attr_accessor :file
+
+    # If set to a Time, will limit the parsed responses to those *after*
+    # the threshold. This lets you parse the last hour's worth of data out
+    # of a log.
+    #
+    # Depends on the 'elif' gem.
+    attr_accessor :threshold
+
+    def initialize(file = nil, threshold = nil)
+      self.file = file || RAILS_ROOT + '/log/production.log'
+      self.threshold = threshold
+    end
+
+    # pulls B4R lines out of the logfile.
+    B4R_RE        = /^B4R/
+    PROCESSING_RE = /\AProcessing .+ at (\d+-\d+-\d+ \d+:\d+:\d+)\Z/
+    def lines
+      if @lines.nil?
+        if threshold
+          require 'elif'
+          @lines = []
+          Elif.foreach(self.file) do |line|
+            if B4R_RE.match(line)
+              @lines << line
+            elsif threshold and PROCESSING_RE.match(line)
+              @lines.pop and break if Time.parse($1) < self.threshold
+            end
+          end
+        else
+          @lines ||= File.read(self.file).grep(/^B4R/)
+        end
+      end
+      @lines
+    end
+
+    # reads the resource_paths to calculate average times for *each* benchmark type.
+    # that is, this returns averages indexed by benchmark, not path.
+    def benchmarks
+      if @benchmarks.nil?
+        benchmarks = {}
+        resource_paths.each do |path|
+          path.requests.each do |request|
+            request.each do |benchmark, time| (benchmarks[benchmark] ||= []) << time end
+          end
+        end
+
+        @benchmarks = {}
+        benchmarks.each do |benchmark, times| @benchmarks[benchmark] = (times.sum || 0) / times.size end
+      end
+      @benchmarks
+    end
+
+    # pulls ResourcePath objects out of the file
+    def resource_paths
+      if @resource_paths.nil?
+        paths_by_path = {}
+        lines.each do |line|
+          path_name = ResourcePath.path_from(line)
+          paths_by_path[path_name] ||= ResourcePath.new(path_name)
+          paths_by_path[path_name].add_request(line)
+        end
+        @resource_paths = paths_by_path.values
+      end
+      @resource_paths
+    end
+
+    # returns the slowest few ResourcePaths
+    # optionally determines slowness by weighting speed vs frequency (e.g. total time, not average time)
+    def slowest(number = 10, total_time = false)
+      resource_paths.sort_by(&(total_time ? :total_time : :average_time)).reverse[0...number]
+    end
+  end
+
+  class ResourcePath
+    # pre-generate the regular expressions. this matters when you loop one million times.
+    PATH_STRIP_RE         = /.*\] */
+    MEASUREMENT_SPLIT_RE  = / *: */
+    PATH_RE               = /\[(.*?)\]/
+
+    attr_reader :path
+    attr_reader :requests
+
+    def initialize(path)
+      @path = path
+      @requests = []
+    end
+
+    def add_request(line)
+      measurements = {}
+      line.sub(PATH_STRIP_RE, '').split(' | ').each do |measurement|
+        md = MEASUREMENT_SPLIT_RE.match(measurement)
+        measurements[md.pre_match] = md.post_match.to_f
+      end
+      self.requests << measurements
+    end
+
+    def frequency
+      @frequency ||= requests.length
+    end
+
+    def total_time
+      @total_time ||= requests.collect{|r| r['request']}.sum
+    end
+
+    def average_time
+      @average_time ||= total_time / frequency
+    end
+
+    def self.path_from(str)
+      PATH_RE.match(str)[1]
+    end
+  end
+end

data/lib/benchmark_for_rails/report.rb

@@ -0,0 +1,34 @@
+class BenchmarkForRails::Report
+  PADDING = 2
+
+  attr_accessor :rows
+  def initialize
+    self.rows = []
+  end
+
+  def render(*headers)
+    headers.each_index do |i|
+      print headers[i].to_s.ljust(width_of_column(i, headers[i].length + PADDING), ' ')
+    end
+    puts ""
+
+    headers.each_index do |i|
+      print '-' * (width_of_column(i) - PADDING)
+      print ' ' * PADDING
+    end
+    puts ""
+
+    rows.each do |row|
+      row.each_index do |i|
+        print row[i].to_s.ljust(width_of_column(i), ' ')
+      end
+      puts ""
+    end
+  end
+
+  def width_of_column(i, min = 8)
+    @column_widths ||= []
+    @column_widths[i] = (rows.collect{|r| r[i]}.collect{|c| c.to_s.length + PADDING} << min).max if @column_widths[i].nil?
+    @column_widths[i]
+  end
+end

data/lib/benchmark_for_rails/resource_path.rb

@@ -0,0 +1,48 @@
+module BenchmarkForRails
+  class ResourcePath
+    attr_reader :path
+    attr_reader :requests
+
+    def initialize(path)
+      @path = path
+      @requests = []
+    end
+
+    def add_request(line)
+      measurements = {}
+      line.sub(/.*\]/, '').split(' | ').each do |measurement|
+        name, seconds = *measurement.split(':').collect{|p| p.strip}
+        measurements[name] = seconds.to_f
+      end
+      self.requests << measurements
+    end
+
+    def frequency
+      @frequency ||= requests.length
+    end
+
+    def total_time
+      @total_time ||= self['request'].sum
+    end
+
+    def average_time
+      @average_time ||= total_time / frequency
+    end
+
+    def min
+      @min ||= self['request'].min
+    end
+
+    def max
+      @max ||= self['request'].max
+    end
+
+    def self.path_from(str)
+      str.match(/\[(.*)\]/)[1]
+    end
+
+    def [](benchmark_name)
+      requests.collect{|r| r[benchmark_name.to_s]}
+    end
+  end
+end

data/lib/benchmark_for_rails/rewatching.rb

@@ -0,0 +1,32 @@
+module BenchmarkForRails
+  class << self
+    def rewatch!
+      rewatchables.each do |(name, object_name, method, instance)|
+        watch(name, object_name.constantize, method, instance)
+      end
+    end
+
+    def rewatchable(*args)
+      rewatchables << args unless rewatchables.include? args
+    end
+
+    private
+
+    def rewatchables
+      @rewatchables ||= []
+    end
+  end
+end
+
+# hook into dependency unloading
+module ActiveSupport::Dependencies
+  class << self
+    def clear_with_rewatching(*args, &block)
+      clear_without_rewatching(*args, &block).tap do
+        BenchmarkForRails.rewatch!
+      end
+    end
+    alias_method_chain :clear, :rewatching
+  end
+end
+

data/lib/reporting.rb

@@ -0,0 +1,43 @@
+module BenchmarkForRails
+  class << self
+    # Prints the benchmarks for the request into the log, with some
+    # basic ASCII formatting (yay). Uses a multi-line format for
+    # development mode, and a one-line format for production mode.
+    def report(request)
+      request_action = "#{request.method.to_s.upcase} #{request.path.chomp('/')}"
+      request_time   = results.delete(:request) || 0.0
+
+      if RAILS_ENV.to_sym == :production
+        # in production mode, we want to use a one-line format that makes it easy to
+        # parse logs generated by multiple processes.
+        benchmarks = ["request: #{'%.4f' % request_time}"]
+        benchmarks += results.to_a.collect{|(name, seconds)| "#{name}: #{'%.4f' % seconds}"}
+
+        logger.info "B4R: [#{request_action}] #{benchmarks.join(' | ')}"
+      else
+        # in development mode, we want to use a multi-line format that makes it easy
+        # for a human to read.
+        logger.info "- [#{'%.4f' % request_time}] #{request_action} ".ljust(50, '-')
+
+        results.to_a.sort_by{|(name, seconds)| seconds}.reverse.each do |(name, seconds)|
+          logger.info "   #{'%.4f' % seconds} #{name}"
+        end
+
+        logger.info " BenchmarkForRails -".rjust(50, '-')
+      end
+
+      results.clear
+    end
+  end
+end
+
+class ActionController::Dispatcher
+  # print reports at the end
+  def call_with_benchmark_for_rails_reporting(*args, &block) #:nodoc:
+    call_without_benchmark_for_rails_reporting(*args, &block).tap do |status, headers, response|
+      BenchmarkForRails.report(ActionController::Request.new(args.first))
+      Rails.logger.flush if Rails.logger.respond_to? :flush
+    end
+  end
+  alias_method_chain :call, :benchmark_for_rails_reporting
+end

data/lib/tasks/logs.rake

@@ -0,0 +1,24 @@
+# Bleh. Why isn't this already loaded? I need Symbol#& !
+require 'active_support'
+require File.dirname(__FILE__) + '/../benchmark_for_rails'
+require File.dirname(__FILE__) + '/../benchmark_for_rails/report'
+require File.dirname(__FILE__) + '/../benchmark_for_rails/log_parser'
+require File.dirname(__FILE__) + '/../benchmark_for_rails/resource_path'
+
+namespace :log do
+  desc "run reports on BenchmarkForRails log output. examples: `rake log:analyze path='GET /'`, or `rake log:analyze order_by=averages`"
+  task :analyze do
+    report = BenchmarkForRails::Report.new
+    order_by_totals = !(ENV['order_by'] =~ /^averages?/)
+    BenchmarkForRails::LogParser.new.slowest(10, order_by_totals).each do |resource_path|
+      report.rows << [
+        resource_path.path,
+        '%.4f' % resource_path.total_time,
+        resource_path.frequency,
+        '%.4f' % resource_path.average_time,
+        "#{'%.3f' % resource_path.min} - #{'%.3f' % resource_path.max}"
+      ]
+    end
+    report.render('resource path', 'total time', 'frequency', 'average', 'min - max')
+  end
+end

data/rails/init.rb

@@ -0,0 +1,31 @@
+# The indentation of this benchmark tree indicates which benchmarks include which other benchmarks.
+# For example, :request = :reloading + :dispatch + ?
+# And, :dispatch = :routing + :process + ?
+BenchmarkForRails.watch(:request, ActionController::Dispatcher, :call)
+  BenchmarkForRails.watch("reloading", ActionController::Dispatcher, :reload_application, false) if RAILS_ENV == 'development'
+  # this runs after all the middleware
+  BenchmarkForRails.watch('dispatch', ActionController::Dispatcher, :_call)
+    BenchmarkForRails.watch('routing', ActionController::Routing::RouteSet, :recognize)
+    BenchmarkForRails.watch('process', ActionController::Base, :process)
+      BenchmarkForRails.watch("filters", ActionController::Filters::BeforeFilter, :call)
+      # Processing the action itself (calling the controller method)
+      # This is what Rails' default benchmarks claim is the response time.
+      BenchmarkForRails.watch("action", ActionController::Base, :perform_action)
+        # And yes, it's still important to know how much time is spent rendering.
+        BenchmarkForRails.watch("rendering", ActionController::Base, :render)
+      BenchmarkForRails.watch("filters", ActionController::Filters::AfterFilter, :call)
+  # TODO: this happens at the *end* of a request, after the middleware stack and definitely
+  # after reporting. so these times get attributed to the *next* request. too confusing.
+  # BenchmarkForRails.watch("reloading", ActionController::Dispatcher, :cleanup_application, false) if RAILS_ENV == 'development'
+
+# The real cost of database access should include query construction.
+# Hence why we try and watch the core finder. More watches might be added
+# to this group to form a more complete picture of database access. The
+# question is simply which methods bypass find().
+# TODO: disabling this until it can be more comprehensive.
+# BenchmarkForRails.watch("queries", ActiveRecord::Base, :find, false)
+# BenchmarkForRails.watch("queries", ActiveRecord::Base, :find_by_sql, false)
+
+# Should be included after the BenchmarkForRails.watch(:request, ...),
+# since it hooks into the same method.
+require 'reporting'

data/test/app/some/klass.rb

@@ -0,0 +1,7 @@
+class Some::Klass
+  include Some::Module
+  def hello; 'hello' end
+  def self.world; 'world' end
+  def yielder; yield end
+  def echoer(*args); args end
+end

data/test/app/some/module.rb

@@ -0,0 +1,4 @@
+module Some::Module
+  def foo; 'foo' end
+  def self.bar; 'bar' end
+end

data/test/benchmark_for_rails_test.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class BenchmarkForRailsTest < Test::Unit::TestCase
+
+  def setup
+    BenchmarkForRails.results.clear
+  end
+
+  def test_measure_preserves_return
+    assert_equal 'gyro', BenchmarkForRails.measure('deliciousness') { 'gyro' }
+  end
+
+  def test_measure_adds_result
+    assert_equal 0, BenchmarkForRails.results['sky']
+    BenchmarkForRails.measure('sky') { 'wide' }
+    assert BenchmarkForRails.results['sky'] > 0
+  end
+
+  def test_measure_adds_to_existing_result
+    assert_equal 0, BenchmarkForRails.results['nalgene']
+    BenchmarkForRails.measure('nalgene') { 'liter' }
+    liter_measurement = BenchmarkForRails.results['nalgene']
+    BenchmarkForRails.measure('nalgene') { '750ml' }
+    assert BenchmarkForRails.results['nalgene'] > liter_measurement
+  end
+
+  def test_basic_accuracy_of_measure
+    BenchmarkForRails.measure('somnolence') { sleep 0.2 }
+    assert BenchmarkForRails.results['somnolence'] < 0.21
+    assert BenchmarkForRails.results['somnolence'] > 0.19
+  end
+
+  # a test for measuring recursive functions
+  def test_nested_duplicate_measurements
+    BenchmarkForRails.measure('recursive') do
+      sleep 0.2
+      BenchmarkForRails.measure('recursive') do
+        sleep 0.2
+      end
+    end
+    assert BenchmarkForRails.results['recursive'] < 0.41
+    assert BenchmarkForRails.results['recursive'] > 0.39
+  end
+
+  def test_watching_passes_blocks
+    BenchmarkForRails.watch('yielding', Some::Klass, :yielder)
+    assert_equal 'christmas', Some::Klass.new.yielder { 'christmas' }
+  end
+
+  def test_watching_passes_args
+    BenchmarkForRails.watch('echoer', Some::Klass, :echoer)
+    assert_equal [1, 1, 2, 3, 5], Some::Klass.new.echoer(1, 1, 2, 3, 5)
+  end
+
+  def test_watching_instance_method
+    BenchmarkForRails.watch('instance_method', Some::Klass, :hello)
+    assert_equal 'hello', Some::Klass.new.hello
+    assert_not_nil BenchmarkForRails.results['instance_method']
+  end
+
+  def test_watching_class_method
+    BenchmarkForRails.watch('class_method', Some::Klass, :world, false)
+    assert_equal 'world', Some::Klass.world
+    assert_not_nil BenchmarkForRails.results['class_method']
+  end
+
+  def test_watching_module_method
+    BenchmarkForRails.watch('module_method', Some::Module, :foo)
+    assert_equal 'foo', Some::Klass.new.foo
+    assert_not_nil BenchmarkForRails.results['module_method']
+  end
+
+  # it's not called a module class method, is it? oh well.
+  def test_watching_module_class_method
+    BenchmarkForRails.watch('module_class_method', Some::Module, :bar, false)
+    assert_equal 'bar', Some::Module.bar
+    assert_not_nil BenchmarkForRails.results['module_class_method']
+  end
+end

data/test/reloading_test.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class ReloadingTest < Test::Unit::TestCase
+  def test_rewatching_reloaded_module
+    BenchmarkForRails.watch('reloading', Some::Klass, :hello)
+    original_oid = Some::Klass.object_id
+    assert ActiveSupport::Dependencies.will_unload?(Some::Klass)
+    assert Some::Klass.instance_methods.include?('hello_with_benchmark_for_rails')
+
+    ActiveSupport::Dependencies.clear
+    assert_not_equal original_oid, Some::Klass.object_id
+    assert Some::Klass.instance_methods.include?('hello_with_benchmark_for_rails')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'test/unit'
+gem 'rails', '2.3.11'
+require 'benchmark'
+require 'active_support'
+
+# load the b4r module
+lib_path = File.dirname(__FILE__) + '/../lib/'
+ActiveSupport::Dependencies.autoload_paths << lib_path
+
+# for the fake application directory - needed to test reloading
+ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__) + '/app/'

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: benchmark_for_rails
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Lance Ivy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-19 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Provides better benchmarking of the Rails request stack. Currently tuned for Rails 2.3.x.
+email: lance@cainlevy.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/reporting.rb
+- lib/tasks/logs.rake
+- lib/benchmark_for_rails.rb
+- lib/benchmark_for_rails/log_parser.rb
+- lib/benchmark_for_rails/rewatching.rb
+- lib/benchmark_for_rails/report.rb
+- lib/benchmark_for_rails/resource_path.rb
+- LICENSE
+- README
+- Rakefile
+- rails/init.rb
+- test/test_helper.rb
+- test/benchmark_for_rails_test.rb
+- test/app/some/module.rb
+- test/app/some/klass.rb
+- test/app/some/class.rb
+- test/reloading_test.rb
+has_rdoc: true
+homepage: http://github.com/cainlevy/benchmarkforrails
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Improved benchmarking in Rails, with easy customization.
+test_files: 
+- test/test_helper.rb
+- test/benchmark_for_rails_test.rb
+- test/app/some/module.rb
+- test/app/some/klass.rb
+- test/app/some/class.rb
+- test/reloading_test.rb