request-log-analyzer 1.10.0 → 1.11.0

data/spec/unit/file_format/rails_format_spec.rb

@@ -5,186 +5,170 @@ describe RequestLogAnalyzer::FileFormat::Rails do
   describe '.create' do
 
     context 'without providing a lines argument' do
-      before(:each) { @rails = RequestLogAnalyzer::FileFormat.load(:rails) }
+      subject { RequestLogAnalyzer::FileFormat::Rails.create } 
 
-      it "should create a valid file format" do
-        @rails.should be_valid
-      end
+      it { should be_well_formed }
+      it { should have(11).report_trackers }
 
-      it "should parse the production lines" do
-        production_rails = RequestLogAnalyzer::FileFormat.load(:rails, 'production')
-        @rails.line_definitions.should == production_rails.line_definitions
+      it "should parse the lines in the production set" do
+        subject.line_definitions.should == RequestLogAnalyzer::FileFormat.load(:rails, 'production').line_definitions
       end
     end
 
     context 'using a comma separated list of lines as argument' do
-      before(:each) { @rails = RequestLogAnalyzer::FileFormat.load(:rails, 'minimal,failure') }
-
-      it "should return a valid language" do
-        @rails.should be_valid
-      end
+      subject {  RequestLogAnalyzer::FileFormat.load(:rails, 'minimal,failure') }
 
-      it "should at least parse :processing and :completed lines" do
-        @rails.line_definitions.should include(:processing, :completed, :failure)
-      end
+      it { should be_well_formed }
+      it { should have(10).report_trackers }
+      
+      it { should have_line_definition(:processing) }
+      it { should have_line_definition(:completed) }
+      it { should have_line_definition(:failure) }
     end
 
     RequestLogAnalyzer::FileFormat::Rails::LINE_COLLECTIONS.keys.each do |constant|
 
       context "using the '#{constant}' line collection constant" do
-        before(:each) { @rails = RequestLogAnalyzer::FileFormat.load(:rails, constant) }
+        subject { RequestLogAnalyzer::FileFormat.load(:rails, constant) }
 
-        it "should return a valid language" do
-          @rails.should be_valid
-        end
+        it { should be_well_formed }
+        it { should have_at_least(9).report_trackers }
 
-        it "should at least parse :processing and :completed lines" do
-          @rails.line_definitions.should include(:processing, :completed)
-        end
+        it { should have_line_definition(:processing) }
+        it { should have_line_definition(:completed) }
       end
     end
   end
+  
+  subject { RequestLogAnalyzer::FileFormat.load(:rails, :all) }
 
   describe '#parse_line' do
-    before(:each) { @rails = RequestLogAnalyzer::FileFormat.load(:rails, :all) }
 
     {'with prefix' => 'LINE PREFIX: ', 'without prefix' => '' }.each do |context, prefix|
       context context do
         it "should parse a :processing line correctly" do
           line = prefix + 'Processing PeopleController#index (for 1.1.1.1 at 2008-08-14 21:16:30) [GET]'
-          @rails.should parse_line(line).as(:processing).and_capture(:controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '1.1.1.1')
+          subject.should parse_line(line).as(:processing).and_capture(:controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '1.1.1.1')
         end
         
         it "should parse a :processing line correctly when it contains ipv6 localhost address" do
            line = prefix + 'Processing PeopleController#index (for ::1 at 2008-08-14 21:16:30) [GET]'
-           @rails.should parse_line(line).as(:processing).and_capture(:controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '::1')
+           subject.should parse_line(line).as(:processing).and_capture(:controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '::1')
         end
 
         it "should parse a :processing line correctly when it contains ipv6 address" do
            line = prefix + 'Processing PeopleController#index (for 3ffe:1900:4545:3:200:f8ff:fe21:67cf at 2008-08-14 21:16:30) [GET]'
