request-log-analyzer 1.2.7 → 1.2.8

data/Rakefile

@@ -1,5 +1,8 @@
 Dir[File.dirname(__FILE__) + "/tasks/*.rake"].each { |file| load(file) }
 
+# Create rake tasks for a gem manages by github. The tasks are created in the
+# gem namespace
 GithubGem::RakeTasks.new(:gem)
- 
-task :default => "spec:specdoc"
+
+# Set the RSpec runner with specdoc output as default task.
+task :default => "spec:specdoc"

data/bin/request-log-analyzer

@@ -21,6 +21,8 @@ begin
     end
     
     command_line.option(:format, :alias => :f, :default => 'rails')
+    command_line.option(:apache_format)
+    
     command_line.option(:file, :alias => :e)
     command_line.option(:parse_strategy, :default => 'assume-correct')
     command_line.option(:dump)

data/lib/request_log_analyzer/aggregator/database.rb

@@ -143,10 +143,10 @@ module RequestLogAnalyzer::Aggregator
       
       orm_module.const_set(class_name, klass) unless orm_module.const_defined?(class_name)
       request_class.send(:has_many, "#{definition.name}_lines".to_sym)
-    end    
-    
-    # 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.
+    end
+
+    # Creates a requests table, in which a record is created for every parsed request. 
+    # It also creates an ActiveRecord::Base class to communicate with this table.
     def create_request_table_and_class
       connection.create_table("requests") do |t|
         t.column :first_lineno, :integer
@@ -157,6 +157,19 @@ module RequestLogAnalyzer::Aggregator
       @request_class = orm_module.const_get('Request')
     end
 
+    # Creates a sources table, in which a record is created for every file that is parsed. 
+    # It also creates an ActiveRecord::Base ORM class for the table.
+    def create_source_table_and_class
+      connection.create_table('sources') do |t|
+        t.column :filename, :string
+        t.column :mtime,    :datetime
+        t.column :filesize, :integer
+      end
+      
+      orm_module.const_set('Source', Class.new(orm_module::Base)) unless orm_module.const_defined?('Source')
+      @source_class = orm_module.const_get('Source')      
+    end
+
     # Creates a warnings table and a corresponding Warning class to communicate with this table using ActiveRecord.
     def create_warning_table_and_class
       connection.create_table("warnings") do |t|
@@ -172,6 +185,7 @@ module RequestLogAnalyzer::Aggregator
     # Creates the database schema and related ActiveRecord::Base subclasses that correspond to the 
     # file format definition. These ORM classes will later be used to create records in the database.
     def create_database_schema!
+      create_source_table_and_class
       create_request_table_and_class
       create_warning_table_and_class
       

data/lib/request_log_analyzer/aggregator/summarizer.rb

@@ -24,7 +24,7 @@ module RequestLogAnalyzer::Aggregator
       
       # Include missing trackers through method missing.
       def method_missing(tracker_method, *args)
-        track(tracker_method, args.first)
+        track(tracker_method, *args)
       end
       
       # Track the frequency of a specific category

data/lib/request_log_analyzer/controller.rb

@@ -46,7 +46,11 @@ module RequestLogAnalyzer
       end
                 
       # Create the controller with the correct file format
-      file_format = RequestLogAnalyzer::FileFormat.load(arguments[:format])
+      file_format = if arguments[:apache_format]
+          RequestLogAnalyzer::FileFormat.load(:apache, arguments[:apache_format])
+        else 
+          RequestLogAnalyzer::FileFormat.load(arguments[:format])
+        end
 
       # register sources
       if arguments.parameters.length == 1

data/lib/request_log_analyzer/file_format/apache.rb

@@ -8,28 +8,69 @@ module RequestLogAnalyzer::FileFormat
   
   class Apache < Base
 
