request-log-analyzer 1.3.4 → 1.4.0

data/lib/request_log_analyzer/database/base.rb

@@ -1,5 +1,5 @@
 class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
-  
+
   self.abstract_class = true
 
   def <=>(other)
@@ -14,25 +14,26 @@ class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
     self.class.name.underscore.gsub(/_line$/, '').to_sym
   end
 
-  cattr_accessor :database, :line_definition
+  class_inheritable_accessor :line_definition
+  cattr_accessor :database
 
   def self.subclass_from_line_definition(definition)
     klass = Class.new(RequestLogAnalyzer::Database::Base)
     klass.set_table_name("#{definition.name}_lines")
-    
+
     klass.line_definition = definition
-    
+
     # Set relations with requests and sources table
     klass.belongs_to :request
     klass.belongs_to :source
-    
+
     # Serialize complex fields into the database
     definition.captures.select { |c| c.has_key?(:provides) }.each do |capture|
       klass.send(:serialize, capture[:name], Hash)
     end
 
-    database.request_class.has_many  "#{definition.name}_lines".to_sym
-    database.source_class.has_many   "#{definition.name}_lines".to_sym
+    RequestLogAnalyzer::Database::Request.has_many  "#{definition.name}_lines".to_sym
+    RequestLogAnalyzer::Database::Source.has_many   "#{definition.name}_lines".to_sym
 
     return klass
   end
@@ -45,34 +46,34 @@ class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
 
     if klass.column_names.include?('request_id')
       klass.belongs_to :request
-      database.request_class.has_many table.to_sym
+      RequestLogAnalyzer::Database::Request.has_many table.to_sym
     end
-    
+
     if klass.column_names.include?('source_id')
       klass.belongs_to :source
-      database.source_class.has_many table.to_sym
+      RequestLogAnalyzer::Database::Source.has_many table.to_sym
     end
-    
+
     return klass
   end
-  
+
   def self.drop_table!
     database.connection.remove_index(self.table_name, [:source_id])  rescue nil
     database.connection.remove_index(self.table_name, [:request_id]) rescue nil
     database.connection.drop_table(self.table_name) if database.connection.table_exists?(self.table_name)
   end
-  
+
   def self.create_table!
     raise "No line_definition available to base table schema on!" unless self.line_definition
-    
+
     unless table_exists?
       database.connection.create_table(table_name.to_sym) do |t|
-      
+
         # Default fields
         t.column :request_id, :integer
         t.column :source_id,  :integer
         t.column :lineno,     :integer
-      
+
         line_definition.captures.each do |capture|
           # Add a field for every capture
           t.column(capture[:name], column_type(capture[:type]))
@@ -82,13 +83,13 @@ class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
         end
       end
     end
-    
+
     # Add indices to table for more speedy querying
     database.connection.add_index(self.table_name.to_sym, [:request_id]) # rescue
     database.connection.add_index(self.table_name.to_sym, [:source_id])  # rescue
   end
-  
-  
+
+
   # Function to determine the column type for a field
   # TODO: make more robust / include in file-format definition
   def self.column_type(type_indicator)
@@ -109,6 +110,6 @@ class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
     when :date;      :date
     else             :string
     end
-  end  
-  
+  end
+
 end

data/lib/request_log_analyzer/database/connection.rb

@@ -26,13 +26,13 @@ module RequestLogAnalyzer::Database::Connection
       raise "Cannot connect with this connection_identifier: #{connection_identifier.inspect}"
     end
   end
-  
+
   def disconnect
     RequestLogAnalyzer::Database::Base.remove_connection
   end
-  
+
   def connection
     RequestLogAnalyzer::Database::Base.connection
   end
-  
+
 end

data/lib/request_log_analyzer/database/request.rb

@@ -0,0 +1,22 @@
+class RequestLogAnalyzer::Database::Request < RequestLogAnalyzer::Database::Base
+
+  # Returns an array of all the Line objects of this request in the correct order.
+  def lines
+    @lines ||= begin
+      lines = []
+      self.class.reflections.each { |r, d| lines += self.send(r).all }
+      lines.sort
+    end
+  end
+
+  # Creates the table to store requests in.
+  def self.create_table!
+    unless database.connection.table_exists?(:requests)
+      database.connection.create_table(:requests) do |t|
+        t.column :first_lineno, :integer
+        t.column :last_lineno,  :integer
+      end
+    end
+  end
+
+end

