request-log-analyzer 1.2.3 → 1.2.6

data/.gitignore

@@ -0,0 +1,10 @@
+.svn/
+.DS_Store
+request-log-analyzer-*.gem
+requests.db
+/pkg
+/doc
+/tmp
+/classes
+/files
+/coverage

data/Rakefile

@@ -1,3 +1,5 @@
 Dir[File.dirname(__FILE__) + "/tasks/*.rake"].each { |file| load(file) }
+
+GithubGem::RakeTasks.new(:gem)
  
-task :default => "spec:fancy"
+task :default => "spec:specdoc"

data/lib/request_log_analyzer.rb

@@ -11,7 +11,7 @@ module RequestLogAnalyzer
   
   # The current version of request-log-analyzer.
   # This will be diplayed in output reports etc.  
-  VERSION = '1.2.1'
+  VERSION = "1.2.6"
   
   # 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/lib/request_log_analyzer/aggregator/database.rb

@@ -46,6 +46,7 @@ module RequestLogAnalyzer::Aggregator
     def finalize
       @request_count = orm_module::Request.count
       remove_database_connection!
+      deinitialize_orm_module!
     end
     
     # Records w warining in the warnings table.
@@ -64,6 +65,11 @@ module RequestLogAnalyzer::Aggregator
       output << "\n"
     end
     
+    # Retreives the connection that is used for the database inserter
+    def connection
+      orm_module::Base.connection
+    end    
+    
     protected 
     
     # Create a module and a default subclass of ActiveRecord::Base on which to establish the database connection
@@ -79,16 +85,22 @@ module RequestLogAnalyzer::Aggregator
         orm_base_class.abstract_class = true
         orm_module.const_set('Base', orm_base_class)
       end
-    end    
-    
+    end
+
+    # Deinitializes the ORM module and the ActiveRecord::Base subclass.
+    def deinitialize_orm_module!
+      file_format.class.send(:remove_const, 'Database') if file_format.class.const_defined?('Database')
+      @orm_module = nil
+    end
+
     # Established a connection with the database for this session
     def establish_database_connection!
       orm_module::Base.establish_connection(:adapter => 'sqlite3', :database => options[:database])
-      ActiveRecord::Migration.class_eval("def self.connection; #{@orm_module.to_s}::Base.connection; end ")
-    end    
-    
+      #ActiveRecord::Migration.class_eval("def self.connection; #{@orm_module.to_s}::Base.connection; end ")
+    end
+
     def remove_database_connection!
-      ActiveRecord::Migration.class_eval("def self.connection; ActiveRecord::Base.connection; end ")      
+      #ActiveRecord::Migration.class_eval("def self.connection; ActiveRecord::Base.connection; end ")      
       orm_module::Base.remove_connection
     end
     
@@ -97,8 +109,7 @@ module RequestLogAnalyzer::Aggregator
     # what line in the original file the line was found, and a request_id to link lines related
     # to the same request. It will also create an index in the request_id field to speed up queries.
     def create_database_table(definition)
-      ActiveRecord::Migration.verbose = options[:debug] # keep it down a notch please
-      ActiveRecord::Migration.create_table("#{definition.name}_lines") do |t|
+      connection.create_table("#{definition.name}_lines") do |t|
         
         # Add default fields for every line type
         t.column(:request_id, :integer)
@@ -114,7 +125,7 @@ module RequestLogAnalyzer::Aggregator
       end
       
       # Create an index on the request_id column to support faster querying
-      ActiveRecord::Migration.add_index("#{definition.name}_lines", [:request_id])
+      connection.add_index("#{definition.name}_lines", [:request_id])
     end
     
     # Creates an ActiveRecord class for a given line definition.
@@ -126,8 +137,8 @@ module RequestLogAnalyzer::Aggregator
       klass = Class.new(orm_module::Base)
       klass.send(:belongs_to, :request)
       
-      definition.captures.each do |capture|
-        klass.send(:serialize, capture[:name], Hash) if capture[:provides]
+      definition.captures.select { |c| c.has_key?(:provides) }.each do |capture|
+        klass.send(:serialize, capture[:name], Hash)
       end
       
       orm_module.const_set(class_name, klass) unless orm_module.const_defined?(class_name)
