request-log-analyzer 1.1.4 → 1.1.5.1

data/lib/request_log_analyzer/aggregator/database.rb

@@ -96,6 +96,11 @@ module RequestLogAnalyzer::Aggregator
       class_name = "#{name}_line".camelize
       klass = Class.new(ActiveRecord::Base)
       klass.send(:belongs_to, :request)
+      
+      definition.captures.each do |capture|
+        klass.send(:serialize, capture[:name], Hash) if capture[:provides]
+      end
+      
       @orm_module.const_set(class_name, klass) unless @orm_module.const_defined?(class_name)
       @request_class.send(:has_many, "#{name}_lines".to_sym)
     end    
@@ -148,11 +153,20 @@ module RequestLogAnalyzer::Aggregator
     # TODO: make more robust / include in file-format definition
     def column_type(type_indicator)
       case type_indicator
-      when :eval;  :text
-      when :sec;   :double
-      when :msec;  :double
-      when :float; :double
-      else         type_indicator
+      when :eval;      :text
+      when :text;      :text
+      when :string;    :string
+      when :sec;       :double
+      when :msec;      :double
+      when :duration;  :double
+      when :float;     :double
+      when :double;    :double
+      when :integer;   :integer
+      when :int;       :int
+      when :timestamp; :datetime
+      when :datetime;  :datetime
+      when :date;      :date
+      else             :string
       end
     end
   end

data/lib/request_log_analyzer/line_definition.rb

@@ -78,12 +78,11 @@ module RequestLogAnalyzer
       value_hash = {}
       captures.each_with_index do |capture, index|
         converted = request.convert_value(values[index], capture)
-        if converted.kind_of?(Hash)
-          value_hash[capture[:name]] = values[index]
-          converted = converted.inject({}) { |h, (key, value)| h[key.to_sym] = value; h } 
-          value_hash = converted.merge(value_hash) 
-        else
-          value_hash[capture[:name]] ||= converted
+        value_hash[capture[:name]] ||= converted
+        if converted.kind_of?(Hash) && capture[:provides].kind_of?(Hash)
+          capture[:provides].each do |name, type|
+            value_hash[name] ||= request.convert_value(converted[name], { :type => type })
+          end          
         end
       end
       return value_hash

data/lib/request_log_analyzer/request.rb

@@ -31,7 +31,9 @@ module RequestLogAnalyzer
       end
       
       def convert_eval(value, capture_definition)
-        eval(value)
+        eval(value).inject({}) { |h, (k, v)| h[k.to_sym] = v; h} 
+      rescue SyntaxError
+        nil
       end
       
       # Slow default method to parse timestamps

data/lib/request_log_analyzer/source/database.rb

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'activerecord'
+
+module RequestLogAnalyzer::Source
+  
+  # Active Resource hook
+  class CompletedLine < ActiveRecord::Base
+    def convert(file_format)
+      RequestLogAnalyzer::Request.create(file_format, self.attributes)
+    end
+  end
+
+  # The Database class gets log data from the database.
+  class Database < Base
+
+    attr_reader :source_files
+    attr_reader :requests
+
+    # Initializes the log file parser instance.
+    # It will apply the language specific FileFormat module to this instance. It will use the line
+    # definitions in this module to parse any input that it is given (see parse_io).
+    #
+    # <tt>format</tt>:: The current file format instance
+    # <tt>options</tt>:: A hash of options that are used by the parser
+    def initialize(format, options = {})      
+      @line_definitions = {}
+      @options          = options
+      @source_files     = options[:source_files]
+      @parsed_requests  = 0
+      @requests         = []
+      
+      self.register_file_format(format)
+    end
+    
+    # Reads the input, which can either be a file, sequence of files or STDIN to parse
+    # lines specified in the FileFormat. This lines will be combined into Request instances,
+    # that will be yielded. The actual parsing occurs in the parse_io method.
+    # <tt>options</tt>:: A Hash of options that will be pased to parse_io.
+    def each_request(options = {}, &block) # :yields: request
+      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => @source_files)
+
+      @progress_handler.call(:started, @source_files) if @progress_handler
+        RequestLogAnalyzer::Source::CompletedLine.find(:all).each do |request|
+          @parsed_requests += 1
+          yield(request.convert(self.file_format))
+        end
+      
+      @progress_handler.call(:finished, @source_files) if @progress_handler
+    end
+
+    # Add a block to this method to install a progress handler while parsing.
+    # <tt>proc</tt>:: The proc that will be called to handle progress update messages
+    def progress=(proc)
+      @progress_handler = proc
+    end
+
+    # Add a block to this method to install a warning handler while parsing,
+    # <tt>proc</tt>:: The proc that will be called to handle parse warning messages    
+    def warning=(proc)
+      @warning_handler = proc
+    end
+
+    # This method is called by the parser if it encounteres any parsing problems.
+    # It will call the installed warning handler if any. 
+    #
+    # By default, RequestLogAnalyzer::Controller will install a warning handler 
+    # that will pass the warnings to each aggregator so they can do something useful
+    # with it.
+    #
+    # <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
+    end
+  end
+end

