request-log-analyzer 1.1.0 → 1.1.1

data/README.rdoc

@@ -5,7 +5,7 @@ Merb to produce a performance report. Its purpose is to find what actions are be
 
 * Analyzes Rails log files (all versions)
 * Can combine multiple files (handy if you are using logrotate)
-* Uses several metrics, including cumulative request time, average request time, process blockers, database and rendering time, HTTP methods and states, Rails action cache statistics, etc.) (Sample output: http://wiki.github.com/wvanbergen/request-log-analyzer/sample-output)
+* Uses several metrics, including cumulative request time, average request time, process blockers, database and rendering time, HTTP methods and statuses, Rails action cache statistics, etc.) (Sample output: http://wiki.github.com/wvanbergen/request-log-analyzer/sample-output)
 * Low memory footprint (server-safe)
 * Fast
 * MIT licensed
@@ -32,10 +32,11 @@ To analyze a log file and produce a performance report, run request-log-analyzer
 
   $ request-log-analyzer log/production.log
 
-For more details and available command line options, see the project's wiki:http://wiki.github.com/wvanbergen/request-log-analyzer/basic-usage
+For more details and available command line options, see the project's wiki: http://wiki.github.com/wvanbergen/request-log-analyzer/basic-usage
 
 == Additional information
 
 * Project wiki at GitHub: http://wiki.github.com/wvanbergen/request-log-analyzer
+* RDoc documentation: http://wvanbergen.github.com/request-log-analyzer
 * wvanbergen's blog posts: http://techblog.floorplanner.com/tag/request-log-analyzer
-* bart ten brinke's blog posts: http://movesonrails.com
+* barttenbrinke's blog posts: http://movesonrails.com/articles/tag/analyzer

data/bin/request-log-analyzer

@@ -115,11 +115,10 @@ when :anonymize
   require File.dirname(__FILE__) + '/../lib/request_log_analyzer/log_processor'    
   RequestLogAnalyzer::LogProcessor.build(:anonymize, arguments).run!  
 else 
-  puts "Request log analyzer, by Willem van Bergen and Bart ten Brinke - Version 1.0\n\n"  
-  
+  puts "Request-log-analyzer, by Willem van Bergen and Bart ten Brinke - version #{RequestLogAnalyzer::VERSION}"  
+  puts "Website: http://github.com/wvanbergen/request-log-analyzer"
+  puts
+
   # Run the request_log_analyzer!
   RequestLogAnalyzer::Controller.build(arguments).run!
-
-  puts 
-  puts "Thanks for using request-log-analyzer"
 end

data/lib/cli/command_line_arguments.rb

@@ -140,8 +140,8 @@ module CommandLine
       end
     end
     
-    OPTION_REGEXP  = /^\-\-([A-z0-9-]+)$/;
-    ALIASES_REGEXP = /^\-([A-z0-9]+)$/
+    OPTION_REGEXP  = /^\-\-([A-Za-z0-9-]+)$/;
+    ALIASES_REGEXP = /^\-([A-Aa-z0-9]+)$/
     
     attr_reader :definition
     attr_reader :tokens

data/lib/request_log_analyzer.rb

@@ -1,14 +1,36 @@
 require 'date'
 require File.dirname(__FILE__) + '/cli/progressbar'
 
+module RequestLogAnalyzer
+   
+  VERSION = '1.1'
+    
+  # Function to implement 
+  def self.load_default_class_file(base, const)
+    path     = to_underscore(base.to_s)
+    basename = to_underscore(const.to_s)
+    filename = "#{File.dirname(__FILE__)}/#{path}/#{basename}"
+    require filename
+    base.const_get(const)
+  end
+
+  # Convert a string/symbol in camelcase (RequestLogAnalyzer::Controller) to underscores (request_log_analyzer/controller)
+  def self.to_underscore(str)
+    str.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+  end  
+
+  # Convert a string/symbol in underscores (request_log_analyzer/controller) to camelcase (RequestLogAnalyzer::Controller)    
+  def self.to_camelcase(str)
+    str.to_s.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+end
+
 require File.dirname(__FILE__) + '/request_log_analyzer/file_format'
 require File.dirname(__FILE__) + '/request_log_analyzer/line_definition'
 require File.dirname(__FILE__) + '/request_log_analyzer/request'
-require File.dirname(__FILE__) + '/request_log_analyzer/log_parser'
-require File.dirname(__FILE__) + '/request_log_analyzer/aggregator/base'
-require File.dirname(__FILE__) + '/request_log_analyzer/aggregator/summarizer'
-require File.dirname(__FILE__) + '/request_log_analyzer/filter/base'
+require File.dirname(__FILE__) + '/request_log_analyzer/aggregator'
+require File.dirname(__FILE__) + '/request_log_analyzer/filter'
 require File.dirname(__FILE__) + '/request_log_analyzer/controller'
-require File.dirname(__FILE__) + '/request_log_analyzer/source/base'
-require File.dirname(__FILE__) + '/request_log_analyzer/source/log_file'
+require File.dirname(__FILE__) + '/request_log_analyzer/source'
 require File.dirname(__FILE__) + '/request_log_analyzer/output'
+

data/lib/request_log_analyzer/{aggregator/base.rb → aggregator.rb}

@@ -1,5 +1,9 @@
 module RequestLogAnalyzer::Aggregator
-
+  
+  def self.const_missing(const)
+    RequestLogAnalyzer::load_default_class_file(self, const)
+  end
+  
   # The base class of an aggregator. This class provides the interface to which
   # every aggregator should comply (by simply subclassing this class).
   class Base

data/lib/request_log_analyzer/aggregator/summarizer.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../tracker/base'
+require File.dirname(__FILE__) + '/../tracker'
 
 module RequestLogAnalyzer::Aggregator
 
@@ -33,8 +33,7 @@ module RequestLogAnalyzer::Aggregator
       end      
       
       def track(tracker_klass, options = {})
-        require "#{File.dirname(__FILE__)}/../tracker/#{tracker_klass}"
-        tracker_klass = RequestLogAnalyzer::Tracker.const_get(tracker_klass.to_s.split(/[^a-z0-9]/i).map{ |w| w.capitalize }.join('')) if tracker_klass.kind_of?(Symbol)
+        tracker_klass = RequestLogAnalyzer::Tracker.const_get(RequestLogAnalyzer::to_camelcase(tracker_klass)) if tracker_klass.kind_of?(Symbol)
         @trackers << tracker_klass.new(options)
       end
     end

data/lib/request_log_analyzer/controller.rb

@@ -62,7 +62,7 @@ module RequestLogAnalyzer
         options.store(:source_files, arguments.parameters)
       end
       
-      controller = Controller.new(RequestLogAnalyzer::Source::LogFile.new(file_format, options), options)
+      controller = Controller.new(RequestLogAnalyzer::Source::LogParser.new(file_format, options), options)
 
       options[:assume_correct_order] = arguments[:assume_correct_order]
       
@@ -147,12 +147,8 @@ module RequestLogAnalyzer
     
     # Adds an aggregator to the controller. The aggregator will be called for every request 
     # that is parsed from the provided sources (see add_source)
-    def add_aggregator(agg)
-      if agg.kind_of?(Symbol)
-        require File.dirname(__FILE__) + "/aggregator/#{agg}"
-        agg = RequestLogAnalyzer::Aggregator.const_get(agg.to_s.split(/[^a-z0-9]/i).map{ |w| w.capitalize }.join(''))
-      end
-      
+    def add_aggregator(agg)      
+      agg = RequestLogAnalyzer::Aggregator.const_get(RequestLogAnalyzer::to_camelcase(agg)) if agg.kind_of?(Symbol)
       @aggregators << agg.new(@source, @options)
     end
     
@@ -160,11 +156,7 @@ module RequestLogAnalyzer
     
     # Adds a request filter to the controller.
     def add_filter(filter, filter_options = {})
-      if filter.kind_of?(Symbol)
-        require File.dirname(__FILE__) + "/filter/#{filter}"
-        filter = RequestLogAnalyzer::Filter.const_get(filter.to_s.split(/[^a-z0-9]/i).map{ |w| w.capitalize }.join(''))
-      end
-      
+      filter = RequestLogAnalyzer::Filter.const_get(RequestLogAnalyzer::to_camelcase(filter)) if filter.kind_of?(Symbol)
       @filters << filter.new(file_format, @options.merge(filter_options))
     end
     
@@ -178,13 +170,11 @@ module RequestLogAnalyzer
     # 6. Finalize Source
     def run!
       
-
-      
       @filters.each { |filter| filter.prepare }
       @aggregators.each { |agg| agg.prepare }
       
       begin
-        @source.requests do |request|
+        @source.each_request do |request|
           @filters.each { |filter| request = filter.filter(request) }
           @aggregators.each { |agg| agg.aggregate(request) } if request
         end
@@ -201,7 +191,12 @@ module RequestLogAnalyzer
             
       @source.finalize
       
-
+      if @output.io.kind_of?(File)
+        puts
+        puts "Report written to: " + File.expand_path(@output.io.path)
+        puts "Thanks for using request-log-analyzer!"
+        @output.io.close
+      end
     end
     
   end

data/lib/request_log_analyzer/file_format.rb

@@ -1,29 +1,80 @@
-module RequestLogAnalyzer
+module RequestLogAnalyzer::FileFormat
   
-  class FileFormat
+  
+  def self.const_missing(const)
+    RequestLogAnalyzer::load_default_class_file(self, const)
+  end  
+  
+  # Loads a FileFormat::Base subclass instance.
+  # You can provide:
+  # * A FileFormat instance (which will return itself)
+  # * A FileFormat class (of which an imstance will be returned)
+  # * A filename (from which the FileFormat class is loaded)
+  # * A symbol of a built-in file format (e.g. :rails)
+  def self.load(file_format)
+    klass = nil
+    if file_format.kind_of?(RequestLogAnalyzer::FileFormat::Base)
+      # this already is a file format! return itself
+      return @current_file_format = file_format
+
+    elsif file_format.kind_of?(Class) && file_format.ancestors.include?(RequestLogAnalyzer::FileFormat::Base)
+      # a usable class is provided. Use this format class.
+      klass = file_format
+
+    elsif file_format.kind_of?(String) && File.exist?(file_format)
+      # load a format from a ruby file
+      require file_format
+      klass = Object.const_get(RequestLogAnalyzer::to_camelcase(File.basename(file_format, '.rb')))
+
+    else
+      # load a provided file format
+      klass = RequestLogAnalyzer::FileFormat.const_get(RequestLogAnalyzer::to_camelcase(file_format))      
+    end
     
-    # Makes classes aware of a file format by registering the file_format variable
-    module Awareness
-      
-      def self.included(base)
-        base.send(:attr_reader, :file_format)
-      end
-      
-      def register_file_format(format)
-        @file_format = format
-      end
+    raise if klass.nil?
+    @current_file_format = klass.new # return an instance of the class
+  end  
+  
+  # Makes classes aware of a file format by registering the file_format variable
+  module Awareness
+    
+    def self.included(base)
+      base.send(:attr_reader, :file_format)
     end
+    
+    def register_file_format(format)
+      @file_format = format
+    end
+  end  
+
+  # Base class for all log file format definitions. This class provides functions for subclasses to 
+  # define their LineDefinitions and to define a summary report.
+  #
+  # A subclass of this class is instantiated when request-log-analyzer is started and this instance
+  # is shared with all components of the application so they can act on the specifics of the format
+  class Base
       
+    # Registers the line definer instance for a subclass.
     def self.inherited(subclass)
        subclass.instance_variable_set(:@line_definer, RequestLogAnalyzer::LineDefinition::Definer.new)
        subclass.class_eval { class << self; attr_accessor :line_definer; end } 
-       subclass.class_eval { class << self; attr_accessor :report_definer; end }       
+       subclass.class_eval { class << self; attr_accessor :report_definer; end }
+       
+       unless subclass.const_defined?('Request')
+         subclass.const_set('Request', Class.new(RequestLogAnalyzer::Request))         
+       end
     end    
     
+    # Specifies a single line defintions.
     def self.line_definition(name, &block)
       @line_definer.send(name, &block)
     end
     
+    def create_request(*hashes)
+      self.class::Request.create(self, *hashes)
+    end
+    
+    # Specifies multiple line definitions at once using a block
     def self.format_definition(&block)
       if block_given?
         yield(@line_definer) 
@@ -32,48 +83,30 @@ module RequestLogAnalyzer
       end
     end
     
+    # Specifies the summary report using a block.
     def self.report(&block)
       @report_definer = RequestLogAnalyzer::Aggregator::Summarizer::Definer.new
       yield(@report_definer)
     end
 
-    def self.load(file_format)
-      if file_format.kind_of?(RequestLogAnalyzer::FileFormat)
-        # this already is a file format! return itself
-        return file_format
-
-      elsif file_format.kind_of?(Class) && file_format.ancestors.include?(RequestLogAnalyzer::FileFormat)
-        klass = file_format
-
-      elsif file_format.kind_of?(String) && File.exist?(file_format)
-        # load a format from a ruby file
-        require file_format
-        klass_name = File.basename(file_format, '.rb').split(/[^a-z0-9]/i).map{ |w| w.capitalize }.join('')
-        klass = Object.const_get(klass_name)
-
-      elsif File.exist?("#{File.dirname(__FILE__)}/file_format/#{file_format}.rb")
-        # load a provided file format
-        require "#{File.dirname(__FILE__)}/file_format/#{file_format}"
-        klass_name = file_format.to_s.split(/[^a-z0-9]/i).map{ |w| w.capitalize }.join('')
-        klass = RequestLogAnalyzer::FileFormat.const_get(klass_name)
-        
-      end
-      
-      klass.new # return an instance of the class
-    end
-    
+    # Returns all line definitions
     def line_definitions
       @line_definitions ||= self.class.line_definer.line_definitions
     end
     
+    # Returns all the defined trackers for the summary report.
     def report_trackers
       self.class.instance_variable_get(:@report_definer).trackers rescue []
     end
     
+    # Checks whether the line definitions form a valid language.
+    # A file format should have at least a header and a footer line type
     def valid?
       line_definitions.detect { |(name, ld)| ld.header } && line_definitions.detect { |(name, ld)| ld.footer }
     end
     
+    # Function that a file format con implement to monkey patch the environment.
+    # * <tt>controller</tt> The environment is provided as a controller instance
     def setup_environment(controller)
       
     end

data/lib/request_log_analyzer/file_format/merb.rb

@@ -1,33 +1,39 @@
-module RequestLogAnalyzer::FileFormat::Merb
+module RequestLogAnalyzer::FileFormat
+  
+  class Merb < Base
 
-  LINE_DEFINITIONS = {
-    
     # ~ Started request handling: Fri Aug 29 11:10:23 +0200 2008
-    :started => {
-      :header   => true,
-      :teaser   => /Started/,
-      :regexp   => /Started request handling\:\ (.+)/,
-      :captures => [{ :name => :timestamp, :type => :timestamp, :anonymize => :slightly }]
-    },
+    line_definition :started do |line|
+      line.header = true
+      line.teaser = /Started/
+      line.regexp = /Started request handling\:\ (.+)/
+      line.captures << { :name => :timestamp, :type => :timestamp, :anonymize => :slightly }
+    end    
     
     # ~ Params: {"action"=>"create", "controller"=>"session"}
     # ~ Params: {"_method"=>"delete", "authenticity_token"=>"[FILTERED]", "action"=>"d}
-    :params => {
-      :teaser   => /Params/,
-      :regexp   => /Params\:\ \{(.+)\}/,
-      :captures => [{ :name => :raw_hash, :type => :string}]
-    },
-    
+    line_definition :params do |line|
+      line.teaser = /Params/
+      line.regexp = /Params\:\ \{(.+)\}/
+      line.captures << { :name => :raw_hash, :type => :string}
+    end
+
     # ~ {:dispatch_time=>0.006117, :after_filters_time=>6.1e-05, :before_filters_time=>0.000712, :action_time=>0.005833}
-    :completed => {
-      :footer   => true,
-      :teaser   => /\{:dispatch_time/,
-      :regexp   => /\{\:dispatch_time=>(\d+\.\d+(?:e-?\d+)?), (?:\:after_filters_time=>(\d+\.\d+(?:e-?\d+)?), )?(?:\:before_filters_time=>(\d+\.\d+(?:e-?\d+)?), )?\:action_time=>(\d+\.\d+(?:e-?\d+)?)\}/,
-      :captures => [{ :name => :dispatch_time,       :type => :sec, :anonymize => :slightly }, 
-                    { :name => :after_filters_time,  :type => :sec, :anonymize => :slightly }, 
-                    { :name => :before_filters_time, :type => :sec, :anonymize => :slightly }, 
-                    { :name => :action_time,         :type => :sec, :anonymize => :slightly }]
-    }
-  }
+    line_definition :completed do |line|
+      line.footer = true
+      line.teaser = /\{:dispatch_time/
+      line.regexp = /\{\:dispatch_time=>(\d+\.\d+(?:e-?\d+)?), (?:\:after_filters_time=>(\d+\.\d+(?:e-?\d+)?), )?(?:\:before_filters_time=>(\d+\.\d+(?:e-?\d+)?), )?\:action_time=>(\d+\.\d+(?:e-?\d+)?)\}/
+      line.captures << { :name => :dispatch_time,       :type => :sec, :anonymize => :slightly } \
+                    << { :name => :after_filters_time,  :type => :sec, :anonymize => :slightly } \
+                    << { :name => :before_filters_time, :type => :sec, :anonymize => :slightly } \
+                    << { :name => :action_time,         :type => :sec, :anonymize => :slightly }
+    end
     
-end
+    
+    report do |analyze|
+      # FIX ME
+    end
+    
+  end
+
+end

data/lib/request_log_analyzer/file_format/rails.rb

@@ -1,90 +1,92 @@
-class RequestLogAnalyzer::FileFormat::Rails < RequestLogAnalyzer::FileFormat
+module RequestLogAnalyzer::FileFormat
   
-  # Processing EmployeeController#index (for 123.123.123.123 at 2008-07-13 06:00:00) [GET]
-  line_definition :processing do |line|
-    line.header = true # this line is the first log line for a request 
-    line.teaser = /Processing /
-    line.regexp = /Processing ((?:\w+::)?\w+)#(\w+)(?: to (\w+))? \(for (\d+\.\d+\.\d+\.\d+) at (\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d)\) \[([A-Z]+)\]/
-    line.captures << { :name => :controller, :type  => :string } \
-                  << { :name => :action,     :type  => :string } \
-                  << { :name => :format,     :type  => :string } \
-                  << { :name => :ip,         :type  => :string, :anonymize => :ip } \
-                  << { :name => :timestamp,  :type  => :timestamp, :anonymize => :slightly } \
-                  << { :name => :method,     :type  => :string }
-  end
+  class Rails < Base
+  
+    # Processing EmployeeController#index (for 123.123.123.123 at 2008-07-13 06:00:00) [GET]
+    line_definition :processing do |line|
+      line.header = true # this line is the first log line for a request 
+      line.teaser = /Processing /
+      line.regexp = /Processing ((?:\w+::)?\w+)#(\w+)(?: to (\w+))? \(for (\d+\.\d+\.\d+\.\d+) at (\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d)\) \[([A-Z]+)\]/
+      line.captures << { :name => :controller, :type  => :string } \
+                    << { :name => :action,     :type  => :string } \
+                    << { :name => :format,     :type  => :string } \
+                    << { :name => :ip,         :type  => :string, :anonymize => :ip } \
+                    << { :name => :timestamp,  :type  => :timestamp, :anonymize => :slightly } \
+                    << { :name => :method,     :type  => :string }
+    end
 
-  # Filter chain halted as [#<ActionController::Caching::Actions::ActionCacheFilter:0x2a999ad620 @check=nil, @options={:store_options=>{}, :layout=>nil, :cache_path=>#<Proc:0x0000002a999b8890@/app/controllers/cached_controller.rb:8>}>] rendered_or_redirected.    
-  line_definition :cache_hit do |line|
-    line.regexp = /Filter chain halted as \[\#<ActionController::Caching::Actions::ActionCacheFilter:.+>\] rendered_or_redirected/
-  end
+    # Filter chain halted as [#<ActionController::Caching::Actions::ActionCacheFilter:0x2a999ad620 @check=nil, @options={:store_options=>{}, :layout=>nil, :cache_path=>#<Proc:0x0000002a999b8890@/app/controllers/cached_controller.rb:8>}>] rendered_or_redirected.    
+    line_definition :cache_hit do |line|
+      line.regexp = /Filter chain halted as \[\#<ActionController::Caching::Actions::ActionCacheFilter:.+>\] rendered_or_redirected/
+    end
   
-  # RuntimeError (Cannot destroy employee):  /app/models/employee.rb:198:in `before_destroy' 
-  line_definition :failed do |line|
-    line.footer = true
-    line.regexp = /((?:[A-Z]\w+\:\:)*[A-Z]\w+) \((.*)\)(?: on line #(\d+) of .+)?\:(.*)/
-    line.captures << { :name => :error,       :type => :string } \
-                  << { :name => :message,     :type => :string } \
-                  << { :name => :line,        :type => :integer } \
-                  << { :name => :file,        :type => :string } \
-                  << { :name => :stack_trace, :type => :string, :anonymize => true }
-  end
+    # RuntimeError (Cannot destroy employee):  /app/models/employee.rb:198:in `before_destroy' 
+    line_definition :failed do |line|
+      line.footer = true
+      line.regexp = /((?:[A-Z]\w+\:\:)*[A-Z]\w+) \((.*)\)(?: on line #(\d+) of .+)?\:(.*)/
+      line.captures << { :name => :error,       :type => :string } \
+                    << { :name => :message,     :type => :string } \
+                    << { :name => :line,        :type => :integer } \
+                    << { :name => :file,        :type => :string } \
+                    << { :name => :stack_trace, :type => :string, :anonymize => true }
+    end
 
 
-  # Rails < 2.1 completed line example
-  # Completed in 0.21665 (4 reqs/sec) | Rendering: 0.00926 (4%) | DB: 0.00000 (0%) | 200 OK [http://demo.nu/employees]
-  RAILS_21_COMPLETED = /Completed in (\d+\.\d{5}) \(\d+ reqs\/sec\) (?:\| Rendering: (\d+\.\d{5}) \(\d+\%\) )?(?:\| DB: (\d+\.\d{5}) \(\d+\%\) )?\| (\d\d\d).+\[(http.+)\]/
+    # Rails < 2.1 completed line example
+    # Completed in 0.21665 (4 reqs/sec) | Rendering: 0.00926 (4%) | DB: 0.00000 (0%) | 200 OK [http://demo.nu/employees]
+    RAILS_21_COMPLETED = /Completed in (\d+\.\d{5}) \(\d+ reqs\/sec\) (?:\| Rendering: (\d+\.\d{5}) \(\d+\%\) )?(?:\| DB: (\d+\.\d{5}) \(\d+\%\) )?\| (\d\d\d).+\[(http.+)\]/
 
-  # Rails > 2.1 completed line example
-  # Completed in 614ms (View: 120, DB: 31) | 200 OK [http://floorplanner.local/demo]  
-  RAILS_22_COMPLETED = /Completed in (\d+)ms \((?:View: (\d+), )?DB: (\d+)\) \| (\d\d\d).+\[(http.+)\]/
+    # Rails > 2.1 completed line example
+    # Completed in 614ms (View: 120, DB: 31) | 200 OK [http://floorplanner.local/demo]  
+    RAILS_22_COMPLETED = /Completed in (\d+)ms \((?:View: (\d+), )?DB: (\d+)\) \| (\d\d\d).+\[(http.+)\]/
 
-  # The completed line uses a kind of hack to ensure that both old style logs and new style logs 
-  # are both parsed by the same regular expression. The format in Rails 2.2 was slightly changed,
-  # but the line contains exactly the same information.
-  line_definition :completed do |line|
+    # The completed line uses a kind of hack to ensure that both old style logs and new style logs 
+    # are both parsed by the same regular expression. The format in Rails 2.2 was slightly changed,
+    # but the line contains exactly the same information.
+    line_definition :completed do |line|
     
-    line.footer = true
-    line.teaser = /Completed in /
-    line.regexp = Regexp.new("(?:#{RAILS_21_COMPLETED}|#{RAILS_22_COMPLETED})")
+      line.footer = true
+      line.teaser = /Completed in /
+      line.regexp = Regexp.new("(?:#{RAILS_21_COMPLETED}|#{RAILS_22_COMPLETED})")
     
-    line.captures << { :name => :duration, :type => :sec,    :anonymize => :slightly } \
-                  << { :name => :view,     :type => :sec,    :anonymize => :slightly } \
-                  << { :name => :db,       :type => :sec,    :anonymize => :slightly } \
-                  << { :name => :status,   :type => :integer } \
-                  << { :name => :url,      :type => :string, :anonymize => :url } # Old variant 
+      line.captures << { :name => :duration, :type => :sec,    :anonymize => :slightly } \
+                    << { :name => :view,     :type => :sec,    :anonymize => :slightly } \
+                    << { :name => :db,       :type => :sec,    :anonymize => :slightly } \
+                    << { :name => :status,   :type => :integer } \
+                    << { :name => :url,      :type => :string, :anonymize => :url } # Old variant 
                   
-    line.captures << { :name => :duration, :type => :msec,   :anonymize => :slightly } \
-                  << { :name => :view,     :type => :msec,   :anonymize => :slightly } \
-                  << { :name => :db,       :type => :msec,   :anonymize => :slightly } \
-                  << { :name => :status,   :type => :integer} \
-                  << { :name => :url,      :type => :string, :anonymize => :url }  # 2.2 variant 
-  end
+      line.captures << { :name => :duration, :type => :msec,   :anonymize => :slightly } \
+                    << { :name => :view,     :type => :msec,   :anonymize => :slightly } \
+                    << { :name => :db,       :type => :msec,   :anonymize => :slightly } \
+                    << { :name => :status,   :type => :integer} \
+                    << { :name => :url,      :type => :string, :anonymize => :url }  # 2.2 variant 
+    end
 
 
 
-  REQUEST_CATEGORIZER = Proc.new do |request|
-    format = request[:format] || 'html'
-    "#{request[:controller]}##{request[:action]}.#{format} [#{request[:method]}]"
-  end
+    REQUEST_CATEGORIZER = Proc.new do |request|
+      format = request[:format] || 'html'
+      "#{request[:controller]}##{request[:action]}.#{format} [#{request[:method]}]"
+    end
 
-  report do |analyze|
-    analyze.timespan :line_type => :processing
-    analyze.category :category => REQUEST_CATEGORIZER, :title => 'Top 20 hits', :amount => 20, :line_type => :processing
-    analyze.category :method, :title => 'HTTP methods'
-    analyze.category :status, :title => 'HTTP statuses returned'
-    analyze.category :category => lambda { |request| request =~ :cache_hit ? 'Cache hit' : 'No hit' }, :title => 'Rails action cache hits'
+    report do |analyze|
+      analyze.timespan :line_type => :processing
+      analyze.category :category => REQUEST_CATEGORIZER, :title => 'Top 20 hits', :amount => 20, :line_type => :processing
+      analyze.category :method, :title => 'HTTP methods'
+      analyze.category :status, :title => 'HTTP statuses returned'
+      analyze.category :category => lambda { |request| request =~ :cache_hit ? 'Cache hit' : 'No hit' }, :title => 'Rails action cache hits'
     
-    analyze.duration :duration, :category => REQUEST_CATEGORIZER, :title => "Request duration",    :line_type => :completed
-    analyze.duration :view,     :category => REQUEST_CATEGORIZER, :title => "Database time",       :line_type => :completed
-    analyze.duration :db,       :category => REQUEST_CATEGORIZER, :title => "View rendering time", :line_type => :completed
+      analyze.duration :duration, :category => REQUEST_CATEGORIZER, :title => "Request duration",    :line_type => :completed
+      analyze.duration :view,     :category => REQUEST_CATEGORIZER, :title => "Database time",       :line_type => :completed
+      analyze.duration :db,       :category => REQUEST_CATEGORIZER, :title => "View rendering time", :line_type => :completed
     
-    analyze.category :category => REQUEST_CATEGORIZER, :title => 'Process blockers (> 1 sec duration)', 
-            :if => lambda { |request| request[:duration] && request[:duration] > 1.0 }, :amount => 20
+      analyze.category :category => REQUEST_CATEGORIZER, :title => 'Process blockers (> 1 sec duration)', 
+              :if => lambda { |request| request[:duration] && request[:duration] > 1.0 }, :amount => 20
             
-    analyze.hourly_spread :line_type => :processing
-    analyze.category :error, :title => 'Failed requests', :line_type => :failed, :amount => 20
-  end
-
+      analyze.hourly_spread :line_type => :processing
+      analyze.category :error, :title => 'Failed requests', :line_type => :failed, :amount => 20
+    end
 
+  end
 
-end 
+end