data/lib/request_log_analyzer/database/source.rb

@@ -0,0 +1,13 @@
+class RequestLogAnalyzer::Database::Source < RequestLogAnalyzer::Database::Base
+
+  def self.create_table!
+    unless database.connection.table_exists?(:sources)
+      database.connection.create_table(:sources) do |t|
+        t.column :filename, :string
+        t.column :mtime,    :datetime
+        t.column :filesize, :integer
+      end
+    end
+  end
+
+end

data/lib/request_log_analyzer/database/warning.rb

@@ -0,0 +1,14 @@
+class RequestLogAnalyzer::Database::Warning < RequestLogAnalyzer::Database::Base
+
+  def self.create_table!
+    unless database.connection.table_exists?(:warnings)
+      database.connection.create_table(:warnings) do |t|
+        t.column  :warning_type, :string, :limit => 30, :null => false
+        t.column  :message, :string
+        t.column  :source_id, :integer
+        t.column  :lineno, :integer
+      end
+    end
+  end
+
+end

data/lib/request_log_analyzer/database.rb

@@ -5,13 +5,13 @@ class RequestLogAnalyzer::Database
 
   def self.const_missing(const) # :nodoc:
     RequestLogAnalyzer::load_default_class_file(self, const)
-  end  
+  end
 
   include RequestLogAnalyzer::Database::Connection
 
   attr_accessor :file_format
-  attr_reader :request_class, :warning_class, :source_class, :line_classes
-  
+  attr_reader :line_classes
+
   def initialize(connection_identifier = nil)
     @line_classes = []
     RequestLogAnalyzer::Database::Base.database = self
@@ -23,112 +23,32 @@ class RequestLogAnalyzer::Database
     line_type = line_type.name if line_type.respond_to?(:name)
     Object.const_get("#{line_type}_line".camelize)
   end
-  
-  # Returns the Request ORM class for the current database.
-  #
-  # It will create the class if not previously done so. The class will
-  # include a create_table! method the migrate the database.
-  def request_class
-    @request_class ||= begin
-      klass = Class.new(RequestLogAnalyzer::Database::Base) do
-        
-        def lines
-          @lines ||= begin
-            lines = []
-            self.class.reflections.each { |r, d| lines += self.send(r).all }
-            lines.sort
-          end
-        end
-        
-        # Creates the requests table
-        def self.create_table!
-          unless database.connection.table_exists?(:requests)
-            database.connection.create_table(:requests) do |t|
-              t.column :first_lineno, :integer
-              t.column :last_lineno,  :integer
-            end
-          end
-        end
-      end
-      
-      Object.const_set('Request', klass) 
-      Object.const_get('Request')
-    end
-  end
-  
-  # Returns the Source ORM class for the current database.
-  #
-  # It will create the class if not previously done so. The class will
-  # include a create_table! method the migrate the database.  
-  def source_class
-    @source_class ||= begin
-      klass = Class.new(RequestLogAnalyzer::Database::Base) do
-        
-        # Creates the sources table
-        def self.create_table!
-          unless database.connection.table_exists?(:sources)
-            database.connection.create_table(:sources) do |t|
-              t.column :filename, :string
-              t.column :mtime,    :datetime
-              t.column :filesize, :integer
-            end
-          end
-        end
-      end
-      
-      Object.const_set('Source', klass)
-      Object.const_get('Source')
-    end
-  end
-  
-  
-  # Returns the Warning ORM class for the current database.
-  #
-  # It will create the class if not previously done so. The class will
-  # include a create_table! method the migrate the database.  
-  def warning_class
-    @warning_class ||= begin
-      klass = Class.new(RequestLogAnalyzer::Database::Base) do
-        
-        # Creates the warnings table
-        def self.create_table!
-          unless database.connection.table_exists?(:warnings)
-            database.connection.create_table(:warnings) do |t|
-              t.column  :warning_type, :string, :limit => 30, :null => false
-              t.column  :message, :string
-              t.column  :source_id, :integer
-              t.column  :lineno, :integer
-            end
-          end
-        end
-      end
-      
-      Object.const_set('Warning', klass)
-      Object.const_get('Warning')
-    end
+
+  def default_classes
+    [RequestLogAnalyzer::Database::Request, RequestLogAnalyzer::Database::Source, RequestLogAnalyzer::Database::Warning]
   end
