ngmoco-request-log-analyzer 1.4.2

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/request_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe RequestLogAnalyzer::Request do
+
+  before(:each) do
+    @request = testing_format.request
+  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
+
+    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 => :last,  :lineno => 10, :time => 0.03 }
+    end
+
+    it "should not be empty when multiple liness are added" do
+      @request.should_not be_empty
+    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 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
+
+  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

data/spec/unit/source/log_parser_spec.rb

@@ -0,0 +1,119 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Source::LogParser, :requests do
+
+  before(:each) do
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format)
+  end
+
+  it "should have multiple line definitions" do
+    @log_parser.file_format.line_definitions.length.should >= 2
+  end
+
+  it "should have a valid language" do
+    @log_parser.file_format.should be_valid
+  end
+
+  it "should set the :source for every parsed line" do
+    @log_parser.parse_file(log_fixture(:rails_22)) do |request|
+      request.lines.all? { |line| line[:source] == log_fixture(:rails_22) }.should be_true
+    end
+  end
+
+  it "should set the :lineno for every parsed line" do
+    @log_parser.parse_file(log_fixture(:rails_22)) do |request|
+      request.lines.all? { |line| line.has_key?(:lineno) }.should be_true
+    end
+  end
+
+  it "should parse more lines than requests" do
+    @log_parser.should_receive(:handle_request).with(an_instance_of(TestingFormat::Request)).twice
+    @log_parser.parse_file(log_fixture(:test_language_combined))
+    @log_parser.parsed_lines.should > 2
+  end
+
+  it "should parse requests spanned over multiple files" do
+    @log_parser.should_receive(:handle_request).with(an_instance_of(TestingFormat::Request)).once
+    @log_parser.parse_files([log_fixture(:multiple_files_1), log_fixture(:multiple_files_2)])
+  end
+
+  it "should parse all request values when spanned over multiple files" do
+    @log_parser.parse_files([log_fixture(:multiple_files_1), log_fixture(:multiple_files_2)]) do |request|
+      request.lines.should have(4).items
+      request[:request_no].should == 1
+      request[:test_capture].should == "Testing is amazing" # Note the custom converter
+    end
+  end
+
+  it "should parse a stream and find valid requests" do
+    io = File.new(log_fixture(:test_file_format), 'r')
+    @log_parser.parse_io(io) do |request|
+      request.should be_kind_of(RequestLogAnalyzer::Request)
+      request.should =~ :test
+      request[:test_capture].should_not be_nil
+    end
+    io.close
+  end
+
+  it "should parse a request that only consists of one line" do
+    @log_parser.parse_file(log_fixture(:header_and_footer))
+    @log_parser.parsed_requests.should == 2
+  end
+end
+
+describe RequestLogAnalyzer::Source::LogParser, :warnings do
+
+  before(:each) do
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format, :parse_strategy => 'cautious')
+  end
+
+  it "should warn about teaser matching problems" do
+    @log_parser.should_receive(:warn).with(:teaser_check_failed, anything).exactly(5).times
+    @log_parser.parse_file(log_fixture(:test_file_format))
+  end
+
+  it "should warn about unmatching request headers and footers" do
+    @log_parser.should_receive(:warn).with(:unclosed_request, anything).at_least(1).times
+    @log_parser.should_receive(:warn).with(:no_current_request, anything).at_least(1).times
+    @log_parser.should_not_receive(:handle_request)
+    @log_parser.parse_file(log_fixture(:test_order))
+  end
+end
+
+describe RequestLogAnalyzer::Source::LogParser, :decompression do
+
+  before(:each) do
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat::Rails.create)
+  end
+
+  it "should parse a rails gzipped log file" do
+    @log_parser.should_receive(:handle_request).once
+    @log_parser.parse_file(log_fixture(:decompression, "log.gz"))
+    @log_parser.parsed_lines.should > 0
+  end
+
+  it "should parse a rails tar gzipped log folder" do
+    @log_parser.should_receive(:handle_request).twice
+    @log_parser.parse_file(log_fixture(:decompression, "tar.gz"))
+    @log_parser.parsed_lines.should > 1
+  end
+
+  it "should parse a rails tar gzipped log folder" do
+    @log_parser.should_receive(:handle_request).twice
+    @log_parser.parse_file(log_fixture(:decompression, "tgz"))
+    @log_parser.parsed_lines.should > 1
+  end
+
+  it "should parse a rails bz2 zipped log file" do
+    @log_parser.should_receive(:handle_request).once
+    @log_parser.parse_file(log_fixture(:decompression, "log.bz2"))
+    @log_parser.parsed_lines.should > 0
+  end
+
+  it "should parse a rails zipped log file" do
+    @log_parser.should_receive(:handle_request).once
+    @log_parser.parse_file(log_fixture(:decompression, "log.zip"))
+    @log_parser.parsed_lines.should > 0
+  end
+
+end

