request-log-analyzer 1.2.0 → 1.2.1

data/lib/request_log_analyzer/source/log_parser.rb

@@ -67,18 +67,41 @@ module RequestLogAnalyzer::Source
     def parse_files(files, options = {}, &block) # :yields: request
       files.each { |file| parse_file(file, options, &block) }
     end
+    
+    # Check if a file has a compressed extention in the filename.
+    # If recognized, return the command string used to decompress the file
+    def decompress_file?(filename)
+      nice_command = "nice -n 5"
+      
+      return "#{nice_command} gunzip -c -d #{filename}" if filename.match(/\.tar.gz$/) || filename.match(/\.tgz$/) || filename.match(/\.gz$/)
+      return "#{nice_command} bunzip2 -c -d #{filename}" if filename.match(/\.bz2$/)
+      return "#{nice_command} unzip -p #{filename}" if filename.match(/\.zip$/)
+
+      return ""
+    end
 
     # Parses a log file. Creates an IO stream for the provided file, and sends it to parse_io for
     # further handling. This method supports progress updates that can be used to display a progressbar
+    #
+    # If the logfile is compressed, it is uncompressed to stdout and read.
+    # TODO: Check if IO.popen encounters problems with the given command line.
+    # TODO: Fix progress bar that is broken for IO.popen, as it returns a single string.
+    #
     # <tt>file</tt>:: The file that should be parsed.
     # <tt>options</tt>:: A Hash of options that will be pased to parse_io.    
     def parse_file(file, options = {}, &block)
+
       @progress_handler.call(:started, file) if @progress_handler
-      File.open(file, 'r') { |f| parse_io(f, options, &block) }
+      
+      if decompress_file?(file).empty?
+        File.open(file, 'r') { |f| parse_io(f, options, &block) }
+      else
+        IO.popen(decompress_file?(file), 'r') { |f| parse_io(f, options, &block) }
+      end
+
       @progress_handler.call(:finished, file) if @progress_handler
     end
 
-
     # Parses an IO stream. It will simply call parse_io. This function does not support progress updates
     # because the length of a stream is not known.
     # <tt>stream</tt>:: The IO stream that should be parsed.
@@ -103,7 +126,7 @@ module RequestLogAnalyzer::Source
 
       @current_io = io
       @current_io.each_line do |line|
-
+        
         @progress_handler.call(:progress, @current_io.pos) if @progress_handler && @current_io.kind_of?(File)
 
         request_data = nil

data/lib/request_log_analyzer/tracker/duration.rb

@@ -2,13 +2,14 @@ module RequestLogAnalyzer::Tracker
 
   # Analyze the duration of a specific attribute
   #
-  # Options:
-  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
-  # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
-  # * <tt>:title</tt> Title do be displayed above the report  
+  # === Options
+  # * <tt>:amount</tt> The amount of lines in the report
   # * <tt>:category</tt> Proc that handles request categorization for given fileformat (REQUEST_CATEGORIZER)
   # * <tt>:duration</tt> The field containing the duration in the request hash.
-  # * <tt>:amount</tt> The amount of lines in the report
+  # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
+  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
+  # * <tt>:title</tt> Title do be displayed above the report  
+  # * <tt>:unless</tt> Handle request if this proc is false for the handled request.
   #
   # The items in the update request hash are set during the creation of the Duration tracker.
   #
@@ -23,6 +24,7 @@ module RequestLogAnalyzer::Tracker
     
     attr_reader :categories
 
+    # Check if duration and catagory option have been received,
     def prepare
       raise "No duration field set up for category tracker #{self.inspect}" unless options[:duration]
       raise "No categorizer set up for duration tracker #{self.inspect}" unless options[:category]
@@ -30,6 +32,8 @@ module RequestLogAnalyzer::Tracker
       @categories = {}
     end
 
+    # Get the duration information fron the request and store it in the different categories.
+    # <tt>request</tt> The request.
     def update(request)
       if options[:multiple]
         categories = request.every(options[:category])
@@ -58,50 +62,68 @@ module RequestLogAnalyzer::Tracker
       end
     end
     
