rubyperf 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.idea/encodings.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Encoding" useUTFGuessing="true" native2AsciiForPropertiesFiles="false" />
+</project>
+

data/.idea/misc.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="DependencyValidationManager">
+    <option name="SKIP_IMPORT_STATEMENTS" value="false" />
+  </component>
+  <component name="ProjectResources">
+    <default-html-doctype>http://www.w3.org/1999/xhtml</default-html-doctype>
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="ruby-1.8.7-p174" project-jdk-type="RUBY_SDK" />
+</project>
+

data/.idea/modules.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/rubyperf.iml" filepath="$PROJECT_DIR$/.idea/rubyperf.iml" />
+    </modules>
+  </component>
+</project>
+

data/.idea/rubyperf.iml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="PROVIDED" name="rcov (v0.9.11, ruby-1.8.7-p174) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="bundler (v1.0.10, ruby-1.8.7-p174) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="rake (v0.9.2.2, ruby-1.8.7-p174) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="shoulda (v2.11.3, ruby-1.8.7-p174) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="jeweler (v1.6.4, ruby-1.8.7-p174) [gem]" level="application" />
+    <orderEntry type="library" scope="PROVIDED" name="git (v1.2.5, ruby-1.8.7-p174) [gem]" level="application" />
+  </component>
+</module>
+

data/.idea/vcs.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>
+

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,20 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2.2)
+    rcov (0.9.11)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  rcov
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,31 @@
+Copyright (c) 2012 Lorenzo Pasqualis - DreamBox Learning, Inc
+
+Project home-page git repository:
+  https://github.com/lpasqualis/rubyperf
+
+Author can be contacted at:
+  lpasqualis@gmail.com
+
+Author's Blog:
+  http://www.lorenzopasqualis.com
+
+LICENSE:
+
+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.rdoc

