summarizer.rb in request-log-analyzer-1.4.0

- old
+ new

@@ -1,11 +1,11 @@
 module RequestLogAnalyzer::Aggregator
 
   class Summarizer < Base
-    
+
     class Definer
-      
+
       attr_reader :trackers
 
       # Initialize tracker array
       def initialize
         @trackers = []
@@ -14,103 +14,103 @@
       # Initialize tracker summarizer by duping the trackers of another summarizer
       # <tt>other</tt> The other Summarizer
       def initialize_copy(other)
         @trackers = other.trackers.dup
       end
-      
+
       # Drop all trackers
       def reset!
         @trackers = []
       end
-      
+
       # Include missing trackers through method missing.
       def method_missing(tracker_method, *args)
         track(tracker_method, *args)
       end
-      
+
       # Track the frequency of a specific category
       # <tt>category_field</tt> Field to track
       # <tt>options</tt> options are passed to new frequency tracker
       def frequency(category_field, options = {})
         if category_field.kind_of?(Symbol)
           track(:frequency, options.merge(:category => category_field))
         elsif category_field.kind_of?(Hash)
           track(:frequency, category_field.merge(options))
         end
       end
-      
+
       # Track the duration of a specific category
       # <tt>duration_field</tt> Field to track
       # <tt>options</tt> options are passed to new frequency tracker
       def duration(duration_field, options = {})
         if duration_field.kind_of?(Symbol)
           track(:duration, options.merge(:duration => duration_field))
         elsif duration_field.kind_of?(Hash)
-          track(:duration, duration_field.merge(options))        
+          track(:duration, duration_field.merge(options))
         end
-      end      
-      
+      end
+
       # Helper function to initialize a tracker and add it to the tracker array.
       # <tt>tracker_class</tt> The class to include
       # <tt>optiont</tt> The options to pass to the trackers.
       def track(tracker_klass, options = {})
         tracker_klass = RequestLogAnalyzer::Tracker.const_get(RequestLogAnalyzer::to_camelcase(tracker_klass)) if tracker_klass.kind_of?(Symbol)
         @trackers << tracker_klass.new(options)
       end
     end
-    
+
     attr_reader :trackers
     attr_reader :warnings_encountered
-    
+
     # Initialize summarizer.
     # Generate trackers from speciefied source.file_format.report_trackers and set them up
     def initialize(source, options = {})
       super(source, options)
       @warnings_encountered = {}
       @trackers = source.file_format.report_trackers
       setup
     end
-    
+
     def setup
     end
-    
+
     # Call prepare on all trackers.
     def prepare
       raise "No trackers set up in Summarizer!" if @trackers.nil? || @trackers.empty?
       @trackers.each { |tracker| tracker.prepare }
     end
-    
+
     # Pass all requests to trackers and let them update if necessary.
     # <tt>request</tt> The request to pass.
     def aggregate(request)
       @trackers.each do |tracker|
         tracker.update(request) if tracker.should_update?(request)
       end
     end
-    
+
     # Call finalize on all trackers. Saves a YAML dump if this is set in  the options.
     def finalize
       @trackers.each { |tracker| tracker.finalize }
       save_results_dump(options[:dump]) if options[:dump]
     end
-    
+
     # Saves the results of all the trackers in YAML format to a file.
     # <tt>filename</tt> The file to store the YAML dump in.
     def save_results_dump(filename)
       File.open(filename, 'w') { |file| file.write(to_yaml) }
     end
-    
+
     # Exports all the tracker results to YAML. It will call the to_yaml_object method
     # for every tracker and combines these into a single YAML export.
     def to_yaml
       require 'yaml'
       trackers_export = @trackers.inject({}) do |export, tracker|
         export[tracker.title] = tracker.to_yaml_object; export
       end
       YAML::dump(trackers_export)
     end
-       
+
     # Call report on all trackers.
     # <tt>output</tt> RequestLogAnalyzer::Output object to output to
     def report(output)
       report_header(output)
       if source.parsed_requests > 0
@@ -119,51 +119,51 @@
         output.puts
         output.puts('There were no requests analyzed.')
       end
       report_footer(output)
     end
-    
+
     # Generate report header.
     # <tt>output</tt> RequestLogAnalyzer::Output object to output to
     def report_header(output)
       output.title("Request summary")
-  
-      output.with_style(:cell_separator => false) do 
+
+      output.with_style(:cell_separator => false) do
         output.table({:width => 20}, {:font => :bold}) do |rows|
           rows << ['Parsed lines:',    source.parsed_lines]
           rows << ['Skipped lines:',   source.skipped_lines]
           rows << ['Parsed requests:', source.parsed_requests]
           rows << ['Skipped requests:', source.skipped_requests]
           rows << ["Warnings:", @warnings_encountered.map { |(key, value)| "#{key}: #{value}" }.join(', ')] if has_warnings?
         end
       end
       output << "\n"
     end
-    
+
     # Generate report footer.
     # <tt>output</tt> RequestLogAnalyzer::Output object to output to
     def report_footer(output)
       if has_log_ordering_warnings?
         output.title("Parse warnings")
-        
+
         output.puts "Parseable lines were ancountered without a header line before it. It"
         output.puts "could be that logging is not setup correctly for your application."
         output.puts "Visit this website for logging configuration tips:"
         output.puts output.link("http://github.com/wvanbergen/request-log-analyzer/wikis/configure-logging")
         output.puts
       end
     end
-    
+
     # Returns true if there were any warnings generated by the trackers
     def has_warnings?
       @warnings_encountered.inject(0) { |result, (key, value)| result += value } > 0
     end
-    
+
     # Returns true if there were any log ordering warnings
     def has_log_ordering_warnings?
       @warnings_encountered[:no_current_request] && @warnings_encountered[:no_current_request] > 0
     end
-    
+
     # Store an encountered warning
     # <tt>type</tt> Type of warning
     # <tt>message</tt> Warning message
     # <tt>lineno</tt> The line on which the error was encountered
     def warning(type, message, lineno)