wvanbergen-request-log-analyzer 1.1.0 → 1.1.1

data/lib/request_log_analyzer/file_format.rb

@@ -1,29 +1,80 @@
-module RequestLogAnalyzer
+module RequestLogAnalyzer::FileFormat
   
-  class FileFormat
+  
+  def self.const_missing(const)
+    RequestLogAnalyzer::load_default_class_file(self, const)
+  end  
+  
+  # Loads a FileFormat::Base subclass instance.
+  # You can provide:
+  # * A FileFormat instance (which will return itself)
+  # * 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)
+    klass = nil
+    if file_format.kind_of?(RequestLogAnalyzer::FileFormat::Base)
+      # this already is a file format! return itself
+      return @current_file_format = file_format
+
+    elsif file_format.kind_of?(Class) && file_format.ancestors.include?(RequestLogAnalyzer::FileFormat::Base)
+      # a usable class is provided. Use this format class.
+      klass = file_format
+
+    elsif file_format.kind_of?(String) && File.exist?(file_format)
+      # load a format from a ruby file
+      require file_format
+      klass = Object.const_get(RequestLogAnalyzer::to_camelcase(File.basename(file_format, '.rb')))
+
+    else
+      # load a provided file format
+      klass = RequestLogAnalyzer::FileFormat.const_get(RequestLogAnalyzer::to_camelcase(file_format))      
+    end
     
-    # Makes classes aware of a file format by registering the file_format variable
-    module Awareness
-      
-      def self.included(base)
-        base.send(:attr_reader, :file_format)
-      end
-      
-      def register_file_format(format)
-        @file_format = format
-      end
+    raise if klass.nil?
+    @current_file_format = klass.new # return an instance of the class
+  end  
+  
+  # Makes classes aware of a file format by registering the file_format variable
+  module Awareness
+    
+    def self.included(base)
+      base.send(:attr_reader, :file_format)
     end
+    
+    def register_file_format(format)
+      @file_format = format
+    end
+  end  
+
+  # Base class for all log file format definitions. This class provides functions for subclasses to 
+  # define their LineDefinitions and to define a summary report.
+  #
+  # 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
       
+    # Registers the line definer instance for a subclass.
     def self.inherited(subclass)
        subclass.instance_variable_set(:@line_definer, RequestLogAnalyzer::LineDefinition::Definer.new)
        subclass.class_eval { class << self; attr_accessor :line_definer; end } 
-       subclass.class_eval { class << self; attr_accessor :report_definer; end }       
+       subclass.class_eval { class << self; attr_accessor :report_definer; end }
+       
+       unless subclass.const_defined?('Request')
+         subclass.const_set('Request', Class.new(RequestLogAnalyzer::Request))         
+       end
     end    
     
+    # Specifies a single line defintions.
     def self.line_definition(name, &block)
       @line_definer.send(name, &block)
     end
     
+    def create_request(*hashes)
+      self.class::Request.create(self, *hashes)
+    end
+    
+    # Specifies multiple line definitions at once using a block
     def self.format_definition(&block)
       if block_given?
         yield(@line_definer) 
@@ -32,48 +83,30 @@ module RequestLogAnalyzer
       end
     end
     
+    # Specifies the summary report using a block.
     def self.report(&block)
       @report_definer = RequestLogAnalyzer::Aggregator::Summarizer::Definer.new
       yield(@report_definer)
     end
 
-    def self.load(file_format)
-      if file_format.kind_of?(RequestLogAnalyzer::FileFormat)
-        # this already is a file format! return itself
-        return file_format
-
-      elsif file_format.kind_of?(Class) && file_format.ancestors.include?(RequestLogAnalyzer::FileFormat)
-        klass = file_format
-
-      elsif file_format.kind_of?(String) && File.exist?(file_format)
-        # load a format from a ruby file
-        require file_format
-        klass_name = File.basename(file_format, '.rb').split(/[^a-z0-9]/i).map{ |w| w.capitalize }.join('')
-        klass = Object.const_get(klass_name)
-
-      elsif File.exist?("#{File.dirname(__FILE__)}/file_format/#{file_format}.rb")
-        # load a provided file format
-        require "#{File.dirname(__FILE__)}/file_format/#{file_format}"
-        klass_name = file_format.to_s.split(/[^a-z0-9]/i).map{ |w| w.capitalize }.join('')
-        klass = RequestLogAnalyzer::FileFormat.const_get(klass_name)
-        
-      end
-      
-      klass.new # return an instance of the class
-    end
-    
+    # Returns all line definitions
     def line_definitions
       @line_definitions ||= self.class.line_definer.line_definitions
     end
     