+    # Get the number of hits of a specific category.
+    # <tt>cat</tt> The category
     def hits(cat)
       categories[cat][:hits]
     end
     
+    # Get the total duration of a specific category.
+    # <tt>cat</tt> The category
     def cumulative_duration(cat)
       categories[cat][:cumulative]
     end
 
+    # Get the minimal duration of a specific category.
+    # <tt>cat</tt> The category
     def min_duration(cat)
       categories[cat][:min]
     end
 
+    # Get the maximum duration of a specific category.
+    # <tt>cat</tt> The category
     def max_duration(cat)
       categories[cat][:max]
     end
 
+    # Get the average duration of a specific category.
+    # <tt>cat</tt> The category
     def average_duration(cat)
       categories[cat][:cumulative] / categories[cat][:hits]  
     end
     
+    # Get the average duration of a all categories.
     def overall_average_duration
       overall_cumulative_duration / overall_hits
     end
     
+    # Get the cumlative duration of a all categories.
     def overall_cumulative_duration
       categories.inject(0.0) { |sum, (name, cat)| sum + cat[:cumulative] }  
     end
     
+    # Get the total hits of a all categories.
     def overall_hits
       categories.inject(0) { |sum, (name, cat)| sum + cat[:hits] }
     end
 
+    # Return categories sorted by hits.
     def sorted_by_hits
       sorted_by(:hits)
     end
 
+    # Return categories sorted by cumulative duration.
     def sorted_by_cumulative
       sorted_by(:cumulative)
     end
 
+    # Return categories sorted by cumulative duration.
     def sorted_by_average
       sorted_by { |cat| cat[:cumulative] / cat[:hits] }
     end
           
+    # Return categories sorted by a given key.
+    # <tt>by</tt> The key.
     def sorted_by(by = nil) 
       if block_given?
         categories.sort { |a, b| yield(b[1]) <=> yield(a[1]) } 
@@ -110,7 +132,12 @@ module RequestLogAnalyzer::Tracker
       end
     end
     
-    # Builds a result table using a provided sorting function 
+    # Block function to build a result table using a provided sorting function.
+    # <tt>output</tt> The output object.
+    # <tt>amount</tt> The number of rows in the report table (default 10).
+    # === Options
+    #  * </tt>:title</tt> The title of the table
+    #  * </tt>:sort</tt> The key to sort on (:hits, :cumulative, :average, :min or :max)
     def report_table(output, amount = 10, options = {}, &block)
     
       output.title(options[:title])
@@ -128,9 +155,12 @@ module RequestLogAnalyzer::Tracker
                     "%0.02fs" % info[:min], "%0.02fs" % info[:max]]
         end        
       end
-
     end
 
+    # Generate a request duration report to the given output object
+    # By default colulative and average duration are generated.
+    # Any options for the report should have been set during initialize.
+    # <tt>output</tt> The output object
     def report(output)
 
       options[:title]  ||= 'Request duration'
@@ -149,6 +179,17 @@ module RequestLogAnalyzer::Tracker
           raise "Unknown duration report specified: #{report}!"
         end
       end
-    end      
+    end
+    
+    # Returns the title of this tracker for reports
+    def title
+      options[:title]  || 'Request duration'
+    end
+    
+    # Returns all the categories and the tracked duration as a hash than can be exported to YAML
+    def to_yaml_object
+      return nil if @categories.empty?      
+      @categories
+    end
   end
 end

data/lib/request_log_analyzer/tracker/frequency.rb

@@ -3,26 +3,29 @@ module RequestLogAnalyzer::Tracker
   # Catagorize requests by frequency.
   # Count and analyze requests for a specific attribute 
   #
-  # Accepts the following options:
-  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
+  # === Options
+  # * <tt>:amount</tt> The amount of lines in the report
+  # * <tt>:category</tt> Proc that handles the request categorization.
   # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
+  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
+  # * <tt>:nils</tt> Track undetermined methods.
   # * <tt>:title</tt> Title do be displayed above the report.
-  # * <tt>:category</tt> Proc that handles the request categorization.
-  # * <tt>:amount</tt> The amount of lines in the report
+  # * <tt>:unless</tt> Proc that has to return nil for a request to be passed to the tracker.
   #
   # The items in the update request hash are set during the creation of the Duration tracker.
   #
   # Example output:
   #  HTTP methods
   #  ----------------------------------------------------------------------
