request-log-analyzer 1.0.2 → 1.6.3

data/lib/request_log_analyzer/controller.rb

@@ -1,14 +1,12 @@
 module RequestLogAnalyzer
-  
+
   # The RequestLogAnalyzer::Controller class creates a LogParser instance for the
-  # requested file format, and connect it with sources and aggregators.
+  # requested file format and connect it with sources and aggregators.
   #
   # Sources are streams or files from which the requests will be parsed.
   # Aggregators will handle every passed request to yield a meaningfull results.
   #
-  # - Use the build-function to build a controller instance using command line arguments.
-  # - Use add_aggregator to register a new aggregator
-  # - Use add_source to register a new aggregator
+  # - Use the build -function to build a new controller instance.
   # - Use the run! method to start the parser and send the requests to the aggregators.
   #
   # Note that the order of sources can be imported if you have log files than succeed
@@ -17,35 +15,50 @@ module RequestLogAnalyzer
   # from several logrotated log files.
   class Controller
 
-    include RequestLogAnalyzer::FileFormat::Awareness
-    
-    attr_reader :aggregators
-    attr_reader :filters
-    attr_reader :log_parser
-    attr_reader :source
-    attr_reader :output
-    attr_reader :options
+    attr_reader :source, :filters, :aggregators, :output, :options
 
     # Builds a RequestLogAnalyzer::Controller given parsed command line arguments
     # <tt>arguments<tt> A CommandLine::Arguments hash containing parsed commandline parameters.
-    # <rr>report_with</tt> Width of the report. Defaults to 80.
-    def self.build(arguments, report_width = 80)
-            
-      options = { :report_width => arguments[:report_width].to_i, :output => STDOUT}
-
-      options[:database] = arguments[:database] if arguments[:database]
-      options[:debug]    = arguments[:debug]
-      options[:colorize] = !arguments[:boring]
-
-      if arguments[:file]
-        options[:output] = File.new(arguments[:file], "w+")
-        options[:colorize] = false
+    def self.build_from_arguments(arguments)
+      
+      options = {}
+      
+      # Copy fields
+      options[:database]       = arguments[:database]
+      options[:reset_database] = arguments[:reset_database]
+      options[:debug]          = arguments[:debug]
+      options[:yaml]           = arguments[:yaml] || arguments[:dump]
+      options[:mail]           = arguments[:mail]
+      options[:no_progress]    = arguments[:no_progress]
+      options[:format]         = arguments[:format]
+      options[:output]         = arguments[:output].downcase
+      options[:file]           = arguments[:file]
+      options[:after]          = arguments[:after]
+      options[:before]         = arguments[:before]
+      options[:reject]         = arguments[:reject]
+      options[:select]         = arguments[:select]
+      options[:boring]         = arguments[:boring]
+      options[:aggregator]     = arguments[:aggregator]
+      options[:report_width]   = arguments[:report_width]
+      options[:report_sort]    = arguments[:report_sort]
+      options[:report_amount]  = arguments[:report_amount]
+      options[:mailhost]       = arguments[:mailhost] 
+      
+      # Apache format workaround
+      if arguments[:rails_format]
+        options[:format] = {:rails => arguments[:rails_format]}
+      elsif arguments[:apache_format]
+        options[:format] = {:apache => arguments[:apache_format]}
       end
-                
-      # Create the controller with the correct file format
-      file_format = RequestLogAnalyzer::FileFormat.load(arguments[:format])
-
-      # register sources
+      
+      # Handle output format casing
+      if options[:output].class == String
+        options[:output] = 'FancyHTML'  if options[:output] =~ /^fancy_?html$/i
+        options[:output] = 'HTML'       if options[:output] =~ /^html$/i
+        options[:output] = 'FixedWidth' if options[:output] =~ /^fixed_?width$/i
+      end
+      
+      # Register sources
       if arguments.parameters.length == 1
         file = arguments.parameters[0]
         if file == '-' || file == 'STDIN'
@@ -60,50 +73,157 @@ module RequestLogAnalyzer
         options.store(:source_files, arguments.parameters)
       end
       
-      controller = Controller.new(RequestLogAnalyzer::Source::LogFile.new(file_format, options), options)
+      # Guess file format
+      if !options[:format] && options[:source_files]
+        options[:format] = :rails # Default
+
+        if options[:source_files] != $stdin
+          if options[:source_files].class == String
+            options[:format] = RequestLogAnalyzer::FileFormat.autodetect(options[:source_files])
 