@@ -137,10 +148,9 @@ module RequestLogAnalyzer::Aggregator
     # Creates a requests table, in which a record is created for every request. It also creates an
     # ActiveRecord::Base class to communicate with this table.
     def create_request_table_and_class
-      ActiveRecord::Migration.verbose = options[:debug]
-      ActiveRecord::Migration.create_table("requests") do |t|
-        t.integer :first_lineno
-        t.integer :last_lineno
+      connection.create_table("requests") do |t|
+        t.column :first_lineno, :integer
+        t.column :last_lineno,  :integer
       end    
       
       orm_module.const_set('Request', Class.new(orm_module::Base)) unless orm_module.const_defined?('Request')     
@@ -149,11 +159,10 @@ module RequestLogAnalyzer::Aggregator
 
     # Creates a warnings table and a corresponding Warning class to communicate with this table using ActiveRecord.
     def create_warning_table_and_class
-      ActiveRecord::Migration.verbose = options[:debug]
-      ActiveRecord::Migration.create_table("warnings") do |t|
-        t.string  :warning_type, :limit => 30, :null => false
-        t.string  :message
-        t.integer :lineno          
+      connection.create_table("warnings") do |t|
+        t.column  :warning_type, :string, :limit => 30, :null => false
+        t.column  :message, :string
+        t.column  :lineno, :integer
       end    
       
       orm_module.const_set('Warning', Class.new(orm_module::Base)) unless orm_module.const_defined?('Warning')

data/lib/request_log_analyzer/file_format/merb.rb

@@ -16,18 +16,16 @@ module RequestLogAnalyzer::FileFormat
       line.teaser = /Params/
       line.regexp = /Params\:\ (\{.+\})/
       line.captures << { :name => :params, :type => :eval, :provides => { 
-            :namespace => :string, :controller => :string, :action => :string, :format => :string } }
+            :namespace => :string, :controller => :string, :action => :string, :format => :string, :method => :string } }
     end
 
     # ~ {:dispatch_time=>0.006117, :after_filters_time=>6.1e-05, :before_filters_time=>0.000712, :action_time=>0.005833}
     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 => :duration } \
-                    << { :name => :after_filters_time,  :type => :duration } \
-                    << { :name => :before_filters_time, :type => :duration } \
-                    << { :name => :action_time,         :type => :duration }
+      line.regexp = /(\{.*\:dispatch_time\s*=>\s*\d+\.\d+.*\})/
+      line.captures << { :name => :times_hash, :type => :eval, :provides => {
+            :dispatch_time => :duration, :after_filters_time => :duration,
+            :before_filters_time => :duration, :action_time => :duration } }
     end
     
     REQUEST_CATEGORIZER = Proc.new do |request| 

data/lib/request_log_analyzer/request.rb

@@ -145,11 +145,11 @@ module RequestLogAnalyzer
     end
     
     def first_lineno
-      @lines.first[:lineno]
+      @lines.map { |line| line[:lineno] }.reject { |v| v.nil? }.min
     end
     
     def last_lineno
-      @lines.last[:lineno]
+      @lines.map { |line| line[:lineno] }.reject { |v| v.nil? }.max
     end
   end
 end

data/request-log-analyzer.gemspec