-  
+
   # Loads the ORM classes by inspecting the tables in the current database
   def load_database_schema!
     connection.tables.map do |table|
       case table.to_sym
-      when :warnings then warning_class
-      when :sources  then source_class
-      when :requests then request_class
+      when :warnings then RequestLogAnalyzer::Database::Warning
+      when :sources  then RequestLogAnalyzer::Database::Source
+      when :requests then RequestLogAnalyzer::Database::Request
       else load_activerecord_class(table)
       end
     end
   end
-  
+
   # Returns an array of all the ActiveRecord-bases ORM classes for this database
   def orm_classes
-    [warning_class, request_class, source_class] + line_classes
+    default_classes + line_classes
   end
-  
+
   # Loads an ActiveRecord-based class that correspond to the given parameter, which can either be
   # a table name or a LineDefinition instance.
   def load_activerecord_class(linedefinition_or_table)
-    
+
     case linedefinition_or_table
     when String, Symbol
       klass_name = linedefinition_or_table.to_s.singularize.camelize
@@ -137,39 +57,44 @@ class RequestLogAnalyzer::Database
       klass_name = "#{linedefinition_or_table.name}_line".camelize
       klass      = RequestLogAnalyzer::Database::Base.subclass_from_line_definition(linedefinition_or_table)
     end
-    
+
     Object.const_set(klass_name, klass)
     klass = Object.const_get(klass_name)
     @line_classes << klass
     return klass
-  end  
+  end
 
   def fileformat_classes
     raise "No file_format provided!" unless file_format
-    
-    default_classes = [request_class, source_class, warning_class]
     line_classes    = file_format.line_definitions.map { |(name, definition)| load_activerecord_class(definition) }
     return default_classes + line_classes
   end
 
-  # Creates the database schema and related ActiveRecord::Base subclasses that correspond to the 
+  # 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!
     fileformat_classes.each { |klass| klass.create_table! }
   end
-  
+
   # Drops the table of all the ORM classes, and unregisters the classes
   def drop_database_schema!
     file_format ? fileformat_classes.map(&:drop_table!) : orm_classes.map(&:drop_table!)
     remove_orm_classes!
   end
-  
+
+  # Registers the default ORM classes in the default namespace
+  def register_default_orm_classes!
+    Object.const_set('Request', RequestLogAnalyzer::Database::Request)
+    Object.const_set('Source',  RequestLogAnalyzer::Database::Source)
+    Object.const_set('Warning', RequestLogAnalyzer::Database::Warning)
+  end
+
   # Unregisters every ORM class constant
   def remove_orm_classes!
     orm_classes.each do |klass|
       if klass.respond_to?(:name) && !klass.name.blank?
-#        klass_base_name = klass.name.split('::').last
-        Object.send(:remove_const, klass.name) if Object.const_defined?(klass.name)
+        klass_name = klass.name.split('::').last
+        Object.send(:remove_const, klass_name) if Object.const_defined?(klass_name)
       end
     end
   end

data/lib/request_log_analyzer/file_format/amazon_s3.rb

@@ -1,71 +1,71 @@
 module RequestLogAnalyzer::FileFormat
 
-  # FileFormat for Amazon S3 access logs. 
+  # FileFormat for Amazon S3 access logs.
   #
   # Access logs are disabled by default on Amazon S3. To enable logging, see
   # http://docs.amazonwebservices.com/AmazonS3/latest/index.html?ServerLogs.html
   class AmazonS3 < Base
-    
+
     line_definition :access do |line|
       line.header = true
       line.footer = true