@@ -0,0 +1,35 @@
+= rubyperf
+
+A gem to measure execution time of blocks of code, methods and expressions.
+It generates detailed reports in various formats showing the nested structure
+of the measures.
+
+It is designed to give tools to drill in the performance of hot code and
+identify bottlenecks.
+
+Currently available output formats for the report: text, html.
+
+== Contributing to rubyperf
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Lorenzo Pasqualis - DreamBox Learning, Inc
+
+Project home-page git repository:
+  https://github.com/lpasqualis/rubyperf
+
+Author can be contacted at:
+  lpasqualis@gmail.com
+
+Author's Blog:
+  http://www.lorenzopasqualis.com
+See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rubyperf"
+  gem.homepage = "http://github.com/lpasqualis/rubyperf"
+  gem.license = "MIT"
+  gem.summary = %Q{A gem to measure ruby code performance}
+  gem.description = %Q{Measures the performance of blocks of code, and provide reporting in various formats}
+  gem.email = "lpasqualis@gmail.com"
+  gem.authors = ["lpasqualis"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rubyperf #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/perf/meter.rb

@@ -0,0 +1,374 @@
+#
+# Copyright (c) 2012 Lorenzo Pasqualis - DreamBox Learning, Inc
+# https://github.com/lpasqualis/rubyperf
+#
+
+require "benchmark"
+
+module Perf
+
+  #
+  # Measures the runtime execution speed of a block of code, expression or entire methods.
+  #
+
+  class Meter
+
+    PATH_MEASURES  = '\blocks'
+    PATH_METHODS   = '\methods'
+
+    METHOD_TYPE_INSTANCE = :instance
+    METHOD_TYPE_CLASS    = :class
+
+    attr_accessor :measurements
+    attr_accessor :current_stack
+
+    def initialize
+      @measurements             = {}
+      @current_stack            = []
+      @instrumented_methods     = {METHOD_TYPE_INSTANCE=>[],METHOD_TYPE_CLASS=>[]}
+      @class_methods            = []
+    end
+
+    # Takes a description and a code block and measures the performance of the block.
+    # It returns the value retuend by the block
+    #
+    # ==== Attributes
+    #
+    # * +what+ - The title that will identify of the block
+    # * +code+ - Block of code to measure
+    #
+    # ==== Examples
+    #
+    # Measures the time taken by the code in the block
+    #
+    #    perf = Perf::Meter.new
+    #    perf.measure(:func) do
+    #       some code here
+    #    end
+    #
+    # Measure the time taken to  compute "some_expression"
+    #
+    #  if perf.measure(:some_expression) { some_expression }
+    #    ...
+    #  end
+    #
+    # Measure a bunch of things, and divides the measures in sub blocks that get measures separately
+    #
+    #  perf.measure(:bunch_of_stuff) do
+    #     perf.measure(:thing1)  do
+    #       ...
+    #     end
+    #     perf.measure(:thing2) do
+    #        perf.measure(:thing2_part1) do
+    #          ...
+    #        end
+    #        perf.measure(:thing2_part2) do
+    #          ...
+    #        end
+    #     end
+    #  end
+    #
+
+    def measure(what,&code)
+      path="#{PATH_MEASURES}\\#{get_current_path}"
+      @current_stack.push what
+      begin
+        res=measure_full_path(PATH_MEASURES) do
+          measure_full_path("#{path}#{what}",&code)
+        end
+      ensure
+        @current_stack.pop
+      end
+      res
+    end
+
+    # Takes a description and an expression returning a value and measures the performance of the expression storing the
+    # result by returned value. Should be used only for expressions that can return only a small discrete number of unique
+    # values, such a flag for example.
+    #
+    # It returns the value returned by the block
+    #
+    # ==== Attributes
+    #
+    # * +what+ - The title that will identify of the block
+    # * +code+ - Block of code to measure
+    #
+    # ==== Examples
+    #
+    # Measures the time take to compute the existence of user xyz and will give you stats for the case in which the
+    # result is true and false.
+    #
+    #    perf = Perf::Meter.new
+    #    if perf.measure_result(:long_epression) { User.find(xyz).nil? }
+    #    end
+    #
+
+    def measure_result(what,&code)
+      res=measure(what,&code)
+      merge_measures(what,"#{what} = \"#{res.to_s}\"")
+      res
+    end
+
+    # Puts a wrapper around a set of methods of a specific class to measure their performance.
+    # The set is provided with an array of iinstance methods, and one of class methods.
+    #
+    # The method defines the wrapper, yelds to the block, and then restores the instrumented class.
+    # This ensures that the instrumented class is restored, and that the instrumentation occurs only in the context
+    # of the block
+    #
+    # ==== Attributes
+    #
+    # * +klass+ - The Class containing the instance method that you want to measure
+    # * +imethods+ - An array of instance methods that you want to measure
+    # * +cmethods+ - An array of class methods that you want to measure
+    #
+    # ==== Examples
+    #
+    #    perf = Perf::Meter.new
+    #    m.method_meters(PerfTestExample,[:test,:test_np],[:static_method]) do
+    #      a=PerfTestExample.new
+    #      a.test(1,2,3)
+    #      a.test_np
+    #      PerfTestExample.static_method
+    #    end
+    #
+    # After this m contains measures for the executions of the instance methods test, test_np and the class
+    # methods static_method
+    #
+
+    def method_meters(klass,imethods=[],cmethods=[])
+      res=nil
+      begin
+        imethods.each {|m| measure_instance_method(klass,m) }
+        cmethods.each {|m| measure_class_method(klass,m) }
+        res=yield
+      ensure
+        imethods.each {|m| restore_instance_method(klass,m) }
+        cmethods.each {|m| restore_class_method(klass,m) }
+      end
+      res
+    end
+
+    # Puts a wrapper around instance methods of a specific class to measure their performance
+    # Remember to use restore_instance_method when you are done, otherwise the method will stay instrumented.
+    #
+    # Use sparingly!
+    #
+    # ==== Attributes
+    #
+    # * +klass+ - The Class containing the instance method that you want to measure
+    # * +method_name+ - The name of the method that you want to measure
+    #
+    # ==== Examples
+    #
+    # Instruments the class find so that the execution of the method "find" will be measures every time that is used.
+    #
+    #    perf = Perf::Meter.new
+    #    perf.measure_instance_method(User,:find)
+    #    ..
+    #
+    # Removes the instrumentation (important!)
+    #
+    #    perf.restore_instance_method(User,:find)
+    #
+    # Removes all instrumentation from class User
+    #
+    #    perf.restore_all_instance_methods(User)
+    #
+
+    def measure_instance_method(klass,method_name)
+      measure_method_by_type(klass,method_name,METHOD_TYPE_INSTANCE)
+    end
+
+    # Removes the instrumentation of a instance method in a given class.
+    # See measure_instance_method for more information.
+
+    def restore_instance_method(klass,method_name)
+      restore_method_by_type(klass,method_name,METHOD_TYPE_INSTANCE)
+    end
+
+    # Removes all instrumentation of instance methods in a given class.
+    # See measure_instance_method for more information.
+
+    def restore_all_instance_methods(klass)
+      restore_all_methods_by_type(klass,METHOD_TYPE_INSTANCE)
+    end
+
+    # Puts a wrapper around class methods of a specific class to measure their performance
+    # Remember to use restore_class_method when you are done, otherwise the class method will stay instrumented.
+    #
+    # Use sparingly!
+    #
+    # ==== Attributes
+    #
+    # * +klass+ - The Class containing the instance method that you want to measure
+    # * +method_name+ - The name of the class method that you want to measure
+    #
+    # ==== Examples
+    #
+    # Instruments the class find so that the execution of the class method "static_method" will be measures every time that is used.
+    #
+    #    perf = Perf::Meter.new
+    #    perf.measure_class_method(SomeClass,:static_method)
+    #    ..
+    #
+    # Removes the instrumentation (important!)
+    #
+    #    perf.restore_class_method(SomeClass,:static_method)
+    #
+    # Removes all instrumentation from class SomeClass
+    #
+    #    perf.restore_all_class_methods(SomeClass)
+    #
+
+    def measure_class_method(klass,method_name)
+      measure_method_by_type(class << klass; self end,method_name,METHOD_TYPE_CLASS)
+    end
+
+    # Removes the instrumentation of a class method in a given class.
+    # See measure_class_method for more information.
+
+    def restore_class_method(klass,method_name)
+      restore_method_by_type(class << klass; self end,method_name,METHOD_TYPE_CLASS)
+    end
+
+    # Removes the instrumentation of all class methods in a given class.
+    # See measure_class_method for more information.
+
+    def restore_all_class_methods(klass)
+      restore_all_methods_by_type(class << klass; self end,METHOD_TYPE_CLASS)
+    end
+
+    # Removes all instrumentation of class methods and instance methods in a given class.
+    # See measure_class_method for more information.
+
+    def restore_all_methods(klass)
+      restore_all_instance_methods(klass)
+      restore_all_class_methods(klass)
+    end
+
+    # Measures a block of code given a full path. Should not be called directly unless you know what you are doing.
+
+    def measure_full_path(path,&code)
+      m=get_measurement(path)
+      m[:count] += 1
+      if m[:measuring]
+        res=code.call
+      else
+        res=nil
+        m[:measuring]  = true
+        begin
+          m[:time]      += Benchmark.measure { res=code.call }
+        ensure
+          m[:measuring]  = false
+        end
+      end
+      res
+    end
+
+private
+
+    def set_measurement(path,m)
+      @measurements[path]=m
+    end
+
+    def get_current_path
+      @current_stack.join("\\") + (!@current_stack.empty? ? "\\" : "")
+    end
+
+    def merge_measures(what_from,what_to)
+      measurement_root = "#{PATH_MEASURES}\\#{get_current_path}"
+      path_from        = "#{measurement_root}#{what_from}"
+      path_to          = "#{measurement_root}#{what_to}"
+      m_from = get_measurement(path_from)
+      m_to   = get_measurement(path_to)
+      m_to[:time]       +=  m_from[:time]
+      m_to[:count]      +=  m_from[:count]
+      m_to[:measuring]  ||= m_from[:measuring]
+      clear_measurement(path_from)
+    end
+
+    def clear_measurement(path)
+      @measurements.delete(path)
+    end
+
+    def get_measurement(path)
+      @measurements[path] ||= {:count      => 0,
+                               :time       => Benchmark::Tms.new,
+                               :measuring  => false}
+    end
+
+    def measure_method_by_type(klass,method_name,type)
+      unless @instrumented_methods[type].find{|x| x[:klass]==klass && x[:method]==method_name}
+        klass_path="#{PATH_METHODS}\\#{klass}"
+        m = get_measurement("#{klass_path}\\#{method_name}")
+        old_method_symbol="rubyperf_org_#{method_name}".to_sym
+        @instrumented_methods[type] << { :klass=>klass, :method=>method_name, :perf=>m, :org=>old_method_symbol }
+        perf=self
+        klass.send(:alias_method, old_method_symbol,method_name)
+        klass.send(:define_method,method_name) do |*args|
+          res=nil
+          m[:count] += 1
+          t = perf.measure_full_path(PATH_METHODS) do
+                perf.measure_full_path(klass_path) do
+                  Benchmark.measure{ res=self.send(old_method_symbol, *args) }
+                end
+              end
+          m[:time]  += t
+          res
+        end
+      end
+    end
+
+    # Removes the instrumentation of a instance method in a given class.
+    # See measure_instance_method for more information.
+
+    def restore_method_by_type(klass,method_name,type)
+      if (im=@instrumented_methods[type].find{|x| x[:klass]==klass && x[:method]==method_name})
+        klass.send(:remove_method,im[:method])
+        klass.send(:alias_method, im[:method], im[:org])
+        klass.send(:remove_method,im[:org])
+        @instrumented_methods[type].delete(im)
+      end
+    end
+
+    # Removes all instrumentation of instance methods in a given class.
+    # See measure_instance_method for more information.
+
+    def restore_all_methods_by_type(klass,type)
+      remove=[]
+      @instrumented_methods[type].select {|x| x[:klass]==klass}.each do |im|
+        klass.send(:remove_method,im[:method])
+        klass.send(:alias_method, im[:method], im[:org])
+        klass.send(:remove_method,im[:org])
+        remove<<im
+      end
+      remove.each do |im|
+        @instrumented_methods[type].delete(im)
+      end
+    end
+
+    # You can generate a report using one of the built-in report formats with a simple syntax shortcut
+    #
+    #    m=Perf::Meter.new
+    #    m.report_FORMAT
+    #
+    # Where FORMAT is the ending part of one of the ReportFormatFORMAT classes built in.
+    #
+    # ==== Examples
+    #
+    # m=Perf::Meter.new
+    # m.measure(:something) {something}
+    # puts m.report_html
+    # puts m.report_simple
+    #
+
+    def method_missing(method_sym, *arguments, &block)
+      if method_sym.to_s =~ /^report_(.*)$/
+        klass=Object.const_get("Perf").const_get("ReportFormat#{$1.capitalize}")
+        return klass.new.format(self) if klass
+      end
+      super
+    end
+  end
+end

data/lib/perf/meter_factory.rb

@@ -0,0 +1,47 @@
+#
+# Copyright (c) 2012 Lorenzo Pasqualis - DreamBox Learning, Inc
+# https://github.com/lpasqualis/rubyperf
+#
+
+module Perf
+
+  # Simple Perf::Meter factory and singleton management.
+  # Useful to not have to pass around Perf::Meter objects and still be able to generate stats in various parts of
+  # the code.
+  #
+  class MeterFactory
+
+    DEFAULT_METER = :default
+
+    # Returns a Perf::Meter with a given key, and creates it lazly if it doesn't exist'.
+    def self.get(key=DEFAULT_METER)
+      @@perf_meters ||= {}
+      @@perf_meters[key] ||= Perf::Meter.new
+    end
+
+    # Pushes a Perf::Meter into a key
+    def self.set_meter(key,meter)
+      @@perf_meters ||= {}
+      @@perf_meters[key]=meter
+    end
+
+    # Sets the default meter.
+    def self.set_default(meter)
+      set_meter(DEFAULT_METER,meter)
+    end
+
+    def self.all
+      @@perf_meters ||= {}
+      return @@perf_meters.clone
+    end
+
+    def self.clear_meter(key=DEFAULT_METER)
+      @@perf_meters.delete(key) if @@perf_meters
+    end
+
+    def self.clear_all!
+      @@perf_meters=nil
+    end
+
+  end
+end

data/lib/perf/no_op_meter.rb

@@ -0,0 +1,39 @@
+#
+# Copyright (c) 2012 Lorenzo Pasqualis - DreamBox Learning, Inc
+# https://github.com/lpasqualis/rubyperf
+#
+
+module Perf
+  #
+  # This class can be used in substitution to a Perf::Measure class to avoid overhead when performance measurments is not
+  # required. It needs to maintain the same API as Perf::Measure.
+  #
+  class NoOpMeter
+
+    def initialize(logger = nil)
+    end
+
+    def clear
+    end
+
+    #############################################################################################################
+
+    def measure(what,type=nil)
+      yield
+    end
+
+    def count_value(what_to_count)
+      nil
+    end
+
+    def report_arr(options={})
+      []
+    end
+
+    def report(options={})
+      true
+    end
+
+  end
+
+end