-           @rails.should parse_line(line).as(:processing).and_capture(:controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '3ffe:1900:4545:3:200:f8ff:fe21:67cf')
+           subject.should parse_line(line).as(:processing).and_capture(:controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '3ffe:1900:4545:3:200:f8ff:fe21:67cf')
         end
 
         it "should parse a Rails 2.1 style :completed line correctly" do
           line = prefix + 'Completed in 0.21665 (4 reqs/sec) | Rendering: 0.00926 (4%) | DB: 0.00000 (0%) | 200 OK [http://demo.nu/employees]'
-          @rails.should parse_line(line).as(:completed).and_capture(:duration => 0.21665, :db => 0.0, :view => 0.00926, :status => 200, :url => 'http://demo.nu/employees')
+          subject.should parse_line(line).as(:completed).and_capture(:duration => 0.21665, :db => 0.0, :view => 0.00926, :status => 200, :url => 'http://demo.nu/employees')
         end
 
         it "should parse a Rails 2.2 style :completed line correctly" do
           line = prefix + 'Completed in 614ms (View: 120, DB: 31) | 200 OK [http://floorplanner.local/demo]'
-          @rails.should parse_line(line).as(:completed).and_capture(:duration => 0.614, :db => 0.031, :view => 0.120, :status => 200, :url => 'http://floorplanner.local/demo')
+          subject.should parse_line(line).as(:completed).and_capture(:duration => 0.614, :db => 0.031, :view => 0.120, :status => 200, :url => 'http://floorplanner.local/demo')
         end
 
         it "should parse a Rails 2.2 style :completed line correctly when AR is disabled" do
           line = prefix + 'Completed in 597ms (View: 298 | 200 OK [http://shapado.com]'
-          @rails.should parse_line(line).as(:completed).and_capture(:duration => 0.597, :db => nil, :view => 0.298, :status => 200, :url => 'http://shapado.com')
+          subject.should parse_line(line).as(:completed).and_capture(:duration => 0.597, :db => nil, :view => 0.298, :status => 200, :url => 'http://shapado.com')
         end
         
         it "should parse a Rails 2.2 style :completed line without view" do
           line = prefix + "Completed in 148ms (DB: 0) | 302 Found [http://iwp-sod.hargray.org/login]"
-          @rails.should parse_line(line).as(:completed).and_capture(:duration => 0.148, :db => 0.0, :view => nil, :status => 302, :url => 'http://iwp-sod.hargray.org/login')
+          subject.should parse_line(line).as(:completed).and_capture(:duration => 0.148, :db => 0.0, :view => nil, :status => 302, :url => 'http://iwp-sod.hargray.org/login')
         end
 
         it "should parse a :failure line with exception correctly" do
           line = prefix + "NoMethodError (undefined method `update_domain_account' for nil:NilClass):"
-          @rails.should parse_line(line).as(:failure).and_capture(:error => 'NoMethodError', :message => "undefined method `update_domain_account' for nil:NilClass")
+          subject.should parse_line(line).as(:failure).and_capture(:error => 'NoMethodError', :message => "undefined method `update_domain_account' for nil:NilClass")
         end
 
         it "should parse a :cache_hit line correctly with an filter instance reference" do
           line = prefix + 'Filter chain halted as [#<ActionController::Filters::AroundFilter:0x2a999ad120 @identifier=nil, @kind=:filter, @options={:only=>#<Set: {"cached"}>, :if=>:not_logged_in?, :unless=>nil}, @method=#<ActionController::Caching::Actions::ActionCacheFilter:0x2a999ad620 @check=nil, @options={:store_options=>{}, :layout=>nil, :cache_path=>#<Proc:0x0000002a999b8890@/app/controllers/cached_controller.rb:8>}>>] did_not_yield.'
-          @rails.should parse_line(line).as(:cache_hit)
+          subject.should parse_line(line).as(:cache_hit)
         end
 
         it "should parse a :cache_hit line correctly with an proc instance reference" do
           line = prefix + 'Filter chain halted as [#<ActionController::Filters::AroundFilter:0x2a9a923e38 @method=#<Proc:0x0000002a9818b3f8@/usr/local/lib/ruby/gems/1.8/gems/actionpack-2.3.5/lib/action_controller/caching/actions.rb:64>, @kind=:filter, @identifier=nil, @options={:unless=>nil, :if=>nil, :only=>#<Set: {"show"}>}>] did_not_yield.'          