-    # 125.76.230.10 - - [02/Sep/2009:03:33:46 +0200] "GET /cart/install.txt HTTP/1.1" 404 214 "-" "Toata dragostea mea pentru diavola"
-    line_definition :access do |line|
-      line.header = true
-      line.footer = true
-      line.regexp = /(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}) - - \[([^\]]{26})\] "([A-Z]+) ([^\s]+) HTTP\/(\d+(?:\.\d+)*)" (\d+) \d+ "-" "([^"]+)"/
-      line.captures << { :name => :ip_address,   :type => :string } \
-                    << { :name => :timestamp,    :type => :timestamp } \
-                    << { :name => :method,       :type => :string } \
-                    << { :name => :path,         :type => :string } \
-                    << { :name => :http_version, :type => :string } \
-                    << { :name => :status,       :type => :integer } \
-                    << { :name => :user_agent,   :type => :string }
-    end    
-
-    
-    report do |analyze|
-      analyze.timespan :line_type => :access
-      analyze.hourly_spread :line_type => :access
-      analyze.frequency :category => :method, :amount => 20, :title => "HTTP methods frequency"
-      analyze.frequency :category => :path,   :amount => 20, :title => "Most popular paths"
+    # A hash of predefined Apache log format strings
+    LOG_FORMAT_DEFAULTS = {
+      :common   => '%h %l %u %t "%r" %>s %b',
+      :combined => '%h %l %u %t "%r" %>s %b "%{Referer}i" "%{User-agent}i"'
+    }
+
+    # A hash that defines how the log format directives should be parsed.
+    LOG_DIRECTIVES = {
+      'h' => { :regexp => '(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})', :captures => [{:name => :ip_address, :type => :string}] },
+      't' => { :regexp => '\[([^\]]{26})\]', :captures => [{:name => :timestamp, :type => :timestamp}] },
+      's' => { :regexp => '(\d{3})', :captures => [{:name => :http_status, :type => :integer}] },
+      'r' => { :regexp => '([A-Z]+) ([^\s]+) HTTP\/(\d+(?:\.\d+)*)', :captures => [{:name => :http_method, :type => :string},
+                       {:name => :path, :type => :string}, {:name => :http_version, :type => :string}]}
+    }
+
+    # Creates the Apache log format language based on a Apache log format string.
+    # It will set up the line definition and the report trackers according to the Apache access log format,
+    # which should be passed as first argument. By default, is uses the 'combined' log format.
+    def self.create(*args)
+      access_line =  access_line_definition(args.first)
+      self.new({ :access => access_line}, report_trackers(access_line))
     end
-  
+
+    # Creates the access log line definition based on the Apache log format string
+    def self.access_line_definition(format_string)
+      format_string ||= :combined
+      format_string   = LOG_FORMAT_DEFAULTS[format_string.to_sym] || format_string
+
+      line_regexp = ''
+      captures    = []
+      format_string.scan(/([^%]*)(?:%(?:\{([^\}]+)\})?>?([A-Za-z]))?/) do |literal, arg, variable|
+
+        line_regexp << Regexp.quote(literal) # Make sure to parse the literal before the directive
+        if variable
+          # Check if we recognize the log directive
+          if directive = LOG_DIRECTIVES[variable]
+            line_regexp << directive[:regexp]   # Parse the value of the directive
+            captures    += directive[:captures] # Add the directive's information to the captures
+          else
+            line_regexp << '.*' # Just accept any input for this literal
+          end
+        end
+      end
+      
+      # Return a new line definition object
+      return RequestLogAnalyzer::LineDefinition.new(:access, :regexp => Regexp.new(line_regexp),
+                                        :captures => captures, :header => true, :footer => true)
+    end
+
+    # Sets up the report trackers according to the access line definition.
+    def self.report_trackers(line_definition)
+      analyze = RequestLogAnalyzer::Aggregator::Summarizer::Definer.new
+
+      analyze.timespan      if line_definition.captures?(:timestamp)
+      analyze.hourly_spread if line_definition.captures?(:timestamp)
+
+      analyze.frequency :category => :http_method, :amount => 20, :title => "HTTP methods"  if line_definition.captures?(:http_method)
+      analyze.frequency :category => :http_status, :amount => 20, :title => "HTTP statuses" if line_definition.captures?(:http_status)
+      analyze.frequency :category => :path, :amount => 20, :title => "Most popular URIs"    if line_definition.captures?(:path)
+
+      return analyze.trackers
+    end
+
     # Define a custom Request class for the Apache file format to speed up timestamp handling.
     class Request < RequestLogAnalyzer::Request
       

data/lib/request_log_analyzer/file_format.rb

@@ -10,7 +10,7 @@ module RequestLogAnalyzer::FileFormat
   # * A FileFormat class (of which an imstance will be returned)
   # * A filename (from which the FileFormat class is loaded)
   # * A symbol of a built-in file format (e.g. :rails)