@@ -0,0 +1,36 @@
+Gem::Specification.new do |s|
+  s.name    = 'request-log-analyzer'
+  s.version = "1.2.6"
+  s.date    = "2009-09-02"
+  
+  s.rubyforge_project = 'r-l-a'
+  
+  s.bindir             = 'bin'
+  s.executables        = ['request-log-analyzer']
+  s.default_executable = 'request-log-analyzer'
+  
+  s.summary     = "A command line tool to analyze request logs for Rails, Merb and other application servers"
+  s.description = <<-eos
+    Request log analyzer's purpose is to find ot how your web application is being used and to focus your optimization efforts.
+    This tool will parse all requests in the application's log file and aggregate the information. Once it is finished parsing 
+    the log file(s), it will show the requests that take op most server time using various metrics. It can also insert all 
+    parsed request information into a database so you can roll your own analysis. It supports Rails- and Merb-based applications 
+    out of the box, but file formats of other applications can easily be supported by supplying an easy to write log file format 
+    definition.
+  eos
+  
+  s.rdoc_options << '--title' << s.name << '--main' << 'README.rdoc' << '--line-numbers' << '--inline-source'
+  s.extra_rdoc_files = ['README.rdoc']
+  
+  s.requirements << "To use the database inserter, ActiveRecord and an appropriate database adapter are required."
+  
+  s.add_development_dependency('rspec', '>= 1.2.4')
+  s.add_development_dependency('git',   '>= 1.1.0')
+  
+  s.authors  = ['Willem van Bergen', 'Bart ten Brinke']
+  s.email    = ['willem@railsdoctors.com', 'bart@railsdoctors.com']
+  s.homepage = 'http://railsdoctors.com'
+
+  s.files      = %w(spec/unit/filter/anonymize_filter_spec.rb lib/request_log_analyzer/line_definition.rb lib/request_log_analyzer/output/html.rb lib/request_log_analyzer/controller.rb spec/fixtures/rails_22_cached.log lib/request_log_analyzer/file_format/rails_development.rb spec/lib/macros.rb spec/fixtures/merb_prefixed.log tasks/request_log_analyzer.rake spec/unit/file_format/file_format_api_spec.rb spec/integration/command_line_usage_spec.rb spec/fixtures/decompression.log.bz2 lib/request_log_analyzer/log_processor.rb lib/request_log_analyzer/tracker.rb lib/request_log_analyzer/filter.rb spec/fixtures/rails_unordered.log bin/request-log-analyzer request-log-analyzer.gemspec DESIGN.rdoc spec/unit/filter/timespan_filter_spec.rb lib/request_log_analyzer/filter/field.rb lib/request_log_analyzer/tracker/frequency.rb spec/fixtures/decompression.log.gz spec/fixtures/decompression.log spec/lib/matchers.rb spec/fixtures/test_order.log lib/request_log_analyzer/output/fixed_width.rb lib/request_log_analyzer/filter/anonymize.rb spec/lib/testing_format.rb lib/request_log_analyzer/tracker/timespan.rb lib/request_log_analyzer/aggregator.rb lib/cli/progressbar.rb README.rdoc spec/fixtures/merb.log lib/request_log_analyzer/tracker/hourly_spread.rb .gitignore spec/unit/tracker/tracker_api_spec.rb spec/unit/tracker/duration_tracker_spec.rb lib/request_log_analyzer/aggregator/echo.rb spec/unit/controller/log_processor_spec.rb lib/request_log_analyzer.rb Rakefile spec/spec_helper.rb spec/unit/filter/filter_spec.rb lib/request_log_analyzer/aggregator/summarizer.rb lib/request_log_analyzer/file_format/rails.rb spec/fixtures/test_language_combined.log spec/fixtures/decompression.tar.gz spec/unit/filter/field_filter_spec.rb spec/spec.opts lib/request_log_analyzer/aggregator/database.rb lib/request_log_analyzer/filter/timespan.rb lib/request_log_analyzer/source/log_parser.rb spec/fixtures/decompression.tgz spec/unit/tracker/timespan_tracker_spec.rb spec/unit/tracker/hourly_spread_spec.rb spec/fixtures/header_and_footer.log lib/cli/tools.rb lib/request_log_analyzer/file_format/merb.rb spec/fixtures/multiple_files_1.log spec/unit/file_format/merb_format_spec.rb spec/unit/file_format/line_definition_spec.rb lib/request_log_analyzer/source.rb lib/request_log_analyzer/request.rb spec/unit/controller/controller_spec.rb lib/request_log_analyzer/output.rb spec/lib/helpers.rb spec/fixtures/rails_1x.log spec/lib/mocks.rb spec/fixtures/decompression.log.zip spec/unit/source/request_spec.rb spec/unit/source/log_parser_spec.rb spec/fixtures/test_file_format.log lib/request_log_analyzer/source/database.rb spec/unit/aggregator/database_spec.rb tasks/github-gem.rake lib/request_log_analyzer/tracker/duration.rb lib/request_log_analyzer/file_format.rb spec/unit/aggregator/summarizer_spec.rb spec/fixtures/rails_22.log spec/fixtures/multiple_files_2.log spec/fixtures/syslog_1x.log LICENSE spec/unit/tracker/frequency_tracker_spec.rb spec/unit/file_format/rails_format_spec.rb lib/cli/command_line_arguments.rb)
+  s.test_files = %w(spec/unit/filter/anonymize_filter_spec.rb spec/unit/file_format/file_format_api_spec.rb spec/integration/command_line_usage_spec.rb spec/unit/filter/timespan_filter_spec.rb spec/unit/tracker/tracker_api_spec.rb spec/unit/tracker/duration_tracker_spec.rb spec/unit/controller/log_processor_spec.rb spec/unit/filter/filter_spec.rb spec/unit/filter/field_filter_spec.rb spec/unit/tracker/timespan_tracker_spec.rb spec/unit/tracker/hourly_spread_spec.rb spec/unit/file_format/merb_format_spec.rb spec/unit/file_format/line_definition_spec.rb spec/unit/controller/controller_spec.rb spec/unit/source/request_spec.rb spec/unit/source/log_parser_spec.rb spec/unit/aggregator/database_spec.rb spec/unit/aggregator/summarizer_spec.rb spec/unit/tracker/frequency_tracker_spec.rb spec/unit/file_format/rails_format_spec.rb)
+end