-      options[:assume_correct_order] = arguments[:assume_correct_order]
+          elsif options[:source_files].class == Array && options[:source_files].first != $stdin
+            options[:format] = RequestLogAnalyzer::FileFormat.autodetect(options[:source_files].first)
+          end
+        end
+      end
       
-      # register filters        
-      if arguments[:after] || arguments[:before]
-        filter_options = {}
-        filter_options[:after]  = DateTime.parse(arguments[:after])  
-        filter_options[:before] = DateTime.parse(arguments[:before]) if arguments[:before]
-        controller.add_filter(:timespan, filter_options)
+      build(options)
+    end
+
+    # Build a new controller.
+    # Returns a new RequestLogAnalyzer::Controller object.
+    #
+    # Options
+    # * <tt>:after</tt> Drop all requests after this date (Date, DateTime, Time, or a String in "YYYY-MM-DD hh:mm:ss" format)
+    # * <tt>:aggregator</tt> Array of aggregators (ATM: STRINGS OR SYMBOLS ONLY! - Defaults to [:summarizer]).
+    # * <tt>:boring</tt> Do not show color on STDOUT (Defaults to false).
+    # * <tt>:before</tt> Drop all requests before this date (Date, DateTime, Time or a String in "YYYY-MM-DD hh:mm:ss" format)
+    # * <tt>:database</tt> Database file to insert encountered requests to.
+    # * <tt>:debug</tt> Enables echo aggregator which will echo each request analyzed.
+    # * <tt>:file</tt> Filestring, File or StringIO.
+    # * <tt>:format</tt> :rails, {:apache => 'FORMATSTRING'}, :merb, :amazon_s3, :mysql or RequestLogAnalyzer::FileFormat class. (Defaults to :rails).
+    # * <tt>:mail</tt> Email the results to this email address.
+    # * <tt>:mailhost</tt> Email the results to this mail server.
+    # * <tt>:no_progress</tt> Do not display the progress bar (increases parsing speed).
+    # * <tt>:output</tt> 'FixedWidth', 'HTML' or RequestLogAnalyzer::Output class. Defaults to 'FixedWidth'.
+    # * <tt>:reject</tt> Reject specific {:field => :value} combination (expects a single hash).
+    # * <tt>:report_width</tt> Width of reports in characters for FixedWidth reports. (Defaults to 80)
+    # * <tt>:reset_database</tt> Reset the database before starting.
+    # * <tt>:select</tt> Select specific {:field => :value} combination (expects a single hash).
+    # * <tt>:source_files</tt> Source files to analyze. Provide either File, array of files or STDIN.
+    # * <tt>:yaml</tt> Output to YAML file.
+    #
+    # === Example
+    # RequestLogAnalyzer::Controller.build(
+    #   :output       => :HTML,
+    #   :mail         => 'root@localhost',
+    #   :after        => Time.now - 24*60*60, 
+    #   :source_files => '/var/log/passenger.log'
+    # ).run!
+    #
+    # === Todo
+    # * Check if defaults work (Aggregator defaults seem wrong).
+    # * Refactor :database => options[:database], :dump => options[:dump] away from contoller intialization.
+    def self.build(options)
+      # Defaults
+      options[:output]        ||= 'FixedWidth'
+      options[:format]        ||= :rails
+      options[:aggregator]    ||= [:summarizer]
+      options[:report_width]  ||= 80
+      options[:report_amount] ||= 20
+      options[:report_sort]   ||= 'sum,mean'
+      options[:boring]        ||= false
+      
+      # Deprecation warnings
+      if options[:dump]
+        warn "[DEPRECATION] `:dump` is deprecated.  Please use `:yaml` instead."
+        options[:yaml]          = options[:dump]
       end
       