-  def self.load(file_format)
+  def self.load(file_format, *args)
     klass = nil
     if file_format.kind_of?(RequestLogAnalyzer::FileFormat::Base)
       # this already is a file format! return itself
@@ -41,7 +41,7 @@ module RequestLogAnalyzer::FileFormat
     raise "Could not load a file format from #{file_format.inspect}" if klass.nil?
     raise "Invalid FileFormat class" unless klass.kind_of?(Class) && klass.ancestors.include?(RequestLogAnalyzer::FileFormat::Base)
     
-    @current_file_format = klass.new # return an instance of the class
+    @current_file_format = klass.create(*args) # return an instance of the class
   end  
   
   # Makes classes aware of a file format by registering the file_format variable
@@ -62,11 +62,17 @@ module RequestLogAnalyzer::FileFormat
   # A subclass of this class is instantiated when request-log-analyzer is started and this instance
   # is shared with all components of the application so they can act on the specifics of the format
   class Base
-      
+    
+    attr_reader :line_definitions, :report_trackers
+    
+    ####################################################################################
+    # CLASS METHODS for format definition
+    ####################################################################################
+    
     # Registers the line definer instance for a subclass.
     def self.inherited(subclass)
       if subclass.superclass == RequestLogAnalyzer::FileFormat::Base
-        
+
         # Create aline and report definer for this class
         subclass.class_eval do 
           instance_variable_set(:@line_definer, RequestLogAnalyzer::LineDefinition::Definer.new)
@@ -77,32 +83,24 @@ module RequestLogAnalyzer::FileFormat
         # Create a custom Request class for this file format
         subclass.const_set('Request', Class.new(RequestLogAnalyzer::Request)) unless subclass.const_defined?('Request')
       else
-        
+
         # Copy the line and report definer from the parent class.
         subclass.class_eval do 
           instance_variable_set(:@line_definer, superclass.line_definer.clone)
           instance_variable_set(:@report_definer, superclass.report_definer.clone)
           class << self; attr_accessor :line_definer, :report_definer; end
-        end        
-        
+        end
+
         # Create a custom Request class based on the superclass's Request class
         subclass.const_set('Request', Class.new(subclass.superclass::Request)) unless subclass.const_defined?('Request')
       end
-    end    
-    
+    end
+
     # Specifies a single line defintions.
     def self.line_definition(name, &block)
       @line_definer.send(name, &block)
     end
-    
-    def request_class
-      self.class::Request
-    end
-    
-    def request(*hashes)
-      request_class.create(self, *hashes)
-    end
-    
+
     # Specifies multiple line definitions at once using a block
     def self.format_definition(&block)
       if block_given?
@@ -111,36 +109,61 @@ module RequestLogAnalyzer::FileFormat
         return self.line_definer
       end
     end
-    
+
     # Specifies the summary report using a block.
     def self.report(mode = :append, &block)
-      if mode == :overwrite
-        self.report_definer.reset!
-      end
-      
+      self.report_definer.reset! if mode == :overwrite
       yield(self.report_definer)
     end
 
-    # Returns all line definitions
-    def line_definitions
-      @line_definitions ||= self.class.line_definer.line_definitions
+    ####################################################################################
+    # Instantiation
+    ####################################################################################
+
+    def self.create(*args)
+      # Ignore arguments
+      return self.new(line_definer.line_definitions, report_definer.trackers)
     end
-    
-    # Returns all the defined trackers for the summary report.
-    def report_trackers
-      self.class.report_definer.trackers# =>  rescue []
+
+    def initialize(line_definitions = [], report_trackers = [])
+      @line_definitions, @report_trackers = line_definitions, report_trackers
     end
-    
+
+    ####################################################################################
+    # INSTANCE methods
+    ####################################################################################
+
+    # Returns the Request class of this file format
+    def request_class
+      self.class::Request
+    end
+
+    # Returns a Request instance with the given parsed lines that should be provided as hashes.
+    def request(*hashes)
+      request_class.create(self, *hashes)
+    end
+
     # Checks whether the line definitions form a valid language.
     # A file format should have at least a header and a footer line type
     def valid?
