request-log-analyzer 1.3.4 → 1.4.0

data/spec/unit/file_format/rails_format_spec.rb

@@ -1,127 +1,167 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Rails do
-  
-  before(:each) do
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(
-          RequestLogAnalyzer::FileFormat.load(:rails), :parse_strategy => 'cautious')
-  end
-  
-  it "should have a valid language definitions" do
-    @log_parser.file_format.should be_valid
-  end
-  
-  it "should parse a stream and find valid requests" do
-    io = File.new(log_fixture(:rails_1x), 'r')
-    @log_parser.parse_io(io) do |request| 
-      request.should be_kind_of(RequestLogAnalyzer::Request)
-    end
-    io.close
-  end  
-  
-  it "should find 4 completed requests" do
-    @log_parser.should_not_receive(:warn)  
-    @log_parser.should_receive(:handle_request).exactly(4).times
-    @log_parser.parse_file(log_fixture(:rails_1x))
-  end  
-  
-  it "should parse a Rails 2.2 request properly" do
-    @log_parser.should_not_receive(:warn)
-    @log_parser.parse_file(log_fixture(:rails_22)) do |request|
-      request.should =~ :processing
-      request.should =~ :completed  
-    
-      request[:controller].should == 'PageController'
-      request[:action].should     == 'demo'
-      request[:url].should        == 'http://www.example.coml/demo'    
-      request[:status].should     == 200
-      request[:duration].should   == 0.614
-      request[:db].should         == 0.031
-      request[:view].should       == 0.120
+
+  describe '.create' do
+
+    context 'without providing a lines argument' do
+      before(:each) { @rails = RequestLogAnalyzer::FileFormat.load(:rails) }
+
+      it "should create a valid file format" do
+        @rails.should be_valid
+      end
+
+      it "should parse the production lines" do
+        production_rails = RequestLogAnalyzer::FileFormat.load(:rails, 'production')
+        @rails.line_definitions.should == production_rails.line_definitions
+      end
     end
-  end
-  
-  it "should parse a syslog file with prefix correctly" do
-    @log_parser.should_not_receive(:warn)    
-    @log_parser.parse_file(log_fixture(:syslog_1x)) do |request| 
-      
-      request.should be_completed
+
+    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
       
-      request[:controller].should == 'EmployeeController'
-      request[:action].should     == 'index'
-      request[:url].should        == 'http://example.com/employee.xml'    
-      request[:status].should     == 200
-      request[:duration].should   == 0.21665
-      request[:db].should         == 0.0
-      request[:view].should       == 0.00926
+      it "should at least parse :processing and :completed lines" do
+        @rails.line_definitions.should include(:processing, :completed, :failure)
+      end
     end
-  end
-  
-  it "should parse cached requests" do
-    @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
-    # No valid request should be found in cautious mode
-    @log_parser.should_not_receive(:handle_request)
-    # the first Processing-line will not give a warning, but the next one will
-    @log_parser.should_receive(:warn).with(:unclosed_request, anything).once
-    # Both Completed lines will give a warning
-    @log_parser.should_receive(:warn).with(:no_current_request, anything).twice
-    
-    @log_parser.parse_file(log_fixture(:rails_unordered))
-  end  
-end
 
-describe RequestLogAnalyzer::FileFormat::RailsDevelopment do
-  
-  before(:each) do
-    @file_format = RequestLogAnalyzer::FileFormat.load(:rails_development)
-    @request = @file_format.request
-  end
-  
-  it "should have a valid language definitions" do
-    @file_format.should be_valid
-  end
-  
-  it "should have a different line definer than Rails" do
-    rails = RequestLogAnalyzer::FileFormat.load(:rails)
-    rails.class.line_definer.should_not == @file_format.class.line_definer
+    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) }
+
+        it "should return a valid language" do
+          @rails.should be_valid
+        end
+
+        it "should at least parse :processing and :completed lines" do
+          @rails.line_definitions.should include(:processing, :completed)
+        end
+      end
+    end
   end
-  
-  it "should parse a rendered line" do
-    info = @file_format.line_definitions[:rendered].match_for("Rendered layouts/_footer (2.9ms)", @request)
-    info[:render_file].should == 'layouts/_footer'
-    info[:render_duration].should == 0.0029
+
+  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')
+        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')
+        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')
+        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")
+        end
+
+        it "should parse a :cache_hit line correctly" do
+          line = prefix + 'Filter chain halted as [#<ActionController::Caching::Actions::ActionCacheFilter:0x2a999ad620 @check=nil, @options={:store_options=>{}, :layout=>nil, :cache_path=>#<Proc:0x0000002a999b8890@/app/controllers/cached_controller.rb:8>}>] rendered_or_redirected.'
+          @rails.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'})
+        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)
+        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)')
+        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)')
+        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)')
+        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)')
+        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)
+        end
+      end
+    end
   end