data/spec/fixtures/merb_prefixed.log

@@ -0,0 +1,9 @@
+Aug 31 18:35:23 typekit-web001 merb:  ~
+Aug 31 18:35:23 typekit-web001 merb: cache: [GET /] miss
+Aug 31 18:35:24 typekit-web001 merb:  ~ Started request handling: Mon Aug 31 18:35:25 +0000 2009
+Aug 31 18:35:24 typekit-web001 merb:  ~ Routed to: {"action"=>"index", "controller"=>"home"}
+Aug 31 18:35:24 typekit-web001 merb:  ~ Params: {"action"=>"index", "controller"=>"home"}
+Aug 31 18:35:24 typekit-web001 merb:  ~ In repository block default
+Aug 31 18:35:24 typekit-web001 merb:  ~ (0.000000) SELECT `id`, `created_at`, `updated_at`, `braintree_vault_id`, `cancelled_at` FROM `accounts` WHERE (`id` IN (6214)) ORDER BY `id`
+Aug 31 18:35:24 typekit-web001 merb:  ~ Redirecting to: /plans (302)
+Aug 31 18:35:24 typekit-web001 merb:  ~ {:after_filters_time=>0.0, :before_filters_time=>0.0, :dispatch_time=>0.012001, :action_time=>0.012001}

data/spec/lib/mocks.rb

@@ -38,10 +38,21 @@ module RequestLogAnalyzer::Spec::Mocks
     output.stub!(:title)
     output.stub!(:line)
     output.stub!(:with_style)    
-    output.stub!(:table) { yield [] }
+    output.stub!(:table).and_yield([])
     output.stub!(:io).and_return(mock_io)
     return output
   end
   
+  def mock_migrator
+    table_creator = mock('ActiveRecord table creator')
+    table_creator.stub!(:column)
+    
+    migrator = mock('ActiveRecord::Base.connection for migrations')
+    migrator.stub!(:add_index)
+    migrator.stub!(:create_table).and_yield(table_creator).and_return(true)
+    migrator.stub!(:table_creator).and_return(table_creator)
+    return migrator
+  end
+  
   
 end

data/spec/unit/aggregator/database_spec.rb

@@ -2,13 +2,13 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Aggregator::Database do
 
-  before(:each) do
+  before(:all) do
     log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format)
     @database_inserter = RequestLogAnalyzer::Aggregator::Database.new(log_parser, :database => ':memory:')
     
     @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, { :regexp   => /Testing (\w+), tries\: (\d+)/,
                           :captures => [{ :name => :what, :type => :string }, { :name => :tries, :type => :integer },
-                            { :name => :evaluated, :type => :hash, :provides => {:evaluated_field => :duration} }]})    
+                            { :name => :evaluated, :type => :hash, :provides => {:evaluated_field => :duration} }]})                               
   end
   
   # The prepare method is called before the parsing starts. It should establish a connection
@@ -16,12 +16,18 @@ describe RequestLogAnalyzer::Aggregator::Database do
   describe '#prepare' do
 
     before(:each) do
-      @database_inserter.stub!(:establish_database_connection!)      
+      @database_inserter.stub!(:initialize_orm_module!)
+      @database_inserter.stub!(:establish_database_connection!)
       @database_inserter.stub!(:create_database_schema!)
     end
 