-  #  GET    |  22248 hits (46.2%) |░░░░░░░░░░░░░░░░░
-  #  PUT    |  13685 hits (28.4%) |░░░░░░░░░░░
-  #  POST   |  11662 hits (24.2%) |░░░░░░░░░
+  #  GET    |  22248 hits (46.2%) |=================
+  #  PUT    |  13685 hits (28.4%) |===========
+  #  POST   |  11662 hits (24.2%) |=========
   #  DELETE |    512 hits (1.1%)  |
   class Frequency < Base
 
     attr_reader :frequencies
 
+    # Check if categories are set up
     def prepare
       raise "No categorizer set up for category tracker #{self.inspect}" unless options[:category]
       @frequencies = {}
@@ -31,6 +34,8 @@ module RequestLogAnalyzer::Tracker
       end
     end
             
+    # Check HTTP method of a request and store that in the frequencies hash.
+    # <tt>request</tt> The request.
     def update(request)
       cat = options[:category].respond_to?(:call) ? options[:category].call(request) : request[options[:category]]
       if !cat.nil? || options[:nils]
@@ -39,18 +44,25 @@ module RequestLogAnalyzer::Tracker
       end
     end
 
+    # Return the amount of times a HTTP method has been encountered
+    # <tt>cat</tt> The HTTP method (:get, :put, :post or :delete)
     def frequency(cat)
       frequencies[cat] || 0
     end
     
+    # Return the overall frequency
     def overall_frequency
       frequencies.inject(0) { |carry, item| carry + item[1] }
     end
     
+    # Return the methods sorted by frequency
     def sorted_by_frequency
       @frequencies.sort { |a, b| b[1] <=> a[1] }
     end
 
+    # Generate a HTTP method frequency report to the given output object.
+    # Any options for the report should have been set during initialize.
+    # <tt>output</tt> The output object
     def report(output)
       output.title(options[:title]) if options[:title]
     
@@ -69,5 +81,16 @@ module RequestLogAnalyzer::Tracker
 
       end
     end
+    
+    # Returns a hash with the frequencies of every category that can be exported to YAML
+    def to_yaml_object
+      return nil if @frequencies.empty?
+      @frequencies
+    end
+    
+    # Returns the title of this tracker for reports
+    def title
+      options[:title] || 'Request frequency'
+    end
   end
 end

data/lib/request_log_analyzer/tracker/hourly_spread.rb

@@ -4,8 +4,10 @@ module RequestLogAnalyzer::Tracker
   # This spread is shown in a graph form.
   #
   # Accepts the following options:
-  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
   # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
+  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
+  # * <tt>:output</tt> Direct output here (defaults to STDOUT)
+  # * <tt>:unless</tt> Proc that has to return nil for a request to be passed to the tracker.
   #
   # Expects the following items in the update request hash
   # * <tt>:timestamp</tt> in YYYYMMDDHHMMSS format.
@@ -13,28 +15,31 @@ module RequestLogAnalyzer::Tracker
   # Example output:
   #  Requests graph - average per day per hour
   #  --------------------------------------------------
-  #    7:00 - 330 hits        : ░░░░░░░
-  #    8:00 - 704 hits        : ░░░░░░░░░░░░░░░░░
-  #    9:00 - 830 hits        : ░░░░░░░░░░░░░░░░░░░░
-  #   10:00 - 822 hits        : ░░░░░░░░░░░░░░░░░░░
-  #   11:00 - 823 hits        : ░░░░░░░░░░░░░░░░░░░
-  #   12:00 - 729 hits        : ░░░░░░░░░░░░░░░░░
-  #   13:00 - 614 hits        : ░░░░░░░░░░░░░░
-  #   14:00 - 690 hits        : ░░░░░░░░░░░░░░░░
-  #   15:00 - 492 hits        : ░░░░░░░░░░░
-  #   16:00 - 355 hits        : ░░░░░░░░
-  #   17:00 - 213 hits        : ░░░░░
-  #   18:00 - 107 hits        : ░░
+  #    7:00 - 330 hits        : =======
+  #    8:00 - 704 hits        : =================
+  #    9:00 - 830 hits        : ====================
+  #   10:00 - 822 hits        : ===================
+  #   11:00 - 823 hits        : ===================
+  #   12:00 - 729 hits        : =================
+  #   13:00 - 614 hits        : ==============
+  #   14:00 - 690 hits        : ================
+  #   15:00 - 492 hits        : ===========
+  #   16:00 - 355 hits        : ========
+  #   17:00 - 213 hits        : =====
+  #   18:00 - 107 hits        : ==
   #   ................
   class HourlySpread < Base
 
     attr_reader :first, :last, :request_time_graph
 