-      line_definitions.detect { |(name, ld)| ld.header } && line_definitions.detect { |(name, ld)| ld.footer }
+      line_definitions.any? { |(name, ld)| ld.header } && line_definitions.any? { |(name, ld)| ld.footer }
     end
-    
+
+    # Returns true if this language captures the given symbol in one of its line definitions
+    def captures?(name)
+      line_definitions.any? { |(name, ld)| ld.captures?(name) }
+    end
+
     # Function that a file format con implement to monkey patch the environment.
     # * <tt>controller</tt> The environment is provided as a controller instance
     def setup_environment(controller)
-      
+    end
+
+    # Parses a line by trying to parse it using every line definition in this file format
+    def parse_line(line, &warning_handler)
+      request_data = nil
+      self.line_definitions.any? { |lt, definition| request_data = definition.matches(line, &warning_handler) }
+      return request_data
     end
   end
 end

data/lib/request_log_analyzer/line_definition.rb

@@ -30,6 +30,9 @@ module RequestLogAnalyzer
     attr_accessor :teaser, :regexp, :captures
     attr_accessor :header, :footer
     
+    alias_method :header?, :header
+    alias_method :footer?, :footer
+    
     # Initializes the LineDefinition instance with a hash containing the different elements of
     # the definition.
     def initialize(name, definition = {})
@@ -49,13 +52,13 @@ module RequestLogAnalyzer
     # with all the fields parsed from that line as content.
     # If the line definition has a teaser-check, a :teaser_check_failed warning will be emitted
     # if this teaser-check is passed, but the full regular exprssion does not ,atch.
-    def matches(line, lineno = nil, parser = nil)
+    def matches(line, &warning_handler)
       if @teaser.nil? || @teaser =~ line
         if match_data = line.match(@regexp)
-          return { :line_definition => self, :lineno => lineno, :captures => match_data.captures}
+          return { :line_definition => self, :captures => match_data.captures}
         else
-          if @teaser && parser
-            parser.warn(:teaser_check_failed, "Teaser matched for #{name.inspect}, but full line did not:\n#{line.inspect}")
+          if @teaser && warning_handler
+            warning_handler.call(:teaser_check_failed, "Teaser matched for #{name.inspect}, but full line did not:\n#{line.inspect}")
           end
           return false
         end
@@ -68,8 +71,8 @@ module RequestLogAnalyzer
 
     # matches the line and converts the captured values using the request's
     # convert_value function.
-    def match_for(line, request, lineno = nil, parser = nil)
-      if match_info = matches(line, lineno, parser)
+    def match_for(line, request, &warning_handler)
+      if match_info = matches(line, &warning_handler)
         convert_captured_values(match_info[:captures], request)
       else
         false
@@ -97,6 +100,11 @@ module RequestLogAnalyzer
       return value_hash
     end
 
+    # Returns true if this line captures values of the given name
+    def captures?(name)
+      captures.any? { |c| c[:name] == name }
+    end
+
   end
   
 end

data/lib/request_log_analyzer/source/log_parser.rb

@@ -17,7 +17,7 @@ module RequestLogAnalyzer::Source
     # All available parse strategies.
     PARSE_STRATEGIES = ['cautious', 'assume-correct']
 
-    attr_reader :source_files
+    attr_reader :source_files, :current_file, :current_lineno
 
     # Initializes the log file parser instance.
     # It will apply the language specific FileFormat module to this instance. It will use the line
@@ -32,7 +32,8 @@ module RequestLogAnalyzer::Source
       @parsed_requests  = 0
       @skipped_lines    = 0
       @skipped_requests = 0
-      @current_io       = nil
+      @current_file     = nil
+      @current_lineno   = nil
       @source_files     = options[:source_files]
       
       @options[:parse_strategy] ||= DEFAULT_PARSE_STRATEGY
@@ -124,27 +125,21 @@ module RequestLogAnalyzer::Source
     # <tt>options</tt>:: A hash of options that can be used by the parser.
     def parse_io(io, options = {}, &block) # :yields: request
 
-      @current_io = io
-      lineno = 0
-      @current_io.each_line do |line|
-        @progress_handler.call(:progress, @current_io.pos) if @progress_handler && @current_io.kind_of?(File)
+      @current_lineno = 0
+      io.each_line do |line|
+        @progress_handler.call(:progress, io.pos) if @progress_handler && io.kind_of?(File)
 