data/lib/request_log_analyzer/tracker/duration.rb

@@ -48,7 +48,7 @@ module RequestLogAnalyzer::Tracker
         category = options[:category].respond_to?(:call) ? options[:category].call(request) : request[options[:category]]
         duration = options[:duration].respond_to?(:call) ? options[:duration].call(request) : request[options[:duration]]
   
-        if !duration.nil? && !category.nil?
+        if duration.kind_of?(Float) && category.kind_of?(String)
           @categories[category] ||= {:hits => 0, :cumulative => 0.0, :min => duration, :max => duration }
           @categories[category][:hits] += 1
           @categories[category][:cumulative] += duration

data/lib/request_log_analyzer/tracker/hourly_spread.rb

@@ -72,9 +72,8 @@ module RequestLogAnalyzer::Tracker
       output.table({}, {:align => :right}, {:type => :ratio, :width => :rest, :treshold => 0.15}) do |rows|
         @request_time_graph.each_with_index do |requests, index|
           ratio = requests.to_f / total_requests.to_f
-          requests_per_day = requests / days
-    
-          rows << ["#{index.to_s.rjust(3)}:00", "#{requests_per_day} hits", ratio]
+          requests_per_day = (requests / days).ceil
+          rows << ["#{index.to_s.rjust(3)}:00", "%d hits" % requests_per_day, ratio]
         end
       end
     end

data/spec/unit/aggregator/database_inserter_spec.rb

@@ -79,7 +79,7 @@ describe RequestLogAnalyzer::Aggregator::Database, "record insertion" do
     @completed_request = testing_format.request( {:line_type => :first, :request_no  => 564}, 
                           {:line_type => :test, :test_capture => "awesome"},
                           {:line_type => :test, :test_capture => "indeed"}, 
-                          {:line_type => :eval, :evaluated => "{ 'greating' => 'howdy'}", :greating => 'howdy' }, 
+                          {:line_type => :eval, :evaluated => { :greating => 'howdy'}, :greating => 'howdy' }, 
                           {:line_type => :last, :request_no   => 564})    
   end
   

data/spec/unit/file_format/line_definition_spec.rb

@@ -55,7 +55,7 @@ describe RequestLogAnalyzer::LineDefinition, :converting do
   
   it "should merge a hash capture into the line hash" do
     hash = @file_format.line_definitions[:eval].convert_captured_values(["{ 'greating' => 'hello', 'what' => 'world'}"], @request)
-    hash[:evaluated].should == "{ 'greating' => 'hello', 'what' => 'world'}"
+    hash[:evaluated].should == { :greating => "hello", :what => "world"}
     hash[:greating].should == 'hello'
     hash[:what].should == 'world'    
   end  

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: request-log-analyzer
 version: !ruby/object:Gem::Version 
-  version: 1.1.4
+  version: 1.1.5.1
 platform: ruby
 authors: 
 - Willem van Bergen
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-08 00:00:00 +01:00
+date: 2009-02-10 00:00:00 +01:00
 default_executable: request-log-analyzer
 dependencies: []
 
@@ -62,6 +62,7 @@ files:
 - lib/request_log_analyzer/request.rb
 - lib/request_log_analyzer/source
 - lib/request_log_analyzer/source.rb
+- lib/request_log_analyzer/source/database.rb
 - lib/request_log_analyzer/source/log_parser.rb
 - lib/request_log_analyzer/tracker
 - lib/request_log_analyzer/tracker.rb