+    it 'should create the ORM mdoule in which the classes can be created' do
+      @database_inserter.should_receive(:initialize_orm_module!)
+      @database_inserter.prepare
+    end
+
     it 'should establish the database connection' do
-      @database_inserter.should_receive(:establish_database_connection!)      
+      @database_inserter.should_receive(:establish_database_connection!)
       @database_inserter.prepare
     end
     
@@ -31,48 +37,70 @@ describe RequestLogAnalyzer::Aggregator::Database do
     end
   end
   
+  # The database inserter creates is own "Database" module within the file format 
+  # class to create all the classes that are needed.
+  describe '#initialize_orm_module!' do
+    
+    before(:all) { @database_inserter.send(:deinitialize_orm_module!) }
+    after(:all)  { @database_inserter.send(:initialize_orm_module!) }
+    
+    before(:each) { @database_inserter.send(:initialize_orm_module!) }
+    after(:each)  { @database_inserter.send(:deinitialize_orm_module!) }
+    
+    it "should create a Database module under the file format's class" do
+      testing_format.class.should be_const_defined('Database')
+    end
+    
+    it "should define a Base class in the Database module" do
+      testing_format.class::Database.should be_const_defined('Base')
+    end
+    
+    it "should create a ActiveRecord::Base class in the Database module" do
+      testing_format.class::Database::Base.ancestors.should include(ActiveRecord::Base)
+    end
+    
+  end
+  
   # The create_database_table method should create a database table according to the line definition,
   # so that parsed lines can be stored in it later on.
   describe '#create_database_table' do
     
     before(:each) do
-      @table_creator = mock('create_table block')
-      @table_creator.stub!(:column)
-      ActiveRecord::Migration.stub!(:create_table).and_yield(@table_creator)
-      ActiveRecord::Migration.stub!(:add_index)
+      @connection = mock_migrator
+      @database_inserter.stub!(:connection).and_return(@connection)
     end
     
     it "should create a table based on the line type name" do
-      ActiveRecord::Migration.should_receive(:create_table).with('test_lines')
+      @connection.should_receive(:create_table).with('test_lines')
       @database_inserter.send(:create_database_table, @line_definition)
     end    
     
     it "should create an index on the request_id field" do
-      ActiveRecord::Migration.should_receive(:add_index).with('test_lines', [:request_id])
+      @connection.should_receive(:add_index).with('test_lines', [:request_id])
       @database_inserter.send(:create_database_table, @line_definition)
     end
     
     it "should create a request_id field to link the requests together" do
-      @table_creator.should_receive(:column).with(:request_id, :integer)
+      @connection.table_creator.should_receive(:column).with(:request_id, :integer)
       @database_inserter.send(:create_database_table, @line_definition)
     end
     
     it "should create a lineno field to save the location of the line in the original file" do
-      @table_creator.should_receive(:column).with(:lineno, :integer)
+      @connection.table_creator.should_receive(:column).with(:lineno, :integer)
       @database_inserter.send(:create_database_table, @line_definition)
     end
     
     it "should create a field of the correct type for every defined field" do
-      @table_creator.should_receive(:column).with(:what, :string)
-      @table_creator.should_receive(:column).with(:tries, :integer)
+      @connection.table_creator.should_receive(:column).with(:what, :string)
+      @connection.table_creator.should_receive(:column).with(:tries, :integer)
       # :hash capture type should map on a :text field type
-      @table_creator.should_receive(:column).with(:evaluated, :text) 
+      @connection.table_creator.should_receive(:column).with(:evaluated, :text) 
       @database_inserter.send(:create_database_table, @line_definition)      
     end
     
     it "should create a field of the correct type for every provided field" do
       # :duration capture type should map on a :double field type
-      @table_creator.should_receive(:column).with(:evaluated_field, :double) 
+      @connection.table_creator.should_receive(:column).with(:evaluated_field, :double) 
       @database_inserter.send(:create_database_table, @line_definition)   
     end
   end
@@ -129,21 +157,19 @@ describe RequestLogAnalyzer::Aggregator::Database do
     before(:each) do
       @line_type_cnt = testing_format.line_definitions.length
 