-      line.regexp = /^([^\ ]+) ([^\ ]+) \[([^\]]{26})\] (\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}) ([^\ ]+) ([^\ ]+) (\w+(?:\.\w+)*) ([^\ ]+) "([^"]+)" (\d+) ([^\ ]+) (\d+) (\d+) (\d+) (\d+) "([^"]+)" "([^"]+)"/
-      line.captures << { :name => :bucket_owner,    :type => :string } << 
-                       { :name => :bucket,          :type => :string } << 
+      line.regexp = /^([^\ ]+) ([^\ ]+) \[(\d{2}\/[A-Za-z]{3}\/\d{4}.\d{2}:\d{2}:\d{2})(?: .\d{4})?\] (\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}) ([^\ ]+) ([^\ ]+) (\w+(?:\.\w+)*) ([^\ ]+) "([^"]+)" (\d+) ([^\ ]+) (\d+) (\d+) (\d+) (\d+) "([^"]+)" "([^"]+)"/
+      line.captures << { :name => :bucket_owner,    :type => :string } <<
+                       { :name => :bucket,          :type => :string } <<
                        { :name => :timestamp,       :type => :timestamp } <<
                        { :name => :remote_ip,       :type => :string } <<
-                       { :name => :requester,       :type => :string } << 
+                       { :name => :requester,       :type => :string } <<
                        { :name => :request_id,      :type => :string } <<
                        { :name => :operation,       :type => :string } <<
                        { :name => :key,             :type => :nillable_string } <<
                        { :name => :request_uri,     :type => :string } <<
                        { :name => :http_status,     :type => :integer } <<
                        { :name => :error_code,      :type => :nillable_string } <<
-                       { :name => :bytes_sent,      :type => :integer } <<
-                       { :name => :object_size,     :type => :integer } <<
+                       { :name => :bytes_sent,      :type => :traffic,  :unit => :byte } <<
+                       { :name => :object_size,     :type => :traffic,  :unit => :byte } <<
                        { :name => :total_time,      :type => :duration, :unit => :msec } <<
                        { :name => :turnaround_time, :type => :duration, :unit => :msec } <<
                        { :name => :referer,         :type => :referer } <<
                        { :name => :user_agent,      :type => :user_agent }
     end
-    
+
     report do |analyze|
       analyze.timespan
       analyze.hourly_spread
 
-      analyze.frequency :category => lambda { |r| "#{r[:bucket]}/#{r[:key]}"}, :amount => 20, :title => "Most popular items"
-      analyze.duration :duration => :total_time, :category => lambda { |r| "#{r[:bucket]}/#{r[:key]}"}, :amount => 20, :title => "Duration"
+      analyze.frequency :category => lambda { |r| "#{r[:bucket]}/#{r[:key]}"}, :title => "Most popular items"
+      analyze.duration :duration => :total_time, :category => lambda { |r| "#{r[:bucket]}/#{r[:key]}"}, :title => "Request duration"
+      analyze.traffic  :traffic => :bytes_sent,  :category => lambda { |r| "#{r[:bucket]}/#{r[:key]}"}, :title => "Traffic"
       analyze.frequency :category => :http_status, :title => 'HTTP status codes'
       analyze.frequency :category => :error_code, :title => 'Error codes'
     end
-    
+
     class Request < RequestLogAnalyzer::Request
-      
+
       MONTHS = {'Jan' => '01', 'Feb' => '02', 'Mar' => '03', 'Apr' => '04', 'May' => '05', 'Jun' => '06',
                 'Jul' => '07', 'Aug' => '08', 'Sep' => '09', 'Oct' => '10', 'Nov' => '11', 'Dec' => '12' }
-      
+
       # Do not use DateTime.parse, but parse the timestamp ourselves to return a integer
       # to speed up parsing.
       def convert_timestamp(value, definition)
-        d = /^(\d{2})\/(\w{3})\/(\d{4}):(\d{2}):(\d{2}):(\d{2})/.match(value).captures
-        "#{d[2]}#{MONTHS[d[1]]}#{d[0]}#{d[3]}#{d[4]}#{d[5]}".to_i
+        "#{value[7,4]}#{MONTHS[value[3,3]]}#{value[0,2]}#{value[12,2]}#{value[15,2]}#{value[18,2]}".to_i
       end
