request-log-analyzer 1.0.2 → 1.6.3

data/lib/request_log_analyzer/aggregator/summarizer.rb

@@ -1,113 +1,151 @@
-require File.dirname(__FILE__) + '/../tracker/base'
-
 module RequestLogAnalyzer::Aggregator
 
   class Summarizer < Base
-    
+
     class Definer
-      
+
       attr_reader :trackers
-      
+
+      # Initialize tracker array
       def initialize
         @trackers = []
       end
-      
-      def method_missing(tracker_method, *args)
-        track(tracker_method, args.first)
+
+      # 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
-      
-      def category(category_field, options = {})
-        if category_field.kind_of?(Symbol)
-          track(:category, options.merge(:category => category_field))
-        elsif category_field.kind_of?(Hash)
-          track(:category, category_field.merge(options))
-        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
       
-      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))        
-        end
-      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)
+      # 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, value_field = {}, other_options = {})
+        options = value_field.kind_of?(Symbol) ? other_options.merge(:value => value_field) : value_field.merge(other_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
-    
+    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[:yaml]) if options[:yaml]
+    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
-       
-    def report(output=STDOUT, report_width = 80, color = false)
-      report_header(output, report_width, color)
+
+    # 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
-        @trackers.each { |tracker| tracker.report(output, report_width, color) }
+        @trackers.each { |tracker| output.report_tracker(tracker) }
       else
-        output << "\n"
-        output << "There were no requests analyzed.\n"
+        output.puts
+        output.puts('There were no requests analyzed.')
       end
-      report_footer(output, report_width, color)
+      report_footer(output)
     end
-    
-    def report_header(output=STDOUT, report_width = 80, color = false)
-      output << "Request summary\n"
-      output << green("━" * report_width, color) + "\n"
-      output << "Parsed lines:         #{green(source.parsed_lines, color)}\n"
-      output << "Parsed requests:      #{green(source.parsed_requests, color)}\n"
-      output << "Skipped lines:        #{green(source.skipped_lines, color)}\n" if source.skipped_lines > 0
-      if has_warnings?
-        output <<  "Warnings:             " + @warnings_encountered.map { |(key, value)| "#{key.inspect}: #{blue(value, color)}" }.join(', ') + "\n"
+
+    # 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.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
-    
-    def report_footer(output=STDOUT, report_width = 80, color = false)
-      output << "\n" 
-      if has_serious_warnings?      
-        output << green("━" * report_width, color) + "\n"
-        output << "Multiple warnings were encountered during parsing. Possibly, your logging " + "\n"
-        output << "is not setup correctly. Visit this website for logging configuration tips:" + "\n"
-        output <<  blue("http://github.com/wvanbergen/request-log-analyzer/wikis/configure-logging", color) + "\n"
+
+    # 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 "Parsable lines were encountered 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
+      @warnings_encountered.inject(0) { |result, (key, value)| result += value } > 0
     end
-    
-    def has_serious_warnings?
-      @warnings_encountered.inject(0) { |result, (key, value)| result += value } > 10
+
+    # 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)
       @warnings_encountered[type] ||= 0
       @warnings_encountered[type] += 1

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

@@ -1,44 +1,48 @@
 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
-    
-    include RequestLogAnalyzer::FileFormat::Awareness
-    
-    attr_reader :options
-    attr_reader :source
+
+    attr_reader :options, :source
 
     # Intializes a new RequestLogAnalyzer::Aggregator::Base instance
     # It will include the specific file format module.
     def initialize(source, options = {})
       @source = source
-      self.register_file_format(source.file_format)
       @options = options
     end
 
-    # The prepare function is called just before parsing starts. This function 
+    # The prepare function is called just before parsing starts. This function
     # can be used to initialie variables, etc.
     def prepare
     end
-    
+
     # The aggregate function is called for every request.
     # Implement the aggregating functionality in this method
     def aggregate(request)
     end
-    
+
     # The finalize function is called after all sources are parsed and no more
     # requests will be passed to the aggregator
     def finalize
     end
-    
+
     # The warning method is called if the parser eits a warning.
     def warning(type, message, lineno)
-    end    
-    
+    end
+
     # The report function is called at the end. Implement any result reporting
     # in this function.
-    def report(output = STDOUT, report_width = 80, color = false)
+    def report(output)
+    end
+
+    # The source_change function gets called when handling a source is started or finished.
+    def source_change(change, filename)
     end
 
   end