-        request_data = nil
-        file_format.line_definitions.each do |line_type, definition|
-          request_data = definition.matches(line, lineno, self)
-          break if request_data
-        end
-        
-        if request_data
+        if request_data = file_format.parse_line(line) { |wt, message| warn(wt, message) }
           @parsed_lines += 1
-          update_current_request(request_data, &block)
+          update_current_request(request_data.merge(:lineno => @current_lineno), &block)
         end
-        lineno += 1
+        
+        @current_lineno += 1
       end
 
       warn(:unfinished_request_on_eof, "End of file reached, but last request was not completed!") unless @current_request.nil?
 
-      @current_io = nil
+      @current_lineno = nil
     end
 
     # Add a block to this method to install a progress handler while parsing.
@@ -169,7 +164,7 @@ module RequestLogAnalyzer::Source
     # <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
+      @warning_handler.call(type, message, @current_lineno) if @warning_handler
     end
 
     protected

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.7"
+  VERSION = "1.2.8"
   
   # 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/request-log-analyzer.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name    = 'request-log-analyzer'
-  s.version = "1.2.7"
-  s.date    = "2009-09-02"
+  s.version = "1.2.8"
+  s.date    = "2009-09-08"
   
   s.rubyforge_project = 'r-l-a'
   

data/spec/integration/command_line_usage_spec.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 
 describe RequestLogAnalyzer, 'running from command line' do
-  
+
   before(:each) do
     cleanup_temp_files!
   end
@@ -10,27 +10,27 @@ describe RequestLogAnalyzer, 'running from command line' do
     cleanup_temp_files!
   end
 
-  it "should find 4 requests in default mode" do  
+  it "should find 4 requests in default mode" do
     output = run("#{log_fixture(:rails_1x)}")
     output.detect { |line| /Parsed requests\:\s*4/ =~ line }.should_not be_nil
   end
 
-  it "should find 3 requests with a --select option" do  
+  it "should find 3 requests with a --select option" do
     output = run("#{log_fixture(:rails_1x)} --select controller PeopleController")
     output.detect { |line| /Parsed requests\:\s*4/ =~ line }.should_not be_nil
   end
 
-  it "should find 1 requests with a --reject option" do  
+  it "should find 1 requests with a --reject option" do
     output = run("#{log_fixture(:rails_1x)} --reject controller PeopleController")
     output.detect { |line| /Parsed requests\:\s*4/ =~ line }.should_not be_nil
   end
-  
-  it "should write output to a file with the --file option" do  
+
+  it "should write output to a file with the --file option" do
     run("#{log_fixture(:rails_1x)} --file #{temp_output_file(:report)}")
     File.exist?(temp_output_file(:report)).should be_true
   end
 
-  it "should write only ASCII characters to a file with the --file option" do  
+  it "should write only ASCII characters to a file with the --file option" do
     run("#{log_fixture(:rails_1x)} --file #{temp_output_file(:report)}")
     /^[\x00-\x7F]*$/.match(File.read(temp_output_file(:report))).should_not be_nil
   end
@@ -39,31 +39,35 @@ describe RequestLogAnalyzer, 'running from command line' do
     output = run("#{log_fixture(:rails_1x)} --output HTML")
     output.any? { |line| /<html.*>/ =~ line}
   end
-  
-  it "should run with the --database option" do  
+
+  it "should run with the --database option" do
     run("#{log_fixture(:rails_1x)} --database #{temp_output_file(:database)}")
     File.exist?(temp_output_file(:database)).should be_true
   end
 
-  it "should use no colors in the report with the --boring option" do  
+  it "should use no colors in the report with the --boring option" do
     output = run("#{log_fixture(:rails_1x)} --boring")
     output.any? { |line| /\e/ =~ line }.should be_false
   end
-  
-  it "should use only ASCII characters in the report with the --boring option" do  
+
+  it "should use only ASCII characters in the report with the --boring option" do
     output = run("#{log_fixture(:rails_1x)} --boring")
     output.all? { |line| /^[\x00-\x7F]*$/ =~ line }.should be_true
   end
-  
-  it "should parse a Merb file if --format merb is set" do  
+
+  it "should parse a Merb file if --apache-format is set" do
     output = run("#{log_fixture(:merb)} --format merb")