-      arguments[:reject].each do |(field, value)|
-        controller.add_filter(:field, :mode => :reject, :field => field, :value => value)
+      # Set the output class
+      output_args   = {}
+      output_object = nil
+      if options[:output].is_a?(Class)
+        output_class = options[:output]
+      else
+        output_class = RequestLogAnalyzer::Output::const_get(options[:output])
+      end
+      
+      output_sort   = options[:report_sort].split(',').map { |s| s.to_sym }
+      output_amount = options[:report_amount] == 'all' ? :all : options[:report_amount].to_i
+      
+      if options[:file]
+        output_object = %w[File StringIO].include?(options[:file].class.name) ? options[:file] : File.new(options[:file], "w+")
+        output_args   = {:width => 80, :color => false, :characters => :ascii, :sort => output_sort, :amount => output_amount }
+      elsif options[:mail]
+        output_object = RequestLogAnalyzer::Mailer.new(options[:mail], options[:mailhost])
+        output_args   = {:width => 80, :color => false, :characters => :ascii, :sort => output_sort, :amount => output_amount  }
+      else
+        output_object = STDOUT
+        output_args   = {:width => options[:report_width].to_i, :color => !options[:boring],
+                        :characters => (options[:boring] ? :ascii : :utf), :sort => output_sort, :amount => output_amount }
       end
       
-      arguments[:select].each do |(field, value)|
-        controller.add_filter(:field, :mode => :select, :field => field, :value => value)
+      output_instance = output_class.new(output_object, output_args)
+      
+      # Create the controller with the correct file format
+      if options[:format].kind_of?(Hash)
+        file_format = RequestLogAnalyzer::FileFormat.load(options[:format].keys[0], options[:format].values[0])
+      else
+        file_format = RequestLogAnalyzer::FileFormat.load(options[:format])
+      end
+      
+      # Kickstart the controller
+      controller = Controller.new(  RequestLogAnalyzer::Source::LogParser.new(file_format, :source_files => options[:source_files]),
+                                    { :output => output_instance,
+                                      :database => options[:database],                # FUGLY!
+                                      :yaml => options[:yaml], 
+                                      :reset_database => options[:reset_database],
+                                      :no_progress => options[:no_progress]})
+
+      # register filters
+      if options[:after] || options[:before]
+        filter_options = {}
+        [:after, :before].each do |filter|
+          case options[filter]
+          when Date, DateTime, Time
+            filter_options[filter] = options[filter]
+          when String
+            filter_options[filter] = DateTime.parse(options[filter])
+          end
+        end
+        controller.add_filter(:timespan, filter_options)
+      end
+
+      if options[:reject]
+        options[:reject].each do |(field, value)|
+          controller.add_filter(:field, :mode => :reject, :field => field, :value => value)
+        end
+      end
+
+      if options[:reject]
+        options[:select].each do |(field, value)|
+          controller.add_filter(:field, :mode => :select, :field => field, :value => value)
+        end
       end
 
       # register aggregators
-      arguments[:aggregator].each { |agg| controller.add_aggregator(agg.to_sym) }
-
-      # register the database 
-      controller.add_aggregator(:database)   if arguments[:database] && !arguments[:aggregator].include?('database')
-      controller.add_aggregator(:summarizer) if arguments[:aggregator].empty?
-    
-      # register the echo aggregator in debug mode
-      controller.add_aggregator(:echo) if arguments[:debug]
-      
+      options[:aggregator].each { |agg| controller.add_aggregator(agg.to_sym) }
+      controller.add_aggregator(:summarizer)          if options[:aggregator].empty?
+      controller.add_aggregator(:echo)                if options[:debug]
+      controller.add_aggregator(:database_inserter)   if options[:database] && !options[:aggregator].include?('database')
+
       file_format.setup_environment(controller)
-          
       return controller
-    end
+    end  
 
     # Builds a new Controller for the given log file format.
     # <tt>format</tt> Logfile format. Defaults to :rails
     # Options are passd on to the LogParser.
-    # * <tt>:aggregator</tt> Aggregator array.
     # * <tt>:database</tt> Database the controller should use.
-    # * <tt>:echo</tt> Output debug information.
-    # * <tt>:silent</tt> Do not output any warnings.
-    # * <tt>:colorize</tt> Colorize output
+    # * <tt>:yaml</tt> Yaml Dump the contrller should use.
     # * <tt>:output</tt> All report outputs get << through this output.
+    # * <tt>:no_progress</tt> No progress bar
     def initialize(source, options = {})
 
       @source      = source
@@ -111,17 +231,17 @@ module RequestLogAnalyzer
       @aggregators = []
       @filters     = []
       @output      = options[:output]
+      @interrupted = false
       
-      # Requester format through RequestLogAnalyzer::FileFormat and construct the parser
-      register_file_format(@source.file_format) 
-      
-      # Pass all warnings to every aggregator so they can do something useful with them.
-      @source.warning = lambda { |type, message, lineno|  @aggregators.each { |agg| agg.warning(type, message, lineno) } } if @source
+      # Register the request format for this session after checking its validity
+      raise "Invalid file format!" unless @source.file_format.valid?
 