+    # Check if timestamp field is set in the options and prepare the result time graph.
     def prepare
       options[:field] ||= :timestamp
       @request_time_graph = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
     end
-            
+
+    # Check if the timestamp in the request and store it.
+    # <tt>request</tt> The request.
     def update(request)
       request = request.attributes
       timestamp = request[options[:field]]
@@ -44,24 +49,31 @@ module RequestLogAnalyzer::Tracker
       @last  = timestamp if @last.nil?  || timestamp > @last
     end
 
+    # Total amount of requests tracked
     def total_requests
       @request_time_graph.inject(0) { |sum, value| sum + value }
     end
     
+    # First timestamp encountered
     def first_timestamp
       DateTime.parse(@first.to_s, '%Y%m%d%H%M%S') rescue nil
     end
     
+    # Last timestamp encountered
     def last_timestamp
       DateTime.parse(@last.to_s, '%Y%m%d%H%M%S') rescue nil
     end
     
+    # Difference between last and first timestamp.
     def timespan
       last_timestamp - first_timestamp
     end
 
+    # Generate an hourly spread report to the given output object.
+    # Any options for the report should have been set during initialize.
+    # <tt>output</tt> The output object
     def report(output)
-      output.title("Requests graph - average per day per hour")
+      output.title(title)
     
       if total_requests == 0
         output << "None found.\n"
@@ -77,5 +89,19 @@ module RequestLogAnalyzer::Tracker
         end
       end
     end
+    
+    # Returns the title of this tracker for reports
+    def title
+      options[:title] || "Request distribution per hour"
+    end
+    
+    # Returns the found frequencies per hour as a hash for YAML exporting
+    def to_yaml_object
+      yaml_object = {}
+      @request_time_graph.each_with_index do |freq, hour|
+        yaml_object["#{hour}:00 - #{hour+1}:00"] = freq
+      end
+      yaml_object
+    end
   end
 end

data/lib/request_log_analyzer/tracker/timespan.rb

@@ -4,10 +4,11 @@ module RequestLogAnalyzer::Tracker
   # Also determines the amount of days inbetween these.
   #
   # Accepts the following options:
-  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
-  # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
   # * <tt>:field</tt> The timestamp field that is looked at. Defaults to :timestamp.
+  # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
+  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
   # * <tt>:title</tt> Title do be displayed above the report.
+  # * <tt>:unless</tt> Proc that has to return nil for a request to be passed to the tracker.
   #
   # Expects the following items in the update request hash
   # * <tt>:timestamp</tt> in YYYYMMDDHHMMSS format.
@@ -20,10 +21,13 @@ module RequestLogAnalyzer::Tracker
 
     attr_reader :first, :last, :request_time_graph
 
+    # Check if timestamp field is set in the options.
     def prepare
       options[:field] ||= :timestamp
     end
             
+    # Check if the timestamp in the request and store it.
+    # <tt>request</tt> The request.
     def update(request)
       timestamp = request[options[:field]]
 
@@ -31,18 +35,24 @@ module RequestLogAnalyzer::Tracker
       @last  = timestamp if @last.nil?  || timestamp > @last
     end
 
+    # First timestamp encountered
     def first_timestamp
       DateTime.parse(@first.to_s, '%Y%m%d%H%M%S') rescue nil
     end
     
+    # Last timestamp encountered
     def last_timestamp
       DateTime.parse(@last.to_s, '%Y%m%d%H%M%S') rescue nil      
     end
     