-    output.detect { |line| /Parsed requests\:\s*11/ =~ line }.should_not be_nil   
-  end  
-  
+    output.detect { |line| /Parsed requests\:\s*11/ =~ line }.should_not be_nil
+  end
+
+  it "should parse a Apache access log file if --format merb is set" do
+    output = run("#{log_fixture(:apache)} --apache-format combined")
+    output.detect { |line| /Parsed requests\:\s*5/ =~ line }.should_not be_nil
+  end
+
   it "should dump the results to a YAML file" do
     run("#{log_fixture(:rails_1x)} --dump #{temp_output_file(:dump)}")
     File.exist?(temp_output_file(:dump)).should be_true
     YAML::load(File.read(temp_output_file(:dump))).should have_at_least(1).item
-  end
-  
-end
+  end  
+end

data/spec/lib/helpers.rb

@@ -2,7 +2,7 @@ module RequestLogAnalyzer::Spec::Helpers
   
   # Create or return a new TestingFormat
   def testing_format
-    @testing_format ||= TestingFormat.new
+    @testing_format ||= TestingFormat.create
   end
   
   # Load a log file from the fixture folder

data/spec/lib/matchers.rb

@@ -13,9 +13,9 @@ module RequestLogAnalyzer::Spec::Matchers
     end
     
     def matches?(file_format)
-      if file_format.new.line_definitions.include?(@line_type)
-        ld = file_format.new.line_definitions[@line_type]
-        @captures.all? { |c| ld.captures.include?(c) }
+      file_format = file_format.create if file_format.kind_of?(Class)
+      if ld = file_format.line_definitions[@line_type]
+        @captures.all? { |c| ld.captures.map { |cd| cd[:name] }.include?(c) }
       else
         false
       end

data/spec/unit/aggregator/database_spec.rb

@@ -183,10 +183,21 @@ describe RequestLogAnalyzer::Aggregator::Database do
       @database_inserter.send :create_database_schema!
     end
 
-    it "should create a Warnng class inheriting from ActiveRecord and the base class of the ORM module" do
+    it "should create a Warning class inheriting from ActiveRecord and the base class of the ORM module" do
       @database_inserter.send :create_database_schema!
       @database_inserter.warning_class.ancestors.should include(ActiveRecord::Base, @database_inserter.orm_module::Base)
     end
+    
+    it "should create a sources table to track parsed files" do
+      @connection.should_receive(:create_table).with("sources")
+      @database_inserter.send :create_database_schema!
+    end    
+
+    it "should create a Source ORM class" do
+      @database_inserter.send :create_database_schema!
+      @database_inserter.orm_module::Source.ancestors.should include(ActiveRecord::Base, @database_inserter.orm_module::Base)
+    end    
+
   
     it "should create a table for every line type" do
       @database_inserter.should_receive(:create_database_table).with(an_instance_of(RequestLogAnalyzer::LineDefinition)).exactly(@line_type_cnt).times

data/spec/unit/file_format/apache_format_spec.rb

@@ -1,35 +1,81 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Apache do
-  
-  before(:each) do
-    @file_format = RequestLogAnalyzer::FileFormat.load(:apache)
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(@file_format)
-    @sample = '69.41.0.45 - - [02/Sep/2009:12:02:40 +0200] "GET //phpMyAdmin/ HTTP/1.1" 404 209 "-" "Mozilla/4.0 (compatible; MSIE 6.0; Windows 98)"'
-  end
-  
-  it "should have a valid language definitions" do
-    @file_format.should be_valid
-  end
-  
-  it "should parse a valid access log line" do
-    @file_format.line_definitions[:access].matches(@sample, 1, nil).should be_kind_of(Hash)
+
+  describe '.access_line_definition' do
+    before(:each) do
+      @format_string   = '%h %l %u %t "%r" %>s %b "%{Referer}i" "%{User-agent}i"'
+      @line_definition = RequestLogAnalyzer::FileFormat::Apache.access_line_definition(@format_string)
+    end
+
+    it "should create a Regexp to match the line" do
+      @line_definition.regexp.should be_kind_of(Regexp)
+    end
+
+    it "should create a list of captures for the values in the lines" do
+      @line_definition.captures.should be_kind_of(Array)
+    end
+
+    it "should make it a header line" do
+      @line_definition.should be_header
+    end
+
+    it "should make it a footer line" do
+      @line_definition.should be_footer
+    end
   end
 