-      
+
       # Make sure that the string '-' is parsed as a nil value.
       def convert_nillable_string(value, definition)
         value == '-' ? nil : value
       end
-      
+
       # Can be implemented in subclasses for improved categorizations
       def convert_referer(value, definition)
         value == '-' ? nil : value
       end
-      
+
       # Can be implemented in subclasses for improved categorizations
       def convert_user_agent(value, definition)
         value == '-' ? nil : value
       end
     end
-    
+
   end
 end

data/lib/request_log_analyzer/file_format/apache.rb

@@ -1,6 +1,6 @@
 module RequestLogAnalyzer::FileFormat
-  
-  # The Apache file format is able to log Apache access.log files. 
+
+  # The Apache file format is able to log Apache access.log files.
   #
   # The access.log can be configured in Apache to have many different formats. In theory, this
   # FileFormat can handle any format, but it must be aware of the log formatting that is used
@@ -17,7 +17,10 @@ module RequestLogAnalyzer::FileFormat
     # A hash of predefined Apache log formats
     LOG_FORMAT_DEFAULTS = {
       :common   => '%h %l %u %t "%r" %>s %b',
-      :combined => '%h %l %u %t "%r" %>s %b "%{Referer}i" "%{User-agent}i"'
+      :combined => '%h %l %u %t "%r" %>s %b "%{Referer}i" "%{User-agent}i"',
+      :rack     => '%h %l %u %t "%r" %>s %b %T',
+      :referer  => '%{Referer}i -> %U',
+      :agent    => '%{User-agent}i'
     }
 
     # A hash that defines how the log format directives should be parsed.
@@ -25,18 +28,19 @@ module RequestLogAnalyzer::FileFormat
       '%' => { :regexp => '%', :captures => [] },
       'h' => { :regexp => '([A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+)',  :captures => [{:name => :remote_host, :type => :string}] },
       'a' => { :regexp => '(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})', :captures => [{:name => :remote_ip, :type => :string}] },
-      'b' => { :regexp => '(\d+|-)', :captures => [{:name => :bytes_sent, :type => :integer}] },
+      'b' => { :regexp => '(\d+|-)', :captures => [{:name => :bytes_sent, :type => :traffic}] },
       'c' => { :regexp => '(\+|\-|\X)', :captures => [{:name => :connection_status, :type => :integer}] },
-      'D' => { :regexp => '(\d+|-)', :captures => [{:name => :duration, :type => :duration, :unit => :msec}] },
+      'D' => { :regexp => '(\d+|-)', :captures => [{:name => :duration, :type => :duration, :unit => :musec}] },
       'l' => { :regexp => '([\w-]+)', :captures => [{:name => :remote_logname, :type => :nillable_string}] },
-      'T' => { :regexp => '(\d+|-)', :captures => [{:name => :duration, :type => :duration, :unit => :sec}] },
-      't' => { :regexp => '\[([^\]]{26})\]', :captures => [{:name => :timestamp, :type => :timestamp}] },
+      'T' => { :regexp => '((?:\d+(?:\.\d+))|-)', :captures => [{:name => :duration, :type => :duration, :unit => :sec}] },
+      't' => { :regexp => '\[(\d{2}\/[A-Za-z]{3}\/\d{4}.\d{2}:\d{2}:\d{2})(?: .\d{4})?\]', :captures => [{:name => :timestamp, :type => :timestamp}] },
       's' => { :regexp => '(\d{3})', :captures => [{:name => :http_status, :type => :integer}] },
       'u' => { :regexp => '(\w+|-)', :captures => [{:name => :user, :type => :nillable_string}] },