-          @rails.should parse_line(line).as(:cache_hit)
+          subject.should parse_line(line).as(:cache_hit)
         end
 
 
         it "should parse a :parameters line correctly" do
           line = prefix + '  Parameters: {"action"=>"cached", "controller"=>"cached"}'
-          @rails.should parse_line(line).as(:parameters).and_capture(:params => {:action => 'cached', :controller => 'cached'})
+          subject.should parse_line(line).as(:parameters).and_capture(:params => {:action => 'cached', :controller => 'cached'})
         end
 
         it "should parse a :rendered line correctly" do
           line = prefix + 'Rendered layouts/_footer (2.9ms)'
-          @rails.should parse_line(line).as(:rendered).and_capture(:render_file => 'layouts/_footer', :render_duration => 0.0029)
+          subject.should parse_line(line).as(:rendered).and_capture(:render_file => 'layouts/_footer', :render_duration => 0.0029)
         end
 
         it "should parse a :query_executed line with colors" do
           line = prefix + ' User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) '
-          @rails.should parse_line(line).as(:query_executed).and_capture(:query_class => 'User', :query_duration => 0.0004, :query_sql => 'SELECT * FROM users WHERE (users.id = :int)')
+          subject.should parse_line(line).as(:query_executed).and_capture(:query_class => 'User', :query_duration => 0.0004, :query_sql => 'SELECT * FROM users WHERE (users.id = :int)')
         end
 
         it "should parse a :query_executed line without colors" do
           line = prefix + ' User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) '
-          @rails.should parse_line(line).as(:query_executed).and_capture(:query_class => 'User', :query_duration => 0.0004, :query_sql => 'SELECT * FROM users WHERE (users.id = :int)')
+          subject.should parse_line(line).as(:query_executed).and_capture(:query_class => 'User', :query_duration => 0.0004, :query_sql => 'SELECT * FROM users WHERE (users.id = :int)')
         end
 
         it "should parse a :query_cached line with colors" do
           line = prefix + ' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) '
-          @rails.should parse_line(line).as(:query_cached).and_capture(:cached_duration => 0.0, :cached_sql => 'SELECT * FROM users WHERE (users.id = :int)')
+          subject.should parse_line(line).as(:query_cached).and_capture(:cached_duration => 0.0, :cached_sql => 'SELECT * FROM users WHERE (users.id = :int)')
         end
 
         it "should parse a :query_cached line without colors" do
           line = prefix + ' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) '
-          @rails.should parse_line(line).as(:query_cached).and_capture(:cached_duration => 0.0, :cached_sql => 'SELECT * FROM users WHERE (users.id = :int)')
+          subject.should parse_line(line).as(:query_cached).and_capture(:cached_duration => 0.0, :cached_sql => 'SELECT * FROM users WHERE (users.id = :int)')
         end
 
         it "should not parse an unsupported line" do
           line = prefix + 'nonsense line that should not be parsed as anything'
-          @rails.should_not parse_line(line)
+          subject.should_not parse_line(line)
         end
       end
     end
   end
 
   describe '#parse_io' do
-    before(:each) do
-      @log_parser = RequestLogAnalyzer::Source::LogParser.new(
-            RequestLogAnalyzer::FileFormat.load(:rails), :parse_strategy => 'cautious')
-    end
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject, :parse_strategy => 'cautious') }
 
     it "should parse a Rails 2.1 style log and find valid Rails requests without warnings" do
-      request_counter.should_receive(:hit!).exactly(4).times
-      @log_parser.should_not_receive(:warn)
-      
-      @log_parser.parse_file(log_fixture(:rails_1x)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails::Request) && request.completed?
-      end
+      log_parser.should_receive(:handle_request).exactly(4).times
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_file(log_fixture(:rails_1x))\
     end
 
     it "should parse a Rails 2.2 style log and find valid Rails requests without warnings" do