-  it "should read the correct values from a valid access log line" do
-    @log_parser.parse_io(@sample) do |request|
-      request[:ip_address].should   == '69.41.0.45'
-      request[:timestamp].should    == 20090902120240
-      request[:status].should       == 404
-      request[:method].should       == 'GET'
-      request[:http_version].should == '1.1'
+  describe '.create' do
+
+    before(:each) do
+      @format_string = '%h %l %u %t "%r" %>s %b "%{Referer}i" "%{User-agent}i"'
+      @format = RequestLogAnalyzer::FileFormat::Apache.create(@format_string)
+    end
+
+    it "should create the :access line definition" do
+      @format.should have_line_definition(:access).capturing(:timestamp, :ip_address, :http_method, :path, :http_version, :http_status)
+    end
+
+    it "should be a valid file format" do
+      @format.should be_valid
+    end
+    
+    it "should setup report trackers" do
+      @format.report_trackers.should_not be_empty
     end
   end
+
+  context 'log parsing' do
+
+    before(:each) do
+      @file_format = RequestLogAnalyzer::FileFormat.load(:apache)
+      @log_parser = RequestLogAnalyzer::Source::LogParser.new(@file_format)
+      @sample = '69.41.0.45 - - [02/Sep/2009:12:02:40 +0200] "GET //phpMyAdmin/ HTTP/1.1" 404 209 "-" "Mozilla/4.0 (compatible; MSIE 6.0; Windows 98)"'
+    end
+
+    it "should have a valid language definitions" do
+      @file_format.should be_valid
+    end
+
+    it "should parse a valid access log line" do
+      @file_format.line_definitions[:access].matches(@sample).should be_kind_of(Hash)
+    end
+
+    it "should read the correct values from a valid access log line" do
+      @log_parser.parse_io(@sample) do |request|
+        request[:ip_address].should   == '69.41.0.45'
+        request[:timestamp].should    == 20090902120240
+        request[:http_status].should  == 404
+        request[:http_method].should  == 'GET'
+        request[:http_version].should == '1.1'
+      end
+    end
   
-  it "should parse 5 request from fixture access log" do
-    counter = mock('counter')
-    counter.should_receive(:hit!).exactly(5).times
-    @log_parser.parse_file(log_fixture(:apache)) { counter.hit! }
+    it "should parse 5 request from fixture access log" do
+      counter = mock('counter')
+      counter.should_receive(:hit!).exactly(5).times
+      @log_parser.parse_file(log_fixture(:apache)) { counter.hit! }
+    end
   end
-
 end
+

data/spec/unit/file_format/file_format_api_spec.rb

@@ -16,7 +16,7 @@ describe RequestLogAnalyzer::FileFormat do
  
     it "specify lines with a block for the format definition" do
       @first_file_format.format_definition do |format|
-        format.block_test :regexp => /test (\w+)/, :captures => [:tester]
+        format.block_test :regexp => /test (\w+)/, :captures => [{:name => :tester, :type => :string}]
       end 
           
       @first_file_format.should have_line_definition(:block_test).capturing(:tester)

data/spec/unit/source/log_parser_spec.rb

@@ -71,7 +71,7 @@ end
 describe RequestLogAnalyzer::Source::LogParser, :decompression do
   
   before(:each) do
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat::Rails.new)
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat::Rails.create)
   end
     
   it "should parse a rails gzipped log file" do

data/tasks/github-gem.rake

@@ -203,7 +203,7 @@ module GithubGem
     end
     
     def rubyforge_release_task
-      sh 'rubyforge', 'add_release', gemspec.rubyforge_project, gemspec.name, gemspec.version, "pgk/#{gemspec.name}-#{gemspec.version}.gem"
+      sh 'rubyforge', 'add_release', gemspec.rubyforge_project, gemspec.name, gemspec.version.to_s, "pkg/#{gemspec.name}-#{gemspec.version}.gem"
     end
     
     def release_task

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: request-log-analyzer
 version: !ruby/object:Gem::Version 
-  version: 1.2.7
+  version: 1.2.8
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-02 00:00:00 +02:00
+date: 2009-09-08 00:00:00 +02:00
 default_executable: request-log-analyzer
 dependencies: 
 - !ruby/object:Gem::Dependency