data/spec/unit/tracker/duration_tracker_spec.rb

@@ -0,0 +1,130 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Tracker::Duration do
+
+  context 'using a static category' do
+
+    before(:each) do
+      @tracker = RequestLogAnalyzer::Tracker::Duration.new(:duration => :duration, :category => :category)
+      @tracker.prepare
+    end
+
+    it "should create a category for every request using the category field" do
+      @tracker.update(request(:category => 'a', :duration => 0.2))
+      @tracker.categories.keys.should include('a')
+    end
+
+    it "should register a request as hit in the right category" do
+      @tracker.update(request(:category => 'a', :duration => 0.2))
+      @tracker.update(request(:category => 'b', :duration => 0.3))
+      @tracker.update(request(:category => 'b', :duration => 0.4))
+
+      @tracker.hits('a').should == 1
+      @tracker.hits('b').should == 2
+    end
+  end
+
+  context 'using a dynamic category' do
+    before(:each) do
+      @categorizer = Proc.new { |request| request[:duration] > 0.2 ? 'slow' : 'fast' }
+      @tracker = RequestLogAnalyzer::Tracker::Duration.new(:duration => :duration, :category => @categorizer)
+      @tracker.prepare
+    end
+
+    it "should use the categorizer to determine the right category" do
+      @tracker.update(request(:category => 'a', :duration => 0.2))
+      @tracker.update(request(:category => 'b', :duration => 0.3))
+      @tracker.update(request(:category => 'b', :duration => 0.4))
+
+      @tracker.hits('fast').should == 1
+      @tracker.hits('slow').should == 2
+    end
+  end
+
+  describe '#update' do
+
+    before(:each) do
+      @tracker = RequestLogAnalyzer::Tracker::Duration.new(:duration => :duration, :category => :category)
+      @tracker.prepare
+
+      @tracker.update(request(:category => 'a', :duration => 0.4))
+      @tracker.update(request(:category => 'a', :duration => 0.2))
+      @tracker.update(request(:category => 'a', :duration => 0.3))
+    end
+
+    it "should sum of the durations for a category correctly" do
+      @tracker.sum('a').should be_close(0.9, 0.000001)
+    end
+
+    it "should overall sum of the durations correctly" do
+      @tracker.sum_overall.should be_close(0.9, 0.000001)
+    end
+
+    it "should keep track of the minimum and maximum duration" do
+      @tracker.min('a').should == 0.2
+      @tracker.max('a').should == 0.4
+    end
+
+    it "should calculate the mean duration correctly" do
+      @tracker.mean('a').should be_close(0.3, 0.000001)
+    end
+
+    it "should calculate the overall mean duration correctly" do
+      @tracker.mean_overall.should be_close(0.3, 0.000001)
+    end
+
+    it "should calculate the duration variance correctly" do
+      @tracker.variance('a').should be_close(0.01, 0.000001)
+    end
+
+    it "should calculate the duration standard deviation correctly" do
+      @tracker.stddev('a').should be_close(0.1,  0.000001)
+    end
+  end
+
+  describe '#report' do
+
+    before(:each) do
+      @tracker = RequestLogAnalyzer::Tracker::Duration.new(:category => :category, :duration => :duration)
+      @tracker.prepare
+    end
+
+    it "should generate a report without errors when one category is present" do
+      @tracker.update(request(:category => 'a', :duration => 0.2))
+      lambda { @tracker.report(mock_output) }.should_not raise_error
+    end
+
+    it "should generate a report without errors when no category is present" do
+      lambda { @tracker.report(mock_output) }.should_not raise_error
+    end
+
+    it "should generate a report without errors when multiple categories are present" do
+      @tracker.update(request(:category => 'a', :duration => 0.2))
+      @tracker.update(request(:category => 'b', :duration => 0.2))
+      lambda { @tracker.report(mock_output) }.should_not raise_error
+    end
+
+    it "should generate a YAML output" do
+      @tracker.update(request(:category => 'a', :duration => 0.2))
+      @tracker.update(request(:category => 'b', :duration => 0.2))
+      @tracker.to_yaml_object.should == {"a"=>{:hits=>1, :min=>0.2, :mean=>0.2, :max=>0.2, :sum_of_squares=>0.0, :sum=>0.2}, "b"=>{:hits=>1, :min=>0.2, :mean=>0.2, :max=>0.2, :sum_of_squares=>0.0, :sum=>0.2}}
+    end
+  end
+  
+  describe '#display_value' do
+    before(:each) { @tracker = RequestLogAnalyzer::Tracker::Duration.new(:category => :category, :duration => :duration) }
+    
+    it "should only display seconds when time < 60" do
+      @tracker.display_value(33.12).should == '33.12s'
+    end
+
+    it "should display minutes and wholeseconds when time > 60" do
+      @tracker.display_value(63.12).should == '1m03s'
+    end
+
+    it "should display minutes and wholeseconds when time > 60" do
+      @tracker.display_value(3601.12).should == '1h00m01s'
+    end
+
+  end
+end