-      # Handle progress messagess
-      @source.progress = lambda { |message, value| handle_progress(message, value) } if @source
+      # Install event handlers for wrnings, progress updates and source changes
+      @source.warning        = lambda { |type, message, lineno|  @aggregators.each { |agg| agg.warning(type, message, lineno) } }
+      @source.progress       = lambda { |message, value| handle_progress(message, value) } unless options[:no_progress]
+      @source.source_changes = lambda { |change, filename| handle_source_change(change, filename) }
     end
-    
+
     # Progress function.
     # Expects :started with file, :progress with current line and :finished or :interrupted when done.
     # <tt>message</tt> Current state (:started, :finished, :interupted or :progress).
@@ -129,7 +249,7 @@ module RequestLogAnalyzer
     def handle_progress(message, value = nil)
       case message
       when :started
-        @progress_bar = ProgressBar.new(green(File.basename(value), options[:colorize]), File.size(value))
+        @progress_bar = CommandLine::ProgressBar.new(File.basename(value), File.size(value), STDOUT)
       when :finished
         @progress_bar.finish
         @progress_bar = nil
@@ -142,30 +262,46 @@ module RequestLogAnalyzer
         @progress_bar.set(value)
       end
     end
-    
-    # Adds an aggregator to the controller. The aggregator will be called for every request 
+
+    # Source change handler
+    def handle_source_change(change, filename)
+      @aggregators.each { |agg| agg.source_change(change, File.expand_path(filename, Dir.pwd)) }
+    end
+
+    # Adds an aggregator to the controller. The aggregator will be called for every request
     # that is parsed from the provided sources (see add_source)
     def add_aggregator(agg)
-      if agg.kind_of?(Symbol)
-        require File.dirname(__FILE__) + "/aggregator/#{agg}"
-        agg = RequestLogAnalyzer::Aggregator.const_get(agg.to_s.split(/[^a-z0-9]/i).map{ |w| w.capitalize }.join(''))
-      end
-      
+      agg = RequestLogAnalyzer::Aggregator.const_get(RequestLogAnalyzer::to_camelcase(agg)) if agg.kind_of?(Symbol)
       @aggregators << agg.new(@source, @options)
     end
-    
+
     alias :>> :add_aggregator
-    
+
     # Adds a request filter to the controller.
     def add_filter(filter, filter_options = {})
-      if filter.kind_of?(Symbol)
-        require File.dirname(__FILE__) + "/filter/#{filter}"
-        filter = RequestLogAnalyzer::Filter.const_get(filter.to_s.split(/[^a-z0-9]/i).map{ |w| w.capitalize }.join(''))
+      filter = RequestLogAnalyzer::Filter.const_get(RequestLogAnalyzer::to_camelcase(filter)) if filter.kind_of?(Symbol)
+      @filters << filter.new(source.file_format, @options.merge(filter_options))
+    end
+
+    # Push a request through the entire filterchain (@filters).
+    # <tt>request</tt> The request to filter.
+    # Returns the filtered request or nil.
+    def filter_request(request)
+      @filters.each do |filter|
+        request = filter.filter(request)
+        return nil if request.nil?
       end
-      
-      @filters << filter.new(file_format, @options.merge(filter_options))
+      return request
+    end
+
+    # Push a request to all the aggregators (@aggregators).
+    # <tt>request</tt> The request to push to the aggregators.
+    def aggregate_request(request)
+      return false unless request
+      @aggregators.each { |agg| agg.aggregate(request) }
+      return true
     end
-    
+
     # Runs RequestLogAnalyzer
     # 1. Call prepare on every aggregator
     # 2. Generate requests from source object
@@ -175,27 +311,44 @@ module RequestLogAnalyzer
     # 5. Call report on every aggregator
     # 6. Finalize Source
     def run!
-      
-      @filters.each { |filter| filter.prepare }
+
+      # @aggregators.each{|agg| p agg}
+
       @aggregators.each { |agg| agg.prepare }
-      
-      begin
-        @source.requests do |request|
-          #@filters.each { |filter| request = filter.filter(request) }
-          @aggregators.each { |agg| agg.aggregate(request) } if request
-        end
-      rescue Interrupt => e
-        handle_progress(:interrupted)
-        puts "Caught interrupt! Stopped parsing."
+      install_signal_handlers
+
+      @source.each_request do |request|
+        break if @interrupted
+        aggregate_request(filter_request(request))
       end
 