-      request_counter.should_receive(:hit!).once
-      @log_parser.should_not_receive(:warn)
-      
-      @log_parser.parse_file(log_fixture(:rails_22)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails::Request) && request.completed?
-      end
+      log_parser.should_receive(:handle_request).once
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_file(log_fixture(:rails_22))
     end
 
     it "should parse a Rails SyslogLogger file with prefix and find valid requests without warnings" do
-      request_counter.should_receive(:hit!).once
-      @log_parser.should_not_receive(:warn)
-      
-      @log_parser.parse_file(log_fixture(:syslog_1x)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails::Request) && request.completed?
-      end
+      log_parser.should_receive(:handle_request).once
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_file(log_fixture(:syslog_1x))
     end
 
     it "should parse cached requests" do
-      @log_parser.should_not_receive(:warn)
-      @log_parser.parse_file(log_fixture(:rails_22_cached)) do |request|
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_file(log_fixture(:rails_22_cached)) do |request|
         request.should be_completed
         request =~ :cache_hit
       end
     end
 
     it "should detect unordered requests in the logs" do
-      @log_parser.should_not_receive(:handle_request)
-      @log_parser.should_receive(:warn).with(:unclosed_request, anything).once
-      @log_parser.should_receive(:warn).with(:no_current_request, anything).twice
-      @log_parser.parse_file(log_fixture(:rails_unordered))
+      log_parser.should_not_receive(:handle_request)
+      log_parser.should_receive(:warn).with(:unclosed_request, anything).once
+      log_parser.should_receive(:warn).with(:no_current_request, anything).at_least(:twice)
+      log_parser.parse_file(log_fixture(:rails_unordered))
     end
   end
 end

data/spec/unit/file_format/w3c_format_spec.rb

@@ -2,45 +2,46 @@ require 'spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::W3c do
 
-  before(:each) do
-    @file_format = RequestLogAnalyzer::FileFormat.load(:w3c)
-    @log_parser  = RequestLogAnalyzer::Source::LogParser.new(@file_format)  
-    #          date       time     c-ip cs-username s-ip     s-port  cs-method cs-uri-stem cs-uri-query sc-status sc-bytes cs-bytes time-taken cs(User-Agent) cs(Referrer) 
-    @sample = '2002-05-24 20:18:01 172.224.24.114 - 206.73.118.24 80 GET /Default.htm - 200 7930 248 31 Mozilla/4.0+(compatible;+MSIE+5.01;+Windows+2000+Server) http://64.224.24.114/'
+  subject { RequestLogAnalyzer::FileFormat.load(:w3c) }
+
+  it { should be_well_formed }
+  it { should have_line_definition(:access).capturing(:timestamp, :remote_ip, :username, :local_ip, :port,
+            :method, :path, :http_status, :bytes_sent, :bytes_received, :duration, :user_agent, :referer) }
+
+  it { should have(10).report_trackers }
+  
+  let(:sample1) { '2002-05-24 20:18:01 172.224.24.114 - 206.73.118.24 80 GET /Default.htm - 200 7930 248 31 Mozilla/4.0+(compatible;+MSIE+5.01;+Windows+2000+Server) http://64.224.24.114/' }
+  let(:irrelevant) { '#Software: Microsoft Internet Information Services 6.0' }
+  
+  describe '#parse_line' do
+    it { should parse_line(sample1, 'an access line').and_capture(
+              :timestamp      => 20020524201801,
+              :remote_ip      => "172.224.24.114",
+              :username       => nil,
+              :local_ip       => "206.73.118.24",
+              :port           => 80,
+              :method         => 'GET',
+              :path           => '/Default.htm',
+              :http_status    => 200,
+              :bytes_sent     => 7930,
+              :bytes_received => 248,
+              :duration       => 0.031,
+              :user_agent     => 'Mozilla/4.0+(compatible;+MSIE+5.01;+Windows+2000+Server)',
+              :referer        => 'http://64.224.24.114/')
+    }
+    
+    it { should_not parse_line(irrelevant, 'an irrelevant line') }
+    it { should_not parse_line('nonsense', 'a nonsense line') }
   end