-      #Make sure no actual migrations occur
-      ActiveRecord::Migration.stub!(:add_index)
-      ActiveRecord::Migration.stub!(:create_table)
+      @connection = mock_migrator
+      @database_inserter.stub!(:connection).and_return(@connection)      
       
       # Stub the expected method calls for the preparation
       @database_inserter.stub!(:create_database_table)
       @database_inserter.stub!(:create_activerecord_class) 
 
-      
       # Make sure the ORM module exists
       @database_inserter.send(:initialize_orm_module!)
     end
 
     it "should create a requests table to join request lines" do
-      ActiveRecord::Migration.should_receive(:create_table).with("requests")
+      @connection.should_receive(:create_table).with("requests")
       @database_inserter.send :create_database_schema!
     end
         
@@ -153,7 +179,7 @@ describe RequestLogAnalyzer::Aggregator::Database do
     end
     
     it "should create a warnings table for logging parse warnings" do
-      ActiveRecord::Migration.should_receive(:create_table).with("warnings")
+      @connection.should_receive(:create_table).with("warnings")
       @database_inserter.send :create_database_schema!
     end
 

data/spec/unit/file_format/merb_format_spec.rb

@@ -23,15 +23,34 @@ describe RequestLogAnalyzer::Source::LogParser, :merb do
     @log_parser.parse_file(log_fixture(:merb))
   end
   
-  it "should parse all details from a request correctly" do
+  it "should parse all details from the first request correctly" do
     request = nil
     @log_parser.parse_file(log_fixture(:merb)) { |found_request| request ||= found_request }
     
     request.should be_completed
+    request[:controller].should == 'session'
+    request[:action].should == 'destroy'    
+    request[:method].should == 'delete'
+    request[:params].should be_kind_of(Hash)      
     request[:timestamp].should == 20080829111023 # 'Fri Aug 29 11:10:23 +0200 2008'
     request[:dispatch_time].should == 0.243424
     request[:after_filters_time].should == 6.9e-05
     request[:before_filters_time].should == 0.213213
     request[:action_time].should == 0.241652
+
+  end
+  
+  it "should parse a prefixed Merb file correctly" do
+    request = nil
+    @log_parser.parse_file(log_fixture(:merb_prefixed)) { |found_request| request ||= found_request }
+    
+    request.should be_completed
+    request[:timestamp].should == 20090831183525
+    request[:controller].should == 'home'
+    request[:action].should == 'index'
+    request[:dispatch_time].should == 0.012001
+    request[:after_filters_time].should == 0.0
+    request[:before_filters_time].should == 0.0
+    request[:action_time].should == 0.012001
   end
 end

data/spec/unit/source/request_spec.rb

@@ -1,85 +1,111 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe RequestLogAnalyzer::Request, :incomplete_request do
+describe RequestLogAnalyzer::Request do
   
   before(:each) do
-    @incomplete_request = testing_format.request
-    @incomplete_request << { :line_type => :test, :lineno => 1, :test_capture => 'awesome!' }
-  end
-  
-  it "should be single if only one line has been added" do
-    @incomplete_request.should_not be_empty
-  end
-  
-  it "should not be a completed request" do
-    @incomplete_request.should_not be_completed
+    @request = testing_format.request
   end  
   
-  it "should take the line type of the first line as global line_type" do
-    @incomplete_request.lines[0][:line_type].should == :test
-    @incomplete_request.should =~ :test
+  it "should be empty without any captured lines in it" do
+    @request.should be_empty
   end
   
-  it "should return the first field value" do
-    @incomplete_request[:test_capture].should == 'awesome!'
-  end
-  
-  it "should return nil if no such field is present" do
-    @incomplete_request[:nonexisting].should be_nil
-  end
-end  
-
-
-describe RequestLogAnalyzer::Request, :completed_request do
+  context :incomplete do
   
-  before(:each) do
-    @completed_request = testing_format.request
-    @completed_request << { :line_type => :first, :lineno =>  1, :name => 'first line!' }    
-    @completed_request << { :line_type => :test,  :lineno =>  4, :test_capture => 'testing' }        
-    @completed_request << { :line_type => :test,  :lineno =>  7, :test_capture => 'testing some more' }            
-    @completed_request << { :line_type => :last,  :lineno => 10, :time => 0.03 }
-  end
+    before(:each) do
+      @request << { :line_type => :test, :lineno => 1, :test_capture => 'awesome!' }
+    end
   