-  
-  it "should parse a query executed line with colors" do
-    info = @file_format.line_definitions[:query_executed].match_for(" User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) ", @request)
-    info[:query_class].should == 'User'
-    info[:query_duration].should == 0.0004
-    info[:query_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'
-  end  
-  
-  it "should parse a query executed line without colors" do
-    info = @file_format.line_definitions[:query_executed].match_for(" User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) ", @request)
-    info[:query_class].should == 'User'
-    info[:query_duration].should == 0.0004
-    info[:query_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'
-  end  
-  
-  it "should parse a cached query line with colors" do
-    info = @file_format.line_definitions[:query_cached].match_for(' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) ', @request)
-    info[:cached_duration].should == 0.0
-    info[:cached_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'   
+
+  describe '#parse_io' do
+    before(:each) do
+      @log_parser = RequestLogAnalyzer::Source::LogParser.new(
+            RequestLogAnalyzer::FileFormat.load(:rails), :parse_strategy => 'cautious')
+    end
+
+    it "should parse a Rails 2.1 style log and find valid Rails requests without warnings" do
+      @log_parser.should_not_receive(:warn)
+      @log_parser.parse_file(log_fixture(:rails_1x)) do |request|
+        request.should be_kind_of(RequestLogAnalyzer::FileFormat::Rails::Request)
+        request.should be_completed
+      end
+    end
+
+    it "should parse a Rails 2.2 style log and find valid Rails requests without warnings" do
+      @log_parser.should_not_receive(:warn)
+      @log_parser.parse_file(log_fixture(:rails_22)) do |request|
+        request.should be_kind_of(RequestLogAnalyzer::FileFormat::Rails::Request)
+        request.should be_completed
+      end
+    end
+
+    it "should parse a Rails SyslogLogger file with prefix and find valid requests without warnings" do
+      @log_parser.should_not_receive(:warn)
+      @log_parser.parse_file(log_fixture(:syslog_1x)) do |request|
+        request.should be_kind_of(RequestLogAnalyzer::FileFormat::Rails::Request)
+        request.should be_completed
+      end
+    end
+
+    it "should find 4 completed requests" do
+      @log_parser.should_not_receive(:warn)
+      @log_parser.should_receive(:handle_request).exactly(4).times
+      @log_parser.parse_file(log_fixture(:rails_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|
+        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))
+    end
   end
-  
-  it "should parse a cached query line without colors" do
-    info = @file_format.line_definitions[:query_cached].match_for(' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) ', @request)
-    info[:cached_duration].should == 0.0
-    info[:cached_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'  
-  end  
-end
+end

data/spec/unit/filter/anonymize_filter_spec.rb

@@ -5,7 +5,7 @@ describe RequestLogAnalyzer::Filter::Anonymize, 'anonymize request' do
   before(:each) do
     @filter = RequestLogAnalyzer::Filter::Anonymize.new(testing_format)
   end
-  
+
   it "should anonimize ip" do
     @filter.filter(request(:ip => '123.123.123.123'))[:ip].should_not eql('123.123.123.123')
   end
@@ -17,5 +17,5 @@ describe RequestLogAnalyzer::Filter::Anonymize, 'anonymize request' do
   it "should fuzz durations" do
     @filter.filter(request(:duration => 100))[:duration].should_not eql(100)
   end
-  
+
 end

data/spec/unit/filter/field_filter_spec.rb

@@ -5,22 +5,22 @@ describe RequestLogAnalyzer::Filter::Field, 'string in accept mode' do
   before(:each) do
     @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => 'test', :mode => :select)
   end
-  
+
   it "should reject a request if the field value does not match" do
     @filter.filter(request(:test => 'not test')).should be_nil
   end
-  
+
   it "should reject a request if the field name does not match" do
     @filter.filter(request(:testing => 'test')).should be_nil
   end
 
   it "should accept a request if the both name and value match" do
     @filter.filter(request(:test => 'test')).should_not be_nil
-  end 
-    
+  end
+
   it "should accept a request if the value is not the first value" do
     @filter.filter(request([{:test => 'ignore'}, {:test => 'test'}])).should_not be_nil
-  end  
+  end
 end
 
 describe RequestLogAnalyzer::Filter::Field, 'string in reject mode' do
@@ -28,22 +28,22 @@ describe RequestLogAnalyzer::Filter::Field, 'string in reject mode' do
   before(:each) do
     @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => 'test', :mode => :reject)
   end
-  
+
   it "should accept a request if the field value does not match" do
     @filter.filter(request(:test => 'not test')).should_not be_nil
   end
-  
+
   it "should accept a request if the field name does not match" do
     @filter.filter(request(:testing => 'test')).should_not be_nil
   end
 
   it "should reject a request if the both name and value match" do
     @filter.filter(request(:test => 'test')).should be_nil
-  end 
-    
+  end
+
   it "should reject a request if the value is not the first value" do
     @filter.filter(request([{:test => 'ignore'}, {:test => 'test'}])).should be_nil
-  end  
+  end
 end
 
 describe RequestLogAnalyzer::Filter::Field, 'regexp in accept mode' do
@@ -51,16 +51,16 @@ describe RequestLogAnalyzer::Filter::Field, 'regexp in accept mode' do
   before(:each) do
     @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => '/test/', :mode => :select)
   end
-  
+
   it "should reject a request if the field value does not match" do
     @filter.filter(request(:test => 'a working test')).should_not be_nil
   end
-  
+
   it "should reject a request if the field name does not match" do
     @filter.filter(request(:testing => 'test')).should be_nil
   end
 
   it "should accept a request if the value is not the first value" do
     @filter.filter(request([{:test => 'ignore'}, {:test => 'testing 123'}])).should_not be_nil
-  end  
+  end
 end

data/spec/unit/filter/filter_spec.rb

@@ -5,7 +5,7 @@ describe RequestLogAnalyzer::Filter::Base, 'base filter' do
   before(:each) do
     @filter = RequestLogAnalyzer::Filter::Base.new(testing_format)
   end
-  
+
   it "should return everything" do
     @filter.filter(request(:ip => '123.123.123.123'))[:ip].should eql('123.123.123.123')
   end

data/spec/unit/filter/timespan_filter_spec.rb

@@ -5,54 +5,54 @@ describe RequestLogAnalyzer::Filter::Timespan, 'both before and after'  do
   before(:each) do
     @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :after => DateTime.parse('2009-01-01'), :before => DateTime.parse('2009-02-02'))
   end