-
-  it "should be a valid file format" do
-    @file_format.should be_valid
-  end
-
-  it "should parse access lines and capture all of its fields" do
-    @file_format.should have_line_definition(:access).capturing(:timestamp, :remote_ip, :username, :local_ip, :port, :method, :path, :http_status, :bytes_sent, :bytes_received, :duration, :user_agent, :referer)
-  end
-
-  it "should match the sample line" do
-    @file_format.parse_line(@sample).should include(:line_definition, :captures)
-  end
-
-  it "should not match a nonsense line" do
-    @file_format.parse_line('#Software: Microsoft Internet Information Services 6.0').should be_nil
-  end
-
-  it "should parse and convert the sample fields correctly" do
-    @log_parser.parse_io(StringIO.new(@sample)) do |request|
-      request[:timestamp].should      == 20020524201801
-      request[:remote_ip].should      == "172.224.24.114"
-      request[:username].should       == nil
-      request[:local_ip].should       == "206.73.118.24"
-      request[:port].should           == 80
-      request[:method].should         == 'GET'
-      request[:path].should           == '/Default.htm'
-      request[:http_status].should    == 200
-      request[:bytes_sent].should     == 7930
-      request[:bytes_received].should == 248
-      request[:duration].should       == 0.031
-      request[:user_agent].should     == 'Mozilla/4.0+(compatible;+MSIE+5.01;+Windows+2000+Server)'
-      request[:referer].should        == 'http://64.224.24.114/'
+  
+  describe '#parse_io' do
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
+    let(:snippet) { log_snippet(irrelevant, sample1, sample1) }
+    
+    it "should parse a snippet successully without warnings" do
+      log_parser.should_receive(:handle_request).twice
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_io(snippet)
     end
   end
-
-end
+end

data/spec/unit/source/log_parser_spec.rb

@@ -11,7 +11,7 @@ describe RequestLogAnalyzer::Source::LogParser, :requests do
   end
 
   it "should have a valid language" do
-    @log_parser.file_format.should be_valid
+    @log_parser.file_format.should be_well_formed
   end
 
   it "should set the :source for every parsed line" do

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 10
+  - 11
   - 0
-  version: 1.10.0
+  version: 1.11.0
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-26 00:00:00 -05:00
+date: 2011-04-27 00:00:00 -04:00
 default_executable: request-log-analyzer
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -83,6 +83,7 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - .gitignore
+- .infinity_test
 - DESIGN.rdoc
 - Gemfile
 - LICENSE
@@ -94,7 +95,6 @@ files:
 - lib/cli/database_console_init.rb
 - lib/cli/progressbar.rb
 - lib/cli/tools.rb
-- lib/mixins/gets_memory_protection.rb
 - lib/request_log_analyzer.rb
 - lib/request_log_analyzer/aggregator.rb
 - lib/request_log_analyzer/aggregator/database_inserter.rb
@@ -131,12 +131,10 @@ files:
 - lib/request_log_analyzer/log_processor.rb
 - lib/request_log_analyzer/mailer.rb
 - lib/request_log_analyzer/output.rb
-- lib/request_log_analyzer/output/fancy_html.rb
 - lib/request_log_analyzer/output/fixed_width.rb
 - lib/request_log_analyzer/output/html.rb
 - lib/request_log_analyzer/request.rb
 - lib/request_log_analyzer/source.rb
-- lib/request_log_analyzer/source/database_loader.rb
 - lib/request_log_analyzer/source/log_parser.rb
 - lib/request_log_analyzer/tracker.rb
 - lib/request_log_analyzer/tracker/duration.rb