+    # Returns all the defined trackers for the summary report.
     def report_trackers
       self.class.instance_variable_get(:@report_definer).trackers rescue []
     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 }
     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

data/lib/request_log_analyzer/filter/anonimize.rb

@@ -15,7 +15,7 @@ module RequestLogAnalyzer::Filter
     end
 
     def anonymize_url(value)
-      return value.sub(/^https?\:\/\/[A-z0-9\.-]+\//, "http://example.com/")
+      return value.sub(/^https?\:\/\/[A-Za-z0-9\.-]+\//, "http://example.com/")
     end
     
     def fuzz(value)

data/lib/request_log_analyzer/filter.rb

@@ -0,0 +1,38 @@
+module RequestLogAnalyzer::Filter
+  
+  # Filter class loader using const_missing
+  # This function will automatically load the class file based on the name of the class
+  def self.const_missing(const)
+    RequestLogAnalyzer::load_default_class_file(self, const)
+  end
+  
+  # Base filter class used to filter input requests.
+  # All filters should interit from this base.  
+  class Base
+    
+    include RequestLogAnalyzer::FileFormat::Awareness
+    
+    attr_reader :log_parser
+    attr_reader :options
+    
+    # Initializer
+    # <tt>format</tt> The file format
+    # <tt>options</tt> Are passed to the filters.
+    def initialize(format, options = {})
+      @options    = options
+      register_file_format(format)
+    end
+    
+    # Initialize the filter
+    def prepare
+    end
+    
+    # Return the request if the request should be kept.
+    # Return nil otherwise.
+    def filter(request)
+      return nil unless request
+      return request
+    end   
+  end
+  
+end

data/lib/request_log_analyzer/line_definition.rb

@@ -6,7 +6,7 @@ module RequestLogAnalyzer
     end
 
     def anonymizer_for_url(value, capture_definition)
-      value.sub(/^https?\:\/\/[A-z0-9\.-]+\//, "http://example.com/")
+      value.sub(/^https?\:\/\/[A-Za-z0-9\.-]+\//, "http://example.com/")
     end
   end  
   

data/lib/request_log_analyzer/output/fixed_width.rb

@@ -1,158 +1,174 @@
-class RequestLogAnalyzer::Output::FixedWidth < RequestLogAnalyzer::Output
+module RequestLogAnalyzer::Output
   
-  module Monochrome
-    def colorize(text, *options)
-      text
+  class FixedWidth < Base
+  
+    module Monochrome
+      def colorize(text, *options)
+        text
+      end
     end
-  end
   
-  module Color
+    module Color
     
-    STYLES = { :normal => 0, :bold => 1, :underscore => 4, :blink => 5, :inverse => 7, :concealed => 8 }
-    COLORS = { :black  => 0, :blue => 4, :green => 2, :cyan => 6, :red => 1, :purple => 5, :brown => 3, :white => 7 }
+      STYLES = { :normal => 0, :bold => 1, :underscore => 4, :blink => 5, :inverse => 7, :concealed => 8 }
+      COLORS = { :black  => 0, :blue => 4, :green => 2, :cyan => 6, :red => 1, :purple => 5, :brown => 3, :white => 7 }
     
-    def colorize(text, *options)
+      def colorize(text, *options)
     
-      font_style       = ''
-      foreground_color = '0'
-      background_color = ''
+        font_style       = ''
+        foreground_color = '0'
+        background_color = ''
       
-      options.each do |option|
-        if option.kind_of?(Symbol)
-          foreground_color = "3#{COLORS[option]}" if COLORS.include?(option)
-          font_style       = "#{STYLES[option]};" if STYLES.include?(option)          
-        elsif option.kind_of?(Hash)
-          options.each do |key, value|
-            case key
-            when :color;      foreground_color = "3#{COLORS[value]}"  if COLORS.include?(value)
-            when :background; background_color = "4#{COLORS[value]};" if COLORS.include?(value)
-            when :on;         background_color = "4#{COLORS[value]};" if COLORS.include?(value)
-            when :style;      font_style       = "#{STYLES[value]};"  if STYLES.include?(value)
+        options.each do |option|
+          if option.kind_of?(Symbol)
+            foreground_color = "3#{COLORS[option]}" if COLORS.include?(option)
+            font_style       = "#{STYLES[option]};" if STYLES.include?(option)          
+          elsif option.kind_of?(Hash)
+            options.each do |key, value|
+              case key
+              when :color;      foreground_color = "3#{COLORS[value]}"  if COLORS.include?(value)
+              when :background; background_color = "4#{COLORS[value]};" if COLORS.include?(value)
+              when :on;         background_color = "4#{COLORS[value]};" if COLORS.include?(value)
+              when :style;      font_style       = "#{STYLES[value]};"  if STYLES.include?(value)
+              end
             end
           end
         end
+        return "\e[#{background_color}#{font_style}#{foreground_color}m#{text}\e[0m"
       end
-      return "\e[#{background_color}#{font_style}#{foreground_color}m#{text}\e[0m"
-    end
     
-  end
+    end
   
-  attr_reader :characters
+    attr_reader :characters
   
-  CHARACTERS = {
-    :ascii => { :horizontal_line => '-', :vertical_line => '|', :block => '=' },
-    :utf   => { :horizontal_line => '━', :vertical_line => '┃', :block => '░' }
-  }
+    CHARACTERS = {
+      :ascii => { :horizontal_line => '-', :vertical_line => '|', :block => '=' },
+      :utf   => { :horizontal_line => '━', :vertical_line => '┃', :block => '░' }
+    }
   
-  def initialize(io, options = {})
-    super(io, options)
-    @options[:width]      ||= 80
-    @options[:characters] ||= :utf
-    @characters = CHARACTERS[@options[:characters]]
+    def initialize(io, options = {})
+      super(io, options)
+      @options[:width]      ||= 80
+      @options[:characters] ||= :utf
+      @characters = CHARACTERS[@options[:characters]]
     
-    color_module = @options[:color] ? Color : Monochrome
-    (class << self; self; end).send(:include, color_module) 
-  end
+      color_module = @options[:color] ? Color : Monochrome
+      (class << self; self; end).send(:include, color_module) 
+    end
   
-  def print(str)
-    @io << str
-  end
+    def print(str)
+      @io << str
+    end
   
-  alias :<< :print
+    alias :<< :print
   
-  def puts(str = '')
-    @io << str << "\n"
-  end
+    def puts(str = '')
+      @io << str << "\n"
+    end
   
-  def title(title)
-    puts
-    puts colorize(title, :bold, :white)
-    line(:green)
-  end
+    def title(title)
+      puts
+      puts colorize(title, :bold, :white)
+      line(:green)
+    end
     
-  def line(*font)  
-    puts colorize(characters[:horizontal_line] * @options[:width], *font)
-  end
+    def line(*font)  
+      puts colorize(characters[:horizontal_line] * @options[:width], *font)
+    end
   
-  def link(text, url = nil)
-    if url.nil?
-      colorize(text, :blue, :bold)
-    else
-      "#{text} (#{colorize(url, :blue, :bold)})"
+    def link(text, url = nil)
+      if url.nil?
+        colorize(text, :blue, :bold)
+      else
+        "#{text} (#{colorize(url, :blue, :bold)})"
+      end
+    end
+    
+    def header
+      if io.kind_of?(File)
+        puts "Request-log-analyzer summary report"
+        line
+        puts "Version #{RequestLogAnalyzer::VERSION} - written by Willem van Bergen and Bart ten Brinke"
+        puts "Request-log-analyzer website: http://github.com/wvanbergen/request-log-analyzer"
+      end
+    end
+    
+    def footer
+      puts
+      puts "Thanks for using request-log-analyzer!"
     end
-  end
     
-  def table(*columns, &block)
+    def table(*columns, &block)
     
-    rows = Array.new
-    yield(rows)
+      rows = Array.new
+      yield(rows)
 
-    # determine maximum cell widths
-    max_cell_widths = rows.inject(Array.new(columns.length, 0)) do |result, row|
-      lengths = row.map { |column| column.to_s.length }
-      result.each_with_index { |length, index| result[index] = ([length, lengths[index]].max rescue length) }
-    end
-    columns.each_with_index { |col, index| col[:actual_width] ||= max_cell_widths[index] }
+      # determine maximum cell widths
+      max_cell_widths = rows.inject(Array.new(columns.length, 0)) do |result, row|
+        lengths = row.map { |column| column.to_s.length }
+        result.each_with_index { |length, index| result[index] = ([length, lengths[index]].max rescue length) }
+      end
+      columns.each_with_index { |col, index| col[:actual_width] ||= max_cell_widths[index] }
     
-    # determine actual column width
-    column_widths = columns.map do |column|
-      if column[:width] == :rest
-        nil
-      elsif column[:width]
-        column[:width]
-      elsif column[:min_width]
-        [column[:min_width], column[:actual_width]].max
-      elsif column[:max_width]
-        [column[:max_width], column[:actual_width]].min
-      else
-        column[:actual_width]
+      # determine actual column width
+      column_widths = columns.map do |column|
+        if column[:width] == :rest
+          nil
+        elsif column[:width]
+          column[:width]
+        elsif column[:min_width]
+          [column[:min_width], column[:actual_width]].max
+        elsif column[:max_width]
+          [column[:max_width], column[:actual_width]].min
+        else
+          column[:actual_width]
+        end
       end
-    end
      
-    if column_widths.include?(nil)
-      width_left = options[:width] - ((columns.length - 1) * (style[:cell_separator] ? 3 : 1)) - column_widths.compact.inject(0) { |sum, col| sum + col}
-      column_widths[column_widths.index(nil)] = width_left
-    end
-    
-    # Print table header
-    if table_has_header?(columns)
-      column_titles = []
-      columns.each_with_index do |column, index|
-        width = column_widths[index]        
-        alignment = (column[:align] == :right ? '' : '-')
-        column_titles.push(colorize("%#{alignment}#{width}s" % column[:title].to_s[0...width], :bold))
+      if column_widths.include?(nil)
+        width_left = options[:width] - ((columns.length - 1) * (style[:cell_separator] ? 3 : 1)) - column_widths.compact.inject(0) { |sum, col| sum + col}
+        column_widths[column_widths.index(nil)] = width_left
       end
+    
+      # Print table header
+      if table_has_header?(columns)
+        column_titles = []
+        columns.each_with_index do |column, index|
+          width = column_widths[index]        
+          alignment = (column[:align] == :right ? '' : '-')
+          column_titles.push(colorize("%#{alignment}#{width}s" % column[:title].to_s[0...width], :bold))
+        end
       
-      puts
-      puts column_titles.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')
-      line(:green)
-    end
+        puts column_titles.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')
+        line(:green)
+      end
     
-    rows.each do |row|
-      row_values = []
-      columns.each_with_index do |column, index|
-        width = column_widths[index]
-        case column[:type]
-        when :ratio
-          if width > 4
-            if column[:treshold] && column[:treshold] < row[index].to_f
-              bar = ''
-              bar << characters[:block] * (width.to_f * column[:treshold]).round 
-              bar << colorize(characters[:block] * (width.to_f * (row[index].to_f - column[:treshold])).round, :red) 
-              row_values.push(bar) 
+      rows.each do |row|
+        row_values = []
+        columns.each_with_index do |column, index|
+          width = column_widths[index]
+          case column[:type]
+          when :ratio
+            if width > 4
+              if column[:treshold] && column[:treshold] < row[index].to_f
+                bar = ''
+                bar << characters[:block] * (width.to_f * column[:treshold]).round 
+                bar << colorize(characters[:block] * (width.to_f * (row[index].to_f - column[:treshold])).round, :red) 
+                row_values.push(bar) 
+              else
+                row_values.push(characters[:block] * (width.to_f * row[index].to_f).round) 
+              end
             else
-              row_values.push(characters[:block] * (width.to_f * row[index].to_f).round) 
+              row_values.push('')
             end
           else
-            row_values.push('')
+            alignment = (columns[index][:align] == :right ? '' : '-')        
+            row_values.push("%#{alignment}#{width}s" % row[index].to_s[0...width])
           end
-        else
-          alignment = (columns[index][:align] == :right ? '' : '-')        
-          row_values.push("%#{alignment}#{width}s" % row[index].to_s[0...width])
         end
+        puts row_values.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')      
       end
-      puts row_values.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')      
     end
-  end
   
+  end
 end