-  it "should not be empty when multiple liness are added" do
-    @completed_request.should_not be_empty
-  end
+    it "should be single if only one line has been added" do
+      @request.should_not be_empty
+    end
   
-  it "should be a completed request" do
-    @completed_request.should be_completed
-  end
+    it "should not be a completed request" do
+      @request.should_not be_completed
+    end  
   
-  it "should recognize all line types" do
-    [:first, :test, :last].each { |type| @completed_request.should =~ type }
-  end
+    it "should take the line type of the first line as global line_type" do
+      @request.lines[0][:line_type].should == :test
+      @request.should =~ :test
+    end
   
-  it "should detect the correct field value" do
-    @completed_request[:name].should == 'first line!'
-    @completed_request[:time].should == 0.03
-  end
+    it "should return the first field value" do
+      @request[:test_capture].should == 'awesome!'
+    end
   
-  it "should detect the first matching field value" do  
-    @completed_request.first(:test_capture).should == 'testing'
+    it "should return nil if no such field is present" do
+      @request[:nonexisting].should be_nil
+    end
   end
   
-  it "should detect the every matching field value" do  
-    @completed_request.every(:test_capture).should == ['testing', "testing some more"]
-  end
-  
-  it "should set the first_lineno for a request to the lowest lineno encountered" do
-    @completed_request.first_lineno.should eql(1)
-  end
+  context :completed do
+    
+    before(:each) do
+      @request << { :line_type => :first, :lineno =>  1, :name => 'first line!' }    
+      @request << { :line_type => :test,  :lineno =>  4, :test_capture => 'testing' }        
+      @request << { :line_type => :test,  :lineno =>  7, :test_capture => 'testing some more' }            
+      @request << { :line_type => :last,  :lineno => 10, :time => 0.03 }
+    end
 
-  it "should set the last_lineno for a request to the highest encountered lineno" do
-    @completed_request.last_lineno.should eql(10)
-  end
+    it "should not be empty when multiple liness are added" do
+      @request.should_not be_empty
+    end
 
-  it "should not have a timestamp if no such field is captured" do
-    @completed_request.timestamp.should be_nil
-  end
+    it "should be a completed request" do
+      @request.should be_completed
+    end
+
+    it "should recognize all line types" do
+      [:first, :test, :last].each { |type| @request.should =~ type }
+    end
+
+    it "should detect the correct field value" do
+      @request[:name].should == 'first line!'
+      @request[:time].should == 0.03
+    end
+
+    it "should detect the first matching field value" do  
+      @request.first(:test_capture).should == 'testing'
+    end
 
-  it "should set return a timestamp field if such a field is captured" do
-    @completed_request << { :line_type => :first, :lineno =>  1, :name => 'first line!', :timestamp => Time.now}    
-    @completed_request.timestamp.should_not be_nil
+    it "should detect the every matching field value" do  
+      @request.every(:test_capture).should == ['testing', "testing some more"]
+    end
+
+    it "should set the first_lineno for a request to the lowest lineno encountered" do
+      @request.first_lineno.should eql(1)
+    end
+    
+    it "should set the first_lineno for a request if a line with a lower lineno is added" do
+      @request << { :line_type => :test, :lineno =>  0 }          
+      @request.first_lineno.should eql(0)
+    end    
+
+    it "should set the last_lineno for a request to the highest encountered lineno" do
+      @request.last_lineno.should eql(10)
+    end
+    
+    it "should not set the last_lineno for a request if a line with a lower lineno is added" do
+      @request << { :line_type => :test, :lineno =>  7 }          
+      @request.last_lineno.should eql(10)
+    end
+
+    it "should not have a timestamp if no such field is captured" do
+      @request.timestamp.should be_nil
+    end
+
+    it "should set return a timestamp field if such a field is captured" do
+      @request << { :line_type => :first, :lineno =>  1, :name => 'first line!', :timestamp => Time.now}    
+      @request.timestamp.should_not be_nil
+    end    
   end
   
-end
+  context 'single line' do
+    # combined is both a header and a footer line
+    before(:each) { @request << { :line_type => :combined, :lineno => 1 } }
+  
+    it "should be a completed request if the line is both header and footer" do
+      @request.should be_completed
+    end   
+  end
+end