+    # Difference between last and first timestamp.
     def timespan
       last_timestamp - first_timestamp
     end
 
+    # Generate an hourly spread report to the given output object.
+    # Any options for the report should have been set during initialize.
+    # <tt>output</tt> The output object
     def report(output)
       output.title(options[:title]) if options[:title]
     
@@ -55,7 +65,17 @@ module RequestLogAnalyzer::Tracker
           end
         end
       end
+    end
+    
+    # Returns the title of this tracker for reports
+    def title
+      options[:title] || 'Request timespan'
+    end
     
+    # A hash that can be exported to YAML with the first and last timestamp encountered.
+    def to_yaml_object
+      { :first => first_timestamp, :last  =>last_timestamp }
     end
+    
   end
 end

data/lib/request_log_analyzer/tracker.rb

@@ -9,28 +9,51 @@ module RequestLogAnalyzer::Tracker
   # Base Tracker class. All other trackers inherit from this class
   #
   # Accepts the following options:
-  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
   # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
+  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
   # * <tt>:output</tt> Direct output here (defaults to STDOUT)
+  # * <tt>:unless</tt> Proc that has to return nil for a request to be passed to the tracker.
   #
   # For example :if => lambda { |request| request[:duration] && request[:duration] > 1.0 }
   class Base
     
     attr_reader :options
     
+    # Initialize the class
+    # Note that the options are only applicable if should_update? is not overwritten
+    # by the inheriting class.
+    # 
+    # === Options
+    # * <tt>:if</tt> Handle request if this proc is true for the handled request.
+    # * <tt>:unless</tt> Handle request if this proc is false for the handled request.
+    # * <tt>:line_type</tt> Line type this tracker will accept.
     def initialize(options ={})
       @options = options
     end
     
+    # Hook things that need to be done before running here.
     def prepare
     end
     
+    # Will be called with each request.
+    # <tt>request</tt> The request to track data in.
     def update(request)
     end
     
+    # Hook things that need to be done after running here.
     def finalize
     end
     
+    # Determine if we should run the update function at all.
+    # Usually the update function will be heavy, so a light check is done here
+    # determining if we need to call update at all.
+    #
+    # Default this checks if defined: 
+    #  * :line_type is also in the request hash.
+    #  * :if is true for this request.
+    #  * :unless if false for this request
+    #
+    # <tt>request</tt> The request object.
     def should_update?(request)
       return false if options[:line_type] && !request.has_line_type?(options[:line_type])
       
@@ -49,10 +72,24 @@ module RequestLogAnalyzer::Tracker
       return true
     end
     
+    # Hook report generation here.
+    # Defaults to self.inspect
+    # <tt>output</tt> The output object the report will be passed to.
     def report(output)
       output << self.inspect
       output << "\n"  
     end
+    
+    # The title of this tracker. Used for reporting.
+    def title
+      self.class.to_s
+    end
+    
+    # This method is called by RequestLogAnalyzer::Aggregator:Summarizer to retrieve an
+    # object with all the results of this tracker, that can be dumped to YAML format.
+    def to_yaml_object
+      nil
+    end
          
   end 
 end

data/lib/request_log_analyzer.rb

@@ -1,9 +1,7 @@
 require 'date'
 
 # Satisfy ruby 1.9 sensitivity about encoding.
-if defined? Encoding and Encoding.respond_to? 'default_external='
-  Encoding.default_external = 'binary'
-end
+Encoding.default_external = 'binary' if defined? Encoding and Encoding.respond_to? 'default_external='
 
 # RequestLogAnalyzer is the base namespace in which all functionality of RequestLogAnalyzer is implemented.
 #
@@ -13,7 +11,7 @@ module RequestLogAnalyzer
   
   # The current version of request-log-analyzer.
   # This will be diplayed in output reports etc.  
-  VERSION = '1.1.7'
+  VERSION = '1.2.1'
   
   # Loads constants in the RequestLogAnalyzer namespace using self.load_default_class_file(base, const)
   # <tt>const</tt>:: The constant that is not yet loaded in the RequestLogAnalyzer namespace. This should be passed as a string or symbol.