data/lib/mixins/gets_memory_protection.rb

@@ -1,80 +0,0 @@
-class File
-  alias_method :gets_original, :gets
-  # The size of the reads we will use to add to the line buffer.
-  MAX_READ_SIZE=1024*100
-
-  # 
-  # This method returns the next line of the File.
-  # 
-  # It works by moving the file pointer forward +MAX_READ_SIZE+ at a time, 
-  # storing seen lines in <tt>@line_buffer</tt>.  Once the buffer contains at 
-  # least two lines (ensuring we have seen on full line) or the file pointer 
-  # reaches the end of the File, the last line from the buffer is returned.  
-  # When the buffer is exhausted, this will throw +nil+ (from the empty Array).
-  #
-  # Read portions of the file that do not contain the +sep_string+ are not added to 
-  # the buffer. This prevents <tt>@line_buffer<tt> from growing signficantly when parsing
-  # large lines.
-  #
-  def gets(sep_string = $/)
-    @read_size ||= MAX_READ_SIZE
-    # A buffer to hold lines read, but not yet returned.
-    @line_buffer ||= Array.new
-        
-    # Record where we are.
-    @current_pos ||= pos
-    
-    # Last Position in the file
-    @last_pos ||= nil
-    if @last_pos.nil? 
-      seek(0, IO::SEEK_END)
-      @last_pos = pos
-      seek(@current_pos, IO::SEEK_SET)
-    end
-    
-    # 
-    # If we have more than one line in the buffer or we have reached the
-    # beginning of the file, send the last line in the buffer to the caller.  
-    # (This may be +nil+, if the buffer has been exhausted.)
-    #
-    if @line_buffer.size > 2 or @current_pos >= @last_pos
-      self.lineno += 1
-      return @line_buffer.shift 
-    end
-    
-    sep = 
-    
-    chunk = String.new
-    while chunk and chunk !~ /#{sep_string}/   
-      chunk = read(@read_size)
-    end
-    
-    # Appends new lines to the last element of the buffer
-    line_buffer_pos = @line_buffer.any? ? @line_buffer.size-1 : 0
-    
-    if chunk
-      @line_buffer[line_buffer_pos] = @line_buffer[line_buffer_pos].to_s<< chunk
-    else
-      # at the end
-      return @line_buffer.shift
-    end
-    
-    # 
-    # Divide the last line of the buffer based on +sep_string+ and #flatten!
-    # those new lines into the buffer.
-    # 
-    @line_buffer[line_buffer_pos] = @line_buffer[line_buffer_pos].scan(/.*?#{Regexp.escape(sep_string)}|.+/)
-    @line_buffer.flatten!
-
-    # 
-    # If we made it this far, we need to read more data to try and find the 
-    # end of a line or the end of the file.  Move the file pointer
-    # forward a step, to give us new bytes to read.
-    #
-    @current_pos += @read_size
-    seek(@current_pos, IO::SEEK_SET)
-    
-    # We have more data now, so try again to read a line...
-    gets(sep_string)
-  end
-end

data/lib/request_log_analyzer/output/fancy_html.rb

@@ -1,44 +0,0 @@
-begin 
-  require 'rubygems'
-  require 'gchart'
-rescue LoadError
-  $stderr.puts "The FancyHTML output format requires the googlechart gem:"
-  $stderr.puts "  (sudo) gem install googlecharts"
-end
-
-module RequestLogAnalyzer::Output
-  
-  class FancyHTML < HTML
-    
-    def report_tracker(tracker)
-      case tracker
-      when RequestLogAnalyzer::Tracker::HourlySpread then report_hourly_spread(tracker)
-      else tracker.report(self)
-      end
-    end
-    
-    def report_hourly_spread(tracker)
-      title tracker.title
-      puts tag(:img, nil, :width => '700', :height => '120', :src =>
-          Gchart.sparkline(:data => tracker.hour_frequencies, :size => '700x120', :line_colors => '0077CC',
-                           :axis_with_labels => 'x,y', :axis_labels => [x_axis_labels(tracker),y_axis_labels(tracker)]))
-    end
-    
-    def x_axis_labels(tracker)
-      frmt = '%H:%M'
-      x_axis_labels = []
-      num_labels    = 5
-      start         = tracker.first_timestamp
-      step          = tracker.timespan / (num_labels - 1)
-      for i in 0...num_labels do
-        x_axis_labels << (start + step * i).strftime(frmt)
-      end
-      x_axis_labels
-    end
-    
-    def y_axis_labels(tracker)
-      sorted_frequencies = tracker.hour_frequencies.sort
-      [sorted_frequencies.first, sorted_frequencies.last]
-    end
-  end
-end

data/lib/request_log_analyzer/source/database_loader.rb

@@ -1,87 +0,0 @@
-require 'rubygems'
-require 'activerecord'
-
-module RequestLogAnalyzer::Source
-
-  # Active Resource hook
-  class Request < ActiveRecord::Base
-    has_many :completed_lines
-    has_many :processing_lines
-    def convert(file_format)
-      send_attributes = self.attributes
-      send_attributes.merge!(self.completed_lines.first.attributes) if self.completed_lines.first
-      send_attributes.merge!(self.processing_lines.first.attributes) if self.processing_lines.first
-      return RequestLogAnalyzer::Request.new(file_format, send_attributes)
-    end
-  end
-
-  class CompletedLine < ActiveRecord::Base
-    belongs_to :request
-  end
-
-  class ProcessingLine < ActiveRecord::Base
-    belongs_to :request
-  end
-
-  # The Database class gets log data from the database.
-  class DatabaseLoader < Base
-
-    attr_reader :source_files, :file_format, :requests
-
-    # Initializes the log file parser instance.
-    # It will apply the language specific FileFormat module to this instance. It will use the line
-    # definitions in this module to parse any input that it is given (see parse_io).
-    #
-    # <tt>format</tt>:: The current file format instance
-    # <tt>options</tt>:: A hash of options that are used by the parser
-    def initialize(format, options = {})
-      super(format, options)
-      @source_files     = options[:source_files]
-      @parsed_requests  = 0
-      @requests         = []
-    end
-
-    # Reads the input, which can either be a file, sequence of files or STDIN to parse
-    # lines specified in the FileFormat. This lines will be combined into Request instances,
-    # that will be yielded. The actual parsing occurs in the parse_io method.
-    # <tt>options</tt>:: A Hash of options that will be pased to parse_io.
-    def each_request(options = {}, &block) # :yields: request
-      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => @source_files)
-
-      @progress_handler.call(:started, @source_files) if @progress_handler
-        RequestLogAnalyzer::Source::Request.find(:all).each do |request|
-          @parsed_requests += 1
-          @progress_handler.call(:progress, @parsed_requests) if @progress_handler
-
-          yield request.convert(self.file_format)
-        end
-
-      @progress_handler.call(:finished, @source_files) if @progress_handler
-    end
-
-    # Add a block to this method to install a progress handler while parsing.
-    # <tt>proc</tt>:: The proc that will be called to handle progress update messages
-    def progress=(proc)
-      @progress_handler = proc
-    end
-
-    # Add a block to this method to install a warning handler while parsing,
-    # <tt>proc</tt>:: The proc that will be called to handle parse warning messages
-    def warning=(proc)
-      @warning_handler = proc
-    end
-
-    # This method is called by the parser if it encounteres any parsing problems.
-    # It will call the installed warning handler if any.
-    #
-    # By default, RequestLogAnalyzer::Controller will install a warning handler
-    # that will pass the warnings to each aggregator so they can do something useful
-    # with it.
-    #
-    # <tt>type</tt>:: The warning type (a Symbol)
-    # <tt>message</tt>:: A message explaining the warning
-    def warn(type, message)
-      @warning_handler.call(type, message, @current_io.lineno) if @warning_handler
-    end
-  end
-end