-      'r' => { :regexp => '([A-Z]+) ([^\s]+) HTTP\/(\d+(?:\.\d+)*)', :captures => [{:name => :http_method, :type => :string},
+      'U' => { :regexp => '(\/\S*)', :captures => [{:name => :path, :type => :string}] },
+      'r' => { :regexp => '([A-Z]+) (\S+) HTTP\/(\d+(?:\.\d+)*)', :captures => [{:name => :http_method, :type => :string},
                        {:name => :path, :type => :path}, {:name => :http_version, :type => :string}]},
-      'i' => { 'Referer'    => { :regexp => '([^\s]+)', :captures => [{:name => :referer, :type => :nillable_string}] },
-               'User-agent' => { :regexp => '(.*)',     :captures => [{:name => :user_agent, :type => :user_agent}] }
+      'i' => { 'Referer'    => { :regexp => '(\S+)', :captures => [{:name => :referer, :type => :nillable_string}] },
+               'User-agent' => { :regexp => '(.*)',  :captures => [{:name => :user_agent, :type => :user_agent}] }
              }
     }
 
@@ -44,8 +48,9 @@ module RequestLogAnalyzer::FileFormat
     # 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))
+      access_line = access_line_definition(args.first)
+      trackers = report_trackers(access_line) + report_definer.trackers
+      self.new(line_definer.line_definitions.merge(:access => access_line), trackers)
     end
 
     # Creates the access log line definition based on the Apache log format string
@@ -58,7 +63,7 @@ module RequestLogAnalyzer::FileFormat
       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
           directive = LOG_DIRECTIVES[variable]
@@ -73,7 +78,7 @@ module RequestLogAnalyzer::FileFormat
           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)
@@ -86,45 +91,47 @@ module RequestLogAnalyzer::FileFormat
       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)
+      analyze.frequency :category => :http_method, :title => "HTTP methods"  if line_definition.captures?(:http_method)
+      analyze.frequency :category => :http_status, :title => "HTTP statuses" if line_definition.captures?(:http_status)
+      analyze.frequency :category => lambda { |r| r.category }, :title => "Most popular URIs"    if line_definition.captures?(:path)
 
-      analyze.frequency :category => :user_agent, :amount => 20, :title => "User agents"    if line_definition.captures?(:user_agent)
-      analyze.frequency :category => :referer,    :amount => 20, :title => "Referers"       if line_definition.captures?(:referer)
+      analyze.frequency :category => :user_agent, :title => "User agents"    if line_definition.captures?(:user_agent)
+      analyze.frequency :category => :referer,    :title => "Referers"       if line_definition.captures?(:referer)
 
-      if line_definition.captures?(:path) && line_definition.captures?(:duration)
-        analyze.duration :duration => :duration, :category => :path , :title => 'Request duration'
-      end
+      analyze.duration :duration => :duration,  :category => lambda { |r| r.category }, :title => 'Request duration' if line_definition.captures?(:duration)
+      analyze.traffic  :traffic => :bytes_sent, :category => lambda { |r| r.category }, :title => 'Traffic'          if line_definition.captures?(:bytes_sent)
 
       return analyze.trackers
     end
 
     # Define a custom Request class for the Apache file format to speed up timestamp handling.
     class Request < RequestLogAnalyzer::Request
-      
+
+      def category
+        first(:path)
+      end
+
       MONTHS = {'Jan' => '01', 'Feb' => '02', 'Mar' => '03', 'Apr' => '04', 'May' => '05', 'Jun' => '06',
                 'Jul' => '07', 'Aug' => '08', 'Sep' => '09', 'Oct' => '10', 'Nov' => '11', 'Dec' => '12' }
-      
+
       # Do not use DateTime.parse, but parse the timestamp ourselves to return a integer
       # to speed up parsing.
       def convert_timestamp(value, definition)
-        d = /^(\d{2})\/(\w{3})\/(\d{4}):(\d{2}):(\d{2}):(\d{2})/.match(value).captures
-        "#{d[2]}#{MONTHS[d[1]]}#{d[0]}#{d[3]}#{d[4]}#{d[5]}".to_i
+        "#{value[7,4]}#{MONTHS[value[3,3]]}#{value[0,2]}#{value[12,2]}#{value[15,2]}#{value[18,2]}".to_i
       end
-      
+
       # This function can be overridden to rewrite the path for better categorization in the
       # reports.
       def convert_path(value, definition)
         value
       end
-      
-      # This function can be overridden to simplify the user agent string for better 
+
+      # This function can be overridden to simplify the user agent string for better
       # categorization in the reports
       def convert_user_agent(value, definition)
         value # TODO
       end
-      
+
       # Make sure that the string '-' is parsed as a nil value.
       def convert_nillable_string(value, definition)
         value == '-' ? nil : value