-      puts "\n"
-      
       @aggregators.each { |agg| agg.finalize }
-      @aggregators.each { |agg| agg.report(@output, options[:report_width], options[:colorize]) }
-      
+
+      @output.header
+      @aggregators.each { |agg| agg.report(@output) }
+      @output.footer
+
       @source.finalize
+
+      if @output.io.kind_of?(File)
+        puts
+        puts "Report written to: " + File.expand_path(@output.io.path)
+        puts "Need an expert to analyze your application?"
+        puts "Mail to contact@railsdoctors.com or visit us at http://railsdoctors.com"
+        puts "Thanks for using request-log-analyzer!"
+        @output.io.close
+      elsif @output.io.kind_of?(RequestLogAnalyzer::Mailer)
+        @output.io.mail
+      end
     end
-    
+
+    def install_signal_handlers
+      Signal.trap("INT") do
+        handle_progress(:interrupted)
+        puts "Caught interrupt! Stopping parsing..."
+        @interrupted = true
+      end
+    end
+
   end
-end
+end

data/lib/request_log_analyzer/database/base.rb

@@ -0,0 +1,114 @@
+class RequestLogAnalyzer::Database::Base < ActiveRecord::Base
+
+  self.abstract_class = true
+
+  def <=>(other)
+    if (source_id.nil? && other.source_id.nil?) || (source_comparison = source_id <=> other.source_id) == 0
+      lineno <=> other.lineno
+    else
+      source_comparison
+    end
+  end
+
+  def line_type
+    self.class.name.underscore.gsub(/_line$/, '').to_sym
+  end
+
+  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
+
+    RequestLogAnalyzer::Database::Request.has_many  "#{definition.name}_lines".to_sym
+    RequestLogAnalyzer::Database::Source.has_many   "#{definition.name}_lines".to_sym
+
+    return klass
+  end
+
+  def self.subclass_from_table(table)
+    raise "Table #{table} not found!" unless database.connection.table_exists?(table)
+
+    klass = Class.new(RequestLogAnalyzer::Database::Base)
+    klass.set_table_name(table)
+
+    if klass.column_names.include?('request_id')
+      klass.belongs_to :request
+      RequestLogAnalyzer::Database::Request.has_many table.to_sym
+    end
+
+    if klass.column_names.include?('source_id')
+      klass.belongs_to :source
+      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]))
+
+          # If the capture provides other field as well, create columns for them, too
+          capture[:provides].each { |field, field_type| t.column(field, column_type(field_type)) } if capture[:provides].kind_of?(Hash)
+        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
+  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)
+    case type_indicator
+    when :eval;      :text
+    when :hash;      :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/database/connection.rb

@@ -0,0 +1,38 @@
+module RequestLogAnalyzer::Database::Connection
+
+  def self.from_string(string)
+    hash = {}
+    if string =~ /^(?:\w+=(?:[^;])*;)*\w+=(?:[^;])*$/
+      string.scan(/(\w+)=([^;]*);?/) { |variable, value| hash[variable.to_sym] = value }
+    elsif string =~ /^(\w+)\:\/\/(?:(?:([^:]+)(?:\:([^:]+))?\@)?([\w\.-]+)\/)?([\w\:\-\.\/]+)$/
+      hash[:adapter], hash[:username], hash[:password], hash[:host], hash[:database] = $1, $2, $3, $4, $5
+      hash.delete_if { |k, v| v.nil? }
+    end
+    return hash.empty? ? nil : hash
+  end
+
+  def connect(connection_identifier)
+    if connection_identifier.kind_of?(Hash)
+      RequestLogAnalyzer::Database::Base.establish_connection(connection_identifier)
+    elsif connection_identifier == ':memory:'
+      RequestLogAnalyzer::Database::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+    elsif connection_hash = RequestLogAnalyzer::Database::Connection.from_string(connection_identifier)
+      RequestLogAnalyzer::Database::Base.establish_connection(connection_hash)
+    elsif connection_identifier.kind_of?(String) # Normal SQLite 3 database file
+      RequestLogAnalyzer::Database::Base.establish_connection(:adapter => 'sqlite3', :database => connection_identifier)
+    elsif connection_identifier.nil?
+      nil
+    else
+      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