data/spec/unit/tracker/frequency_tracker_spec.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Tracker::Frequency do
+
+  context 'static category' do
+    before(:each) do
+      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => :category)
+      @tracker.prepare
+    end
+
+    it "should register a request in the right category" do
+      @tracker.update(request(:category => 'a', :blah => 0.2))
+      @tracker.categories.should include('a')
+    end
+
+    it "should register a request in the right category" do
+      @tracker.update(request(:category => 'a', :blah => 0.2))
+      @tracker.update(request(:category => 'b', :blah => 0.2))
+      @tracker.update(request(:category => 'b', :blah => 0.2))
+
+      @tracker.frequency('a').should == 1
+      @tracker.frequency('b').should == 2
+      @tracker.overall_frequency.should == 3
+    end
+
+    it "should sort correctly by frequency" do
+      @tracker.update(request(:category => 'a', :blah => 0.2))
+      @tracker.update(request(:category => 'b', :blah => 0.2))
+      @tracker.update(request(:category => 'b', :blah => 0.2))
+
+      @tracker.sorted_by_frequency.should == [['b', 2], ['a', 1]]
+    end
+  end
+  
+
+  context 'dynamic category' do
+    before(:each) do
+      @categorizer = Proc.new { |request| request[:duration] > 0.2 ? 'slow' : 'fast' }
+      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => @categorizer)
+      @tracker.prepare
+    end
+
+    it "should use the categorizer to determine the right category" do
+      @tracker.update(request(:category => 'a', :duration => 0.2))
+      @tracker.update(request(:category => 'b', :duration => 0.3))
+      @tracker.update(request(:category => 'b', :duration => 0.4))
+
+      @tracker.frequency('fast').should == 1
+      @tracker.frequency('slow').should == 2
+      @tracker.frequency('moderate').should == 0
+    end
+  end
+
+  describe '#report' do
+    before(:each) do
+      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => :category)
+      @tracker.prepare
+    end
+
+    it "should generate a report without errors when one category is present" do
+      @tracker.update(request(:category => 'a', :blah => 0.2))
+      lambda { @tracker.report(mock_output) }.should_not raise_error
+    end
+
+    it "should generate a report without errors when no category is present" do
+      lambda { @tracker.report(mock_output) }.should_not raise_error
+    end
+
+    it "should generate a report without errors when multiple categories are present" do
+      @tracker.update(request(:category => 'a', :blah => 0.2))
+      @tracker.update(request(:category => 'b', :blah => 0.2))
+      lambda { @tracker.report(mock_output) }.should_not raise_error
+    end
+  end
+
+  describe '#to_yaml_object' do
+    before(:each) do
+      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => :category)
+      @tracker.prepare
+    end
+
+    it "should generate a YAML output" do
+      @tracker.update(request(:category => 'a', :blah => 0.2))
+      @tracker.update(request(:category => 'b', :blah => 0.2))
+      @tracker.to_yaml_object.should == { "a" => 1, "b" => 1 }
+    end
+  end
+end