data/spec/fixtures/decompression.log

@@ -0,0 +1,12 @@
+Processing PageController#demo (for 127.0.0.1 at 2008-12-10 16:28:09) [GET]
+  Parameters: {"action"=>"demo", "controller"=>"page"}
+Logging in from session data...
+Logged in as test@example.com
+Using locale: en-US, http-accept: ["en-US"], session: , det browser: en-US, det domain: 
+Rendering template within layouts/demo
+Rendering page/demo
+Rendered shared/_analytics (0.2ms)
+Rendered layouts/_actions (0.6ms)
+Rendered layouts/_menu (2.2ms)
+Rendered layouts/_tabbar (0.5ms)
+Completed in 614ms (View: 120, DB: 31) | 200 OK [http://www.example.coml/demo]

data/spec/integration/command_line_usage_spec.rb

@@ -3,19 +3,13 @@ require File.dirname(__FILE__) + '/../spec_helper.rb'
 describe RequestLogAnalyzer, 'running from command line' do
   
   include RequestLogAnalyzer::Spec::Helper
-  
-  TEMPORARY_DIRECTORY = "#{File.dirname(__FILE__)}/../fixtures"
-  TEMP_DATABASE_FILE  = TEMPORARY_DIRECTORY + "/output.db"
-  TEMP_REPORT_FILE    = TEMPORARY_DIRECTORY + "/report"
 
   before(:each) do
-    File.unlink(TEMP_DATABASE_FILE) if File.exist?(TEMP_DATABASE_FILE)
-    File.unlink(TEMP_REPORT_FILE) if File.exist?(TEMP_REPORT_FILE)    
+    cleanup_temp_files!
   end
 
   after(:each) do
-    File.unlink(TEMP_DATABASE_FILE) if File.exist?(TEMP_DATABASE_FILE)
-    File.unlink(TEMP_REPORT_FILE) if File.exist?(TEMP_REPORT_FILE)    
+    cleanup_temp_files!
   end
 
   it "should find 4 requests in default mode" do  
@@ -34,13 +28,13 @@ describe RequestLogAnalyzer, 'running from command line' do
   end
   
   it "should write output to a file with the --file option" do  
-    run("#{log_fixture(:rails_1x)} --file #{TEMP_REPORT_FILE}")
-    File.exist?(TEMP_REPORT_FILE).should be_true
+    run("#{log_fixture(:rails_1x)} --file #{temp_output_file(:report)}")
+    File.exist?(temp_output_file(:report)).should be_true
   end
 
   it "should write only ASCII characters to a file with the --file option" do  
-    run("#{log_fixture(:rails_1x)} --file #{TEMP_REPORT_FILE}")
-    /^[\x00-\x7F]*$/.match(File.read(TEMP_REPORT_FILE)).should_not be_nil
+    run("#{log_fixture(:rails_1x)} --file #{temp_output_file(:report)}")
+    /^[\x00-\x7F]*$/.match(File.read(temp_output_file(:report))).should_not be_nil
   end
 
   it "should write HTML if --output HTML is provided" do
@@ -49,8 +43,8 @@ describe RequestLogAnalyzer, 'running from command line' do
   end
   
   it "should run with the --database option" do  
-    run("#{log_fixture(:rails_1x)} --database #{TEMP_DATABASE_FILE}")
-    File.exist?(TEMP_DATABASE_FILE).should be_true
+    run("#{log_fixture(:rails_1x)} --database #{temp_output_file(:database)}")
+    File.exist?(temp_output_file(:database)).should be_true
   end
 
   it "should use no colors in the report with the --boring option" do  
@@ -68,4 +62,10 @@ describe RequestLogAnalyzer, 'running from command line' do
     output.detect { |line| /Parsed requests\:\s*11/ =~ line }.should_not be_nil   
   end  
   
+  it "should dump the results to a YAML file" do
+    run("#{log_fixture(:rails_1x)} --dump #{temp_output_file(:dump)}")
+    File.exist?(temp_output_file(:dump)).should be_true
+    YAML::load(File.read(temp_output_file(:dump))).should have_at_least(1).item
+  end
+  
 end