easy-prof 1.0.0

data/.gitignore

@@ -0,0 +1,3 @@
+doc
+rdoc
+.yardoc

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Dmytro Shteflyuk
+
+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,248 @@
+= easy-prof
+
+Simple and easy to use Ruby code profiler, which could be used
+as a Rails plugin.
+
+== Installation
+
+There are two options when approaching easy-prof installation:
+
+* using the gem (recommended)
+* install as a Rails plugin
+
+To install as a gem, add this to your environment.rb:
+
+  config.gem 'easy-prof', :lib => 'easy_prof'
+
+And then run the command:
+
+  sudo rake gems:install
+
+To install meta-tags as a Rails plugin use this:
+
+  script/plugin install git://github.com/kpumuk/easy-prof.git
+
+== Description
+
+The main idea behind the easy-prof is creating check points and your
+code and measuring time needed to execute code blocks. Here is the
+example of easy-prof output:
+
+  [home#index] Benchmark results:
+  [home#index] debug: Logged in user home page
+  [home#index] progress: 0.7002 s [find top videos]
+  [home#index] progress: 0.0452 s [build categories list]
+  [home#index] progress: 0.0019 s [build tag cloud]
+  [home#index] progress: 0.0032 s [find featured videos]
+  [home#index] progress: 0.0324 s [find latest videos]
+  [home#index] debug: VIEW STARTED
+  [home#index] progress: 0.0649 s [top videos render]
+  [home#index] progress: 0.0014 s [categories render]
+  [home#index] progress: 2.5887 s [tag cloud render]
+  [home#index] progress: 0.0488 s [latest videos render]
+  [home#index] progress: 0.1053 s [featured video render]
+  [home#index] results: 3.592 s
+
+From this output you can see what checkpoints takes longer to reach,
+and what code fragments are pretty fast.
+
+== Usage
+
+The library extends <tt>Kernel</tt> with a method <tt>easy_profiler</tt>.
+By default profiling is disabled globally, so you should pass :enabled
+parameter to enable profiling of particular code. Also there is a time
+:limit option which could be used to skip logging of blocks which are
+fast enough.
+
+For more details see the options description below.
+
+  easy_profiler('sleep', :enabled => true) do |p|
+    sleep 1
+    p.progress('sleep 1')
+    p.debug('checkpoint reached')
+    sleep 2
+    p.progress('sleep 2')
+  end
+
+Method accepts two parameters: profiling session name and a hash of
+options:
+
+* <tt>:enabled</tt> -- value indicating whether profiling is enabled.
+* <tt>:limit</tt> -- minimum time period which should be reached to
+  print profiling log.
+* <tt>:count_ar_instances</tt> -- indicating whether profiler should
+  log an approximate number of instantiated ActiveRecord objects.
+* <tt>:count_memory_usage</tt> -- indicating whether profiler should
+  log an approximate amount of memory used.
+* <tt>:logger</tt> -- a +Logger+ instance.
+
+== Configuration
+
+There are some global configuration options exists:
+
+  EasyProfiler.configure do |config|
+    config.enable_profiling   = false
+    config.print_limit        = 0.01
+    config.count_ar_instances = false
+    config.count_memory_usage = false
+    config.logger             = nil # or Rails.logger or whatever
+    config.colorize_logging   = true
+    config.live_logging       = false
+  end
+
+* <tt>enable_profiling</tt> -- used to enable or disable profiling
+  globalle (<tt>false</tt> by default).
+* <tt>print_limit</tt> -- used to set a minimum time period in seconds
+  which should be reached to dump profile to the log (<tt>0.01</tt>
+  by default).
+* <tt>count_ar_instances</tt> -- indicating whether profiler should
+  log an approximate number of instantiated ActiveRecord objects.
+* <tt>count_memory_usage</tt> -- indicating whether profiler should
+  log an approximate amount of memory used.
+* <tt>logger</tt> -- a <tt>Logger</tt> instance to dump logs to.
+* <tt>colorize_logging</tt> -- when <tt>true</tt>, output will be
+  colorized (useful when dumping profiling information into the
+  Rails log).
+* <tt>live_logging</tt> -- when <tt>true</tt>, every profiling info
+  will be pushed to the log immediately (by default everything will
+  be dumped in the end of profiling session).
+
+== Active Record instances number profiling
+
+easy-prof can log a number of instantiated ActiveRecord instances.
+To enable this kind of profiling, use a <tt>:count_ar_instances</tt>
+option or global setting with the same name.
+
+Please note, that easy-prof completely disables garbage collector
+during this kind of profiling. It could hurt your overall application
+performance, so do not use it on production boxes. Also I can't
+guaranty 100% precision, but it is about this value in almost all
+cases.
+
+Further reading:
+* That’s Not a Memory Leak, It’s Bloat http://www.engineyard.com/blog/2009/thats-not-a-memory-leak-its-bloat/
+
+== Memory usage profiling
+
+The plugin is able to log an amount of memory used by current Ruby
+process. To enable this kind of profiling, use a <tt>:count_memory_usage</tt>
+option or global setting with the same name.
+
+Please note, that easy-prof completely disables garbage collector
+during this kind of profiling. It could hurt your overall application
+performance, so do not use it on production boxes. Also I can't
+guaranty 100% precision, but it is about this value in almost all
+cases.
+
+== Dumping results to the Firebug console
+
+If you are profiling a Ruby on Rails application, it could be useful
+to get profiling results from production server sometimes. To achieve
+this you can use a <tt>FirebugLogger</tt>, bundled with this plugin.
+In any controller you have a helper called <tt>firebug_logger</tt>,
+so you can pass it to EasyProfiler using <tt>:logger</tt> option:
+
+  easy_profiler('home#index', :logger => firebug_logger, :limit => 2) do |p|
+  end
+
+The idea behind this logger is pretty simple (as everything in this
+plugin): there is an <tt>after_filter</tt> named <tt>dump_firebug_profile</tt>,
+which dumps profiling information after your action finished its work.
+Please note: it will not output any line when profiling session is
+disabled or time limit is not reached.
+
+Do not forget to protect firebug output: it is a bad idea to allow
+anyone to see your profiling session dump. You can allow admin
+users only to use firebug, or restrict this feature by IP address.
+
+BTW, you can use Firebug Console Lite (http://getfirebug.com/lite.html)
+to get this feature working in any browser! By default it works
+perfectly in Firefox with Firebug installed, and in Safari 4.
+
+== Ruby on Rails application profiling
+
+Here is the complete example of a Rails action profiling:
+
+  class HomeController < ApplicationController
+    def index
+      easy_profiler('home#index', :enabled => profile_request?, :limit => 2) do |p|
+        p.progress 'logged in user home page'
+      
+        @top_videos = Video.top(:limit => 10)
+        p.progress 'find top videos'
+
+        @categories = Category.all(:order => 'name DESC')
+        p.progress 'build categories list'
+
+        @tag_cloud = Tag.tag_cloud(:limit => 200)
+        p.progress 'build tag cloud'
+      
+        @featured_videos = Video.featured(limit => 5)
+        p.progress 'find featured videos'
+
+        @latest_videos = Video.latest(:limit => 5)
+        p.progress 'find latest videos'
+      
+        @profiler = p
+        p.debug 'VIEW STARTED'
+      end
+    end
+
+    private
+  
+      # Method returns +true+ if current request should ouput profiling information
+      def profile_request?
+        params['_with_profiling'] == 'yes'
+      end
+  end
+
+And view:
+
+  <div id="top_videos">
+    <%= render :partial => 'top_videos' %>
+    <% @profiler.progress 'top videos render' %>
+  </div>
+  
+  <div class="tabs">
+    <ul id="taxonomy">
+      <li><a href="#" id="categories" class="current">Categories</a></li>
+      <li><a href="#" id="tags">Tags</a></li>
+    </ul>
+    <div class="categories_panel">
+      <%= render :partial => 'categories' %>
+      <% @profiler.progress 'categories render' %>
+    </div>
+    <div class="categories_panel hidden">
+      <%= render :partial => 'tag_cloud' %>
+      <% @profiler.progress 'tag cloud render' %>
+    </div>
+  </div>
+  
+  <div class="box">
+    <div id="latest">
+      <%= render :partial => 'videos', :videos => @latest_videos %>
+      <% @profiler.progress 'latest videos render' %>
+    </div>
+    <div id="featured">
+      <%= render :partial => 'videos', :videos => @featured_videos %>
+      <% @profiler.progress 'featured video render' %>
+    </div>
+  </div>
+  
+As you can see from this example, profiler will be enabled only when
+you pass a _with_profiling parameter with value yes:
+
+  http://example.com/home?_with_profiling=yes
+
+== Who are the authors?
+
+This plugin has been created in Scribd.com for our internal use
+and then the sources were opened for other people to use. All the
+code in this package has been developed by Dmytro Shteflyuk for
+Scribd.com and is released under the MIT license. For more details,
+see the MIT-LICENSE file.
+
+== Credits
+
+* Dmytro Shteflyuk (author) <kpumuk@kpumuk.info> http://kpumuk.info
+* Alexey Kovyrin (contributor) <alexey@kovyrin.net> http://kovyrin.net

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name        = 'easy-prof'
+    gemspec.summary     = 'Simple and easy to use Ruby code profiler'
+    gemspec.description = 'Simple Ruby code profiler to use both in Rails applications and generic Ruby scripts.'
+    gemspec.email       = 'kpumuk@kpumuk.info'
+    gemspec.homepage    = 'http://github.com/kpumuk/easy-prof'
+    gemspec.authors     = ['Dmytro Shteflyuk']
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler not available. Install it with: sudo gem install jeweler'
+end
+
+begin
+  require 'spec/rake/spectask'
+
+  desc 'Default: run unit tests.'
+  task :default => :spec
+
+  desc 'Test the easy-prof plugin.'
+  Spec::Rake::SpecTask.new(:spec) do |t|
+    t.libs << 'lib'
+    t.pattern = 'spec/**/*_spec.rb'
+    t.verbose = true
+    t.spec_opts = ['-cfs']
+  end
+rescue LoadError
+  puts 'RSpec not available. Install it with: sudo gem install rspec'
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new(:yard) do |t|
+    t.options = ['--title', 'EasyProf Documentation']
+    if ENV['PRIVATE']
+      t.options.concat ['--protected', '--private']
+    else
+      t.options.concat ['--protected', '--no-private']
+    end
+  end
+rescue LoadError
+  puts 'Yard not available. Install it with: sudo gem install yard'
+end

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:patch: 0
+:build: 
+:major: 1
+:minor: 0

data/init.rb

@@ -0,0 +1 @@
+require 'easy_prof'

data/lib/easy_prof.rb

@@ -0,0 +1,52 @@
+require 'logger'
+
+module EasyProfiler
+  autoload :Configuration,              'easy_profiler/configuration'
+  autoload :Profile,                    'easy_profiler/profile'
+  autoload :ProfileInstanceBase,        'easy_profiler/profile_instance_base'
+  autoload :ProfileInstance,            'easy_profiler/profile_instance'
+  autoload :NoProfileInstance,          'easy_profiler/no_profile_instance'
+  autoload :FirebugLogger,              'easy_profiler/firebug_logger'
+  autoload :ActionControllerExtensions, 'easy_profiler/action_controller_extensions'
+
+  module ClassMethods
+    def configure(force = false)
+      yield configuration(force)
+    end
+
+    def configuration(force = false)
+      if !@configuration || force
+        @configuration = Configuration.new
+      end
+      @configuration
+    end
+    alias :config :configuration
+  end
+  extend ClassMethods
+end
+
+if Object.const_defined?(:ActionController)
+  ActionController::Base.send(:include, EasyProfiler::ActionControllerExtensions)
+end
+
+module Kernel
+  # Wraps code block into the profiling session.
+  #
+  # See the <tt>EasyProfiler::Profile.start</tt> method for
+  # parameters description.
+  #
+  # Example:
+  #   easy_profiler('sleep', :enabled => true) do |p|
+  #     sleep 1
+  #     p.progress('sleep 1')
+  #     p.debug('checkpoint reached')
+  #     sleep 2
+  #     p.progress('sleep 2')
+  #   end
+  def easy_profiler(name, options = {})
+    profiler = EasyProfiler::Profile.start(name, options)
+    yield profiler
+  ensure
+    EasyProfiler::Profile.stop(name) if profiler
+  end
+end

data/lib/easy_profiler/action_controller_extensions.rb

@@ -0,0 +1,35 @@
+module EasyProfiler
+  module ActionControllerExtensions
+    def self.included(base) #:nodoc:
+      base.send :include, InstanceMethods
+
+      base.class_eval do
+        after_filter :dump_firebug_profile
+      end
+    end
+    
+    module InstanceMethods 
+      # Exposes firebug variable where logs can be submitted.
+      #
+      #   class UserController < ApplicationController
+      #     def index
+      #       firebug.debug 'Why I can be easily debugging with this thing!'
+      #     end
+      #   end
+      def firebug_logger
+        @_firebug_logger ||= FirebugLogger.new
+      end
+      
+      def dump_firebug_profile
+        return if firebug_logger.logs.empty?
+
+        logs = firebug_logger.logs.collect do |message|
+          # We have to add any escape characters
+          "console.info('#{self.class.helpers.escape_javascript(message)}');"
+        end.join("\n")
+
+        response.body << self.class.helpers.javascript_tag(logs)
+      end
+    end
+  end
+end

data/lib/easy_profiler/configuration.rb

@@ -0,0 +1,120 @@
+module EasyProfiler
+  class Configuration
+    # Value indicating whether profiling is globally enabled.
+    attr_reader :enable_profiling
+    
+    # Minimum time period which should be reached to dump
+    # profile to the log.
+    attr_reader :print_limit
+
+    # Value indicating whether profiler should log an
+    # approximate number of instantiated ActiveRecord objects.
+    attr_reader :count_ar_instances
+
+    # Value indicating whether profiler should log an
+    # approximate amount of memory used.
+    attr_reader :count_memory_usage
+
+    # Accepts a logger conforming to the interface of Log4r or the
+    # default Ruby 1.8+ Logger class, which is then passed
+    # on to any profiler instance made.
+    attr_writer :logger
+
+    attr_reader :colorize_logging
+
+    # Value indicating whether profiler should flush
+    # logs on every checkpoint.
+    attr_reader :live_logging
+
+    def initialize
+      @enable_profiling   = false
+      @print_limit        = 0.01
+      @count_ar_instances = false
+      @count_memory_usage = false
+      @logger             = nil
+      @colorize_logging   = true
+      @live_logging       = false
+    end
+    
+    # Sets a value indicating whether profiling is globally enabled.
+    def enable_profiling=(value)
+      @enable_profiling = !!value
+    end
+
+    # Sets a minimum time period which should be reached to dump
+    # profile to the log.
+    def print_limit=(value)
+      @print_limit = FalseClass === value ? false : value.to_f
+    end
+
+    # Sets a value indicating whether profiler should log an
+    # approximate number of instantiated ActiveRecord objects.
+    def count_ar_instances=(value)
+      @count_ar_instances = !!value
+    end
+
+    # Sets a value indicating whether profiler should log an
+    # approximate amount of memory used.
+    # 
+    # @param Boolean value
+    #   identifies whether memory profiling should be enabled.
+    # 
+    def count_memory_usage=(value)
+      @count_memory_usage = !!value
+    end
+
+    def colorize_logging=(value)
+      @colorize_logging = !!value
+    end
+
+    # Sets a value indicating whether profiler should flush
+    # logs on every checkpoint.
+    # 
+    def live_logging=(value)
+      @live_logging = !!value
+    end
+
+    # Gets a logger instance.
+    #
+    # When profiler is started inside Rails application,
+    # creates a "log/profile.log" files where all profile
+    # logs will be places. In regular scripts dumps
+    # information directly to STDOUT. You can use
+    # <tt>EasyProfiler.configuration.logger</tt> to set another
+    # logger.
+    # 
+    def logger
+      unless @logger
+        @logger = if Object.const_defined?(:Rails)
+          Logger.new(File.join(Rails.root, 'log', 'profile.log'))
+        else
+          Logger.new($stdout)
+        end
+      end
+      @logger
+    end
+
+    def merge(options = {})
+      config = self.dup
+      config.enable_profiling   = options[:enabled]            if options.has_key?(:enabled)
+      config.enable_profiling   = options[:enable_profiling]   if options.has_key?(:enable_profiling)
+      config.print_limit        = options[:limit]              if options.has_key?(:limit)
+      config.print_limit        = options[:print_limit]        if options.has_key?(:print_limit)
+      config.count_ar_instances = options[:count_ar_instances] if options.has_key?(:count_ar_instances)
+      config.count_memory_usage = options[:count_memory_usage] if options.has_key?(:count_memory_usage)
+      config.logger             = options[:logger]             if options.has_key?(:logger)
+      config.colorize_logging   = options[:colorize_logging]   if options.has_key?(:colorize_logging)
+      config.live_logging       = options[:live_logging]       if options.has_key?(:live_logging)
+      
+      config
+    end
+    
+    def disable_gc?
+      count_ar_instances or count_memory_usage
+    end
+    
+    def enabled?
+      enable_profiling
+    end
+  end
+end

data/lib/easy_profiler/firebug_logger.rb

@@ -0,0 +1,27 @@
+module EasyProfiler
+  # A logger used to output logs to the Firebug console.
+  #
+  # Based on http://rails.aizatto.com/category/plugins/firebug-logger/
+  class FirebugLogger
+    attr_accessor :logs
+    
+    def initialize #:nodoc:
+      @logs = []
+    end
+
+    # Clear the logs.
+    def clear
+      @logs = []
+    end
+
+    # Adds a line to the log.
+    #
+    # == arguments
+    # * +message+ -- log message to be logged
+    # * +block+  -- optional. Return value of the block will be the message that will be logged.
+    def info(message = nil)
+      message = yield if message.nil? && block_given?
+      @logs << message
+    end
+  end
+end

data/lib/easy_profiler/no_profile_instance.rb

@@ -0,0 +1,5 @@
+module EasyProfiler
+  # Class used when profiling is disabled. Does nothing.
+  class NoProfileInstance < ProfileInstanceBase
+  end
+end

data/lib/easy_profiler/profile.rb

@@ -0,0 +1,59 @@
+module EasyProfiler
+  # Contains global profiling parameters and methods to start and
+  # stop profiling.
+  class Profile
+    @@profile_results    = {}
+
+    # Starts a profiling session.
+    #
+    # Parameters:
+    # * +name+ -- session name.
+    # * +options+ -- a +Hash+ of options.
+    #
+    # Possible options:
+    # * <tt>:enabled</tt> -- value indicating whether profiling is enabled.
+    # * <tt>:limit</tt> -- minimum time period which should be reached to print profiling log.
+    # * <tt>:count_ar_instances</tt> —- indicating whether profiler should log an approximate number of instantiated ActiveRecord objects.
+    # * <tt>:count_memory_usage</tt> —- indicating whether profiler should log an approximate amount of memory used.
+    # * <tt>:logger</tt> -- a +Logger+ instance.
+    # * <tt>:colorize_logging</tt> -- indicating whether profiling log lines should be colorized.
+    # * <tt>:live_logging</tt> -- indicating whether profiler should flush logs on every checkpoint.
+    #
+    # Returns:
+    # * an instance of profiler (descendant of the <tt>EasyProfiler::ProfileInstanceBase</tt> class).
+    def self.start(name, options = {})
+      if @@profile_results[name]
+        raise ArgumentError.new("EasyProfiler::Profile.start() collision! '#{name}' is already started.")
+      end
+
+      config = EasyProfiler.configuration.merge(options)
+
+      # Disable garbage collector to get more precise results
+      GC.disable if config.disable_gc?
+
+      klass = config.enabled? ? ProfileInstance : NoProfileInstance
+      instance = klass.new(name, config)
+
+      @@profile_results[name] = instance
+    end
+
+    # Finishes a profiling session and dumps results to the log.
+    #
+    # Parameters:
+    # * +name+ -- session name, used in +start+ method.
+    def self.stop(name)
+      unless instance = @@profile_results.delete(name)
+        raise ArgumentError.new("EasyProfiler::Profile.stop() error! '#{name}' is not started yet.")
+      end
+
+      instance.dump_results
+
+      # Enable garbage collector which has been disabled before
+      GC.enable if instance.config.disable_gc?
+    end
+
+    def self.reset!
+      @@profile_results    = {}
+    end
+  end
+end

data/lib/easy_profiler/profile_instance.rb

@@ -0,0 +1,111 @@
+module EasyProfiler
+  # Class used when profiling is disabled.
+  class ProfileInstance < ProfileInstanceBase
+    # Sets a profiling checkpoint (block execution time will be printed).
+    #
+    # Parameters:
+    # * message -- a message to associate with a check point.
+    def progress(message)
+      progress = (now = Time.now.to_f) - @progress
+      @progress = now
+
+      ar_instances_count = if config.count_ar_instances
+        ar_instances_delta = (ar_instances = active_record_instances_count) - @current_ar_instances
+        @current_ar_instances = ar_instances
+        ", #{ar_instances_delta} AR objects"
+      end
+
+      memory_usage_value = if config.count_memory_usage
+        memory_usage_delta = (memory_usage = process_memory_usage) - @current_memory_usage
+        @current_memory_usage = memory_usage
+        ", #{format_memory_size(total_memory_usage)}"
+      end
+
+      buffer_checkpoint("progress: %0.4f s#{ar_instances_count}#{memory_usage_value} [#{message}]" % progress)
+    end
+
+    # Sets a profiling checkpoint without execution time printing.
+    #
+    # Parameters:
+    # * message -- a message to associate with a check point.
+    def debug(message)
+      @progress = Time.now.to_f
+      buffer_checkpoint("debug: #{message}")
+    end
+
+    # Dumps results to the log.
+    def dump_results
+      progress('END')
+      t = total
+
+      if config.live_logging || false === config.print_limit || t > config.print_limit.to_f
+        log_header(true)
+        @buffer.each { |message| log_line(message) }
+        log_footer(t)
+      end
+    end
+
+    private
+
+      # Gets a total profiling time.
+      def total
+        Time.now.to_f - @start
+      end
+
+      # Gets a number of total AR objects instantiated number.
+      def total_ar_instances
+        active_record_instances_count - @start_ar_instances
+      end
+
+      # Gets a total amount of memory used.
+      def total_memory_usage
+        process_memory_usage - @start_memory_usage
+      end
+
+      # Buffers a profiling checkpoint.
+      def buffer_checkpoint(message)
+        log_header
+        if config.live_logging
+          log_line(message)
+        else
+          @buffer << message
+        end
+      end
+
+      # Write a header to the log.
+      def log_header(force = false)
+        if (config.live_logging && !@header_printed) || (!config.live_logging && force)
+          log_line("Benchmark results:")
+          @header_printed = true
+        end
+      end
+
+      # Write a footer with summary stats to the log.
+      def log_footer(total_time)
+        ar_instances_count = if config.count_ar_instances
+          ", #{total_ar_instances} AR objects"
+        end
+
+        memory_usage_value = if config.count_memory_usage
+          ", #{format_memory_size(total_memory_usage)}"
+        end
+
+        log_line("results: %0.4f s#{ar_instances_count}#{memory_usage_value}" % total_time)
+      end
+
+      # Write a log line.
+      def log_line(line)
+        if config.colorize_logging
+          @@row_even, message_color = if @@row_even
+            [false, '4;32;1']
+          else
+            [true, '4;33;1']
+          end
+
+          config.logger.info("  [\e[#{message_color}m%s\e[0m] %s" % [@name, line])
+        else
+          config.logger.info("[%s] %s" % [@name, line])
+        end
+      end
+    end
+end

data/lib/easy_profiler/profile_instance_base.rb

@@ -0,0 +1,93 @@
+module EasyProfiler
+  # Base class for profilers.
+  class ProfileInstanceBase
+    attr_reader :name, :config
+
+    @@row_even = true
+
+    # Initializes a new instance of +ProfileInstanceBase+ class.
+    #
+    # Parameters:
+    # * name -- session name.
+    # * options -- a +Hash+ of options (see <tt>EasyProfiler::Profile.start</tt> for details).
+    def initialize(name, config = nil)
+      @name = name
+      @config = case config
+        when Hash: EasyProfiler.configuration.merge(config)
+        when EasyProfiler::Configuration: config
+        else EasyProfiler.configuration
+      end
+
+      @start = @progress = Time.now.to_f
+
+      # Initial number of ActiveRecord::Base objects
+      if @config.count_ar_instances
+        @start_ar_instances = @current_ar_instances = active_record_instances_count
+      end
+
+      # Initial amount of memory used
+      if @config.count_memory_usage
+        @start_memory_usage = @current_memory_usage = process_memory_usage
+      end
+
+      # A buffer where all log messeges will be stored till the
+      # end of the profiling block. We need this because not every
+      # profiling log will be printed (see EasyProf::Configuration.print_limit).
+      @buffer = []
+    end
+
+    # Sets a profiling checkpoint (block execution time will be printed).
+    #
+    # Parameters:
+    # * message -- a message to associate with a check point.
+    #
+    def progress(message)
+    end
+
+    # Sets a profiling checkpoint without execution time printing.
+    #
+    # Parameters:
+    # * message -- a message to associate with a check point.
+    #
+    def debug(message)
+    end
+
+    # Dumps results to the log.
+    def dump_results
+    end
+
+    protected
+
+      # Returns a number of ActiveRecord instances in the Object Space.
+      #
+      def active_record_instances_count
+        count = 0
+        ObjectSpace.each_object(::ActiveRecord::Base) { count += 1 }
+        count
+      end
+
+      # Returns an amount of memory used by current Ruby process.
+      #
+      def process_memory_usage
+        `ps -o rss= -p #{$$}`.to_i
+      end
+
+      # Formats an amount of memory to print.
+      #
+      def format_memory_size(number)
+        if number > 10 ** 9
+          number = number.to_f / (10 ** 9)
+          suffix = 'G'
+        elsif number > 10 ** 6
+          number = number.to_f / (10 ** 6)
+          suffix = 'M'
+        elsif number > 10 ** 3
+          number = number.to_f / (10 ** 3)
+          suffix = 'K'
+        else
+          suffix = 'B'
+        end
+        "%.2f#{suffix}" % number
+      end
+  end
+end

data/spec/easy_profiler_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'easy_profiler' do
+  it 'should pass block results outside' do
+    easy_profiler('test') { 1 }.should == 1
+    easy_profiler('test') { 'xxx' }.should == 'xxx'
+  end
+end

data/spec/no_profile_instance_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe EasyProfiler::NoProfileInstance do
+  it 'should receive name and options in initialize' do
+    profiler = EasyProfiler::NoProfileInstance.new('myprofiler1')
+    profiler.name.should == 'myprofiler1'
+    profiler.config.should be(EasyProfiler.configuration)
+
+    profiler = EasyProfiler::NoProfileInstance.new('myprofiler2', { :print_limit => 100 })
+    profiler.name.should == 'myprofiler2'
+    profiler.config.print_limit.should == 100
+  end
+
+  it 'should respond to :progress' do
+    profiler = EasyProfiler::NoProfileInstance.new('myprofiler')
+    profiler.should respond_to(:progress)
+    lambda {
+      profiler.progress('message')
+    }.should_not raise_error
+  end
+
+  it 'should respond to :debug' do
+    profiler = EasyProfiler::NoProfileInstance.new('myprofiler')
+    profiler.should respond_to(:debug)
+    lambda {
+      profiler.debug('message')
+    }.should_not raise_error
+  end
+
+  it 'should respond to :dump_results' do
+    profiler = EasyProfiler::NoProfileInstance.new('myprofiler')
+    profiler.should respond_to(:dump_results)
+    lambda {
+      profiler.dump_results
+    }.should_not raise_error
+  end
+end

data/spec/profile_instance_spec.rb

@@ -0,0 +1,113 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe EasyProfiler::ProfileInstance do
+  it 'should receive name and options in initialize' do
+    profiler = EasyProfiler::ProfileInstance.new('myprofiler1')
+    profiler.name.should == 'myprofiler1'
+    profiler.config.should be(EasyProfiler.configuration)
+
+    profiler = EasyProfiler::ProfileInstance.new('myprofiler2', { :print_limit => 100 })
+    profiler.name.should == 'myprofiler2'
+    profiler.config.print_limit.should == 100
+
+    config = EasyProfiler::Configuration.new
+    config.print_limit = 100
+    profiler = EasyProfiler::ProfileInstance.new('myprofiler3', config)
+    profiler.name.should == 'myprofiler3'
+    profiler.config.should be(config)
+  end
+
+  it 'should respond to :progress' do
+    profiler = EasyProfiler::ProfileInstance.new('myprofiler')
+    profiler.should respond_to(:progress)
+    lambda {
+      profiler.progress('message')
+      buffer = profiler.instance_variable_get(:@buffer)
+      buffer.should have(1).item
+      buffer.first.should match(/progress: \d+\.\d+ s \[message\]/)
+    }.should_not raise_error
+  end
+
+  it 'should respond to :debug' do
+    profiler = EasyProfiler::ProfileInstance.new('myprofiler')
+    profiler.should respond_to(:debug)
+    lambda {
+      profiler.debug('message')
+      buffer = profiler.instance_variable_get(:@buffer)
+      buffer.should have(1).item
+      buffer.first.should match(/debug: message/)
+    }.should_not raise_error
+  end
+
+  it 'should respond to :dump_results' do
+    logger = mock('MockLogger')
+    profiler = EasyProfiler::ProfileInstance.new('myprofiler', :logger => logger, :enabled => true, :limit => false, :colorize_logging => false)
+    profiler.should respond_to(:dump_results)
+
+    profiler.progress('progress message')
+    profiler.debug('debug message')
+
+    logger.should_receive(:info).ordered.with(/\[myprofiler\] Benchmark results:/)
+    logger.should_receive(:info).ordered.with(/\[myprofiler\] progress: \d+\.\d+ s \[progress message\]/)
+    logger.should_receive(:info).ordered.with(/\[myprofiler\] debug: debug message/)
+    logger.should_receive(:info).ordered.with(/\[myprofiler\] progress: \d+\.\d+ s \[END\]/)
+    logger.should_receive(:info).ordered.with(/\[myprofiler\] results: \d+\.\d+ s/)
+
+    profiler.dump_results
+  end
+
+  it 'should render nothing when time limit not reached' do
+    logger = mock('MockLogger')
+    profiler = EasyProfiler::ProfileInstance.new('myprofiler', :logger => logger, :enabled => true, :limit => 20)
+    logger.should_not_receive(:info)
+    profiler.dump_results
+  end
+
+  context 'when live logging is enabled' do
+    before :each do
+      @logger = mock('MockLogger').as_null_object
+      @profiler = EasyProfiler::ProfileInstance.new('myprofiler', :logger => @logger, :enabled => true, :live_logging => true, :colorize_logging => false)
+    end
+
+    it 'should print header when progress called first time' do
+      @logger.should_receive(:info).with(/\[myprofiler\] Benchmark results:/)
+      @profiler.progress('progress message')
+    end
+
+    it 'should print header when debug called first time' do
+      @logger.should_receive(:info).with(/\[myprofiler\] Benchmark results:/)
+      @profiler.debug('progress message')
+    end
+
+    it 'should not print header in dump_results' do
+      @profiler.debug('progress message')
+      @logger.should_not_receive(:info).with(/\[myprofiler\] Benchmark results:/)
+      @profiler.dump_results
+    end
+
+    it 'should print foter in dump_results' do
+      @profiler.debug('progress message')
+      @logger.should_receive(:info).ordered.with(/\[myprofiler\] results: \d+\.\d+ s/)
+      @profiler.dump_results
+    end
+
+    it 'should flush logs on every checkpoing if live logging is enabled' do
+      @logger.should_receive(:info).with(/\[myprofiler\] Benchmark results:/)
+      @logger.should_receive(:info).ordered.with(/\[myprofiler\] progress: \d+\.\d+ s \[progress message\]/)
+      @logger.should_receive(:info).ordered.with(/\[myprofiler\] debug: debug message/)
+      @profiler.progress('progress message')
+      @profiler.debug('debug message')
+    end
+
+    it 'should print footer in dump_results' do
+      @logger.should_receive(:info).with(/\[myprofiler\] results: \d+\.\d+ s/)
+      @profiler.dump_results
+    end
+
+    it 'should print header in dump_results if did not already' do
+      @logger.should_receive(:info).with(/\[myprofiler\] Benchmark results:/)
+      @logger.should_receive(:info).with(/\[myprofiler\] results: \d+\.\d+ s/)
+      @profiler.dump_results
+    end
+  end
+end

data/spec/profile_spec.rb

@@ -0,0 +1,113 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe EasyProfiler::Profile do
+  after :each do
+    EasyProfiler.configure do |config|
+      config.enable_profiling   = false
+      config.print_limit        = 0.01
+      config.count_ar_instances = false
+      config.count_memory_usage = false
+    end
+    EasyProfiler::Profile.reset!
+  end
+  
+  context '.start' do
+    it 'should pass name to profile instance' do
+      EasyProfiler::Profile.start('myprofiler').name.should == 'myprofiler'
+    end
+
+    it 'should pass options to profile instance' do
+      options = { :print_limit => 100 }
+      EasyProfiler::Profile.start('myprofiler', options).config.print_limit.should == 100
+    end
+
+    it 'should create a ProfileInstance object when enabled' do
+      options = { :enabled => true }
+      EasyProfiler::Profile.start('myprofiler', options).class.should == EasyProfiler::ProfileInstance
+    end
+
+    it 'should create a NoProfileInstance object when disabled' do
+      options = { :enabled => false }
+      EasyProfiler::Profile.start('myprofiler', options).class.should == EasyProfiler::NoProfileInstance
+    end
+
+    it 'should raise an error when two profilers with the same name started' do
+      EasyProfiler::Profile.start('myprofiler')
+      lambda {
+        EasyProfiler::Profile.start('myprofiler')
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'should use global :enabled value' do
+      EasyProfiler::Profile.start('myprofiler1').config.enable_profiling.should be_false
+      EasyProfiler.config.enable_profiling = true
+      EasyProfiler::Profile.start('myprofiler2').config.enable_profiling.should be_true
+    end
+
+    it 'should use global :limit value' do
+      EasyProfiler::Profile.start('myprofiler1').config.print_limit.should == 0.01
+      EasyProfiler.config.print_limit = 10
+      EasyProfiler::Profile.start('myprofiler2').config.print_limit.should == 10.0
+    end
+
+    it 'should use global :count_ar_instances value' do
+      EasyProfiler::Profile.start('myprofiler1').config.count_ar_instances.should be_false
+      EasyProfiler.config.count_ar_instances = true
+      EasyProfiler::Profile.start('myprofiler2').config.count_ar_instances.should be_true
+    end
+
+    it 'should use global :count_memory_usage value' do
+      EasyProfiler::Profile.start('myprofiler1').config.count_memory_usage.should be_false
+      EasyProfiler.config.count_memory_usage = true
+      EasyProfiler::Profile.start('myprofiler2').config.count_memory_usage.should be_true
+    end
+
+    it 'should use global :logger value' do
+      logger = mock('MockLogger')
+      EasyProfiler.config.logger = logger
+      EasyProfiler::Profile.start('myprofiler2').config.logger.should be(logger)
+    end
+
+    it 'should use global :live_logging value' do
+      EasyProfiler::Profile.start('myprofiler1').config.live_logging.should be_false
+      EasyProfiler.config.live_logging = true
+      EasyProfiler::Profile.start('myprofiler2').config.live_logging.should be_true
+    end
+    
+    it 'should disable garbage collector when needed' do
+      options = { :enabled => true, :count_ar_instances => true }
+      GC.should_receive(:disable)
+      EasyProfiler::Profile.start('myprofiler1', options)
+
+      options = { :enabled => true, :count_memory_usage => true }
+      GC.should_receive(:disable)
+      EasyProfiler::Profile.start('myprofiler2', options)
+    end
+  end
+
+  context '.stop' do
+    it 'should raise an error when profiler is not started' do
+      lambda {
+        EasyProfiler::Profile.stop('myprofiler')
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'should call dump_results method on profiler' do
+      profiler = mock_profile_start('myprofiler', :enabled => true)
+      profiler.should_receive(:dump_results)
+      EasyProfiler::Profile.stop('myprofiler')
+    end
+
+    it 'should enable back garbage collector when needed' do
+      profiler = mock_profile_start('myprofiler1', :enabled => true, :count_ar_instances => true)
+      profiler.stub!(:dump_results)
+      GC.should_receive(:enable)
+      EasyProfiler::Profile.stop('myprofiler1')
+
+      profiler = mock_profile_start('myprofiler2', :enabled => true, :count_memory_usage => true)
+      profiler.stub!(:dump_results)
+      GC.should_receive(:enable)
+      EasyProfiler::Profile.stop('myprofiler2')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'active_record'
+require File.join(File.dirname(__FILE__), "../lib/easy_prof")
+
+def mock_profile_start(name, options = {})
+  config = EasyProfiler.configuration.merge(options)
+  profiler = mock 'MockProfiler', :name => name, :config => config
+  EasyProfiler::Profile.send(:class_variable_get, :@@profile_results)[name] = profiler
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: easy-prof
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Dmytro Shteflyuk
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-23 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Simple Ruby code profiler to use both in Rails applications and generic Ruby scripts.
+email: kpumuk@kpumuk.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- init.rb
+- lib/easy_prof.rb
+- lib/easy_profiler/action_controller_extensions.rb
+- lib/easy_profiler/configuration.rb
+- lib/easy_profiler/firebug_logger.rb
+- lib/easy_profiler/no_profile_instance.rb
+- lib/easy_profiler/profile.rb
+- lib/easy_profiler/profile_instance.rb
+- lib/easy_profiler/profile_instance_base.rb
+- spec/easy_profiler_spec.rb
+- spec/no_profile_instance_spec.rb
+- spec/profile_instance_spec.rb
+- spec/profile_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/kpumuk/easy-prof
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Simple and easy to use Ruby code profiler
+test_files: 
+- spec/easy_profiler_spec.rb
+- spec/no_profile_instance_spec.rb
+- spec/profile_instance_spec.rb
+- spec/profile_spec.rb
+- spec/spec_helper.rb