-  
+
   it "should reject a request before the after date" do
     @filter.filter(request(:timestamp => 20081212000000)).should be_nil
   end
-  
+
   it "should reject a request after the before date" do
     @filter.filter(request(:timestamp => 20090303000000)).should be_nil
   end
-  
+
   it "should accept a request between the after and before dates" do
     @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
   end
 end
 
 describe RequestLogAnalyzer::Filter::Timespan, 'only before'  do
-  
+
   before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :before => DateTime.parse('2009-02-02'))    
+    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :before => DateTime.parse('2009-02-02'))
   end
-  
+
   it "should accept a request before the after date" do
     @filter.filter(request(:timestamp => 20081212000000)).should_not be_nil
   end
-  
+
   it "should reject a request after the before date" do
     @filter.filter(request(:timestamp => 20090303000000)).should be_nil
   end
-  
+
   it "should accept a request between the after and before dates" do
     @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
-  end   
+  end
 end
 
-describe RequestLogAnalyzer::Filter::Timespan, 'only after'  do  
-  
+describe RequestLogAnalyzer::Filter::Timespan, 'only after'  do
+
   before(:each) do
     @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :after => DateTime.parse('2009-01-01'))
   end
-  
+
   it "should reject a request before the after date" do
     @filter.filter(request(:timestamp => 20081212000000)).should be_nil
   end
-  
+
   it "should accept a request after the before date" do
     @filter.filter(request(:timestamp => 20090303000000)).should_not be_nil
   end
-  
+
   it "should accept a request between the after and before dates" do
     @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
-  end  
+  end
 end

data/spec/unit/mailer_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe RequestLogAnalyzer::Mailer, 'mailer' do
+
+  it "should store printed data" do
+    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', :debug => true)
+
+    @mailer << 'test1'
+    @mailer.puts 'test2'
+    
+    @mailer.data.should eql(['test1', 'test2'])
+  end
+
+  it "should send mail" do
+    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', :debug => true)
+
+    @mailer << 'test1'
+    @mailer.puts 'test2'
+
+    mail = @mailer.mail
+    
+    mail[0].should include("contact@railsdoctors.com")
+    mail[0].should include("test1")
+    mail[0].should include("test2")
+
+    mail[1].should include("contact@railsdoctors.com")
+    mail[2].should include("alfa@beta.com")
+  end
+
+end

data/spec/unit/{source/request_spec.rb → request_spec.rb}

@@ -1,49 +1,49 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../spec_helper'
 
 describe RequestLogAnalyzer::Request do
-  
+
   before(:each) do
     @request = testing_format.request
-  end  
-  
+  end
+
   it "should be empty without any captured lines in it" do
     @request.should be_empty
   end
-  
+
   context :incomplete do
-  
+
     before(:each) do
       @request << { :line_type => :test, :lineno => 1, :test_capture => 'awesome!' }
     end
-  
+
     it "should be single if only one line has been added" do
       @request.should_not be_empty
     end
-  
+
     it "should not be a completed request" do
       @request.should_not be_completed
-    end  
-  
+    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 return the first field value" do
       @request[:test_capture].should == 'awesome!'
     end
-  
+
     it "should return nil if no such field is present" do
       @request[:nonexisting].should be_nil
     end
   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 => :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
 
@@ -64,29 +64,29 @@ describe RequestLogAnalyzer::Request do
       @request[:time].should == 0.03
     end
 
-    it "should detect the first matching field value" do  
+    it "should detect the first matching field value" do
       @request.first(:test_capture).should == 'testing'
     end
 
-    it "should detect the every matching field value" do  
+    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 << { :line_type => :test, :lineno =>  0 }
       @request.first_lineno.should eql(0)
-    end    
+    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 << { :line_type => :test, :lineno =>  7 }
       @request.last_lineno.should eql(10)
     end
 
@@ -95,17 +95,17 @@ describe RequestLogAnalyzer::Request do
     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 << { :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
-end  
+end