request-log-analyzer 1.3.4 → 1.4.0

data/lib/request_log_analyzer/filter.rb

@@ -1,34 +1,30 @@
 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.  
+  # All filters should interit from this base.
   class Base
-    
-    include RequestLogAnalyzer::FileFormat::Awareness
-    
-    attr_reader :log_parser
-    attr_reader :options
-    
+
+    attr_reader :file_format, :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)
+      @file_format = format
+      @options     = options
     end
-    
+
     # Return the request if the request should be kept.
     # Return nil otherwise.
     def filter(request)
-      return nil unless request
-      return request
-    end   
+      request
+    end
   end
-  
+
 end

data/lib/request_log_analyzer/line_definition.rb

@@ -1,14 +1,14 @@
 module RequestLogAnalyzer
-  
+
   # The line definition class is used to specify what lines should be parsed from the log file.
   # It contains functionality to match a line against the definition and parse the information
   # from this line. This is used by the LogParser class when parsing a log file..
   class LineDefinition
 
     class Definer
-      
+
       attr_accessor :line_definitions
-      
+
       def initialize
         @line_definitions = {}
       end
@@ -16,7 +16,7 @@ module RequestLogAnalyzer
       def initialize_copy(other)
         @line_definitions = other.line_definitions.dup
       end
-      
+
       def method_missing(name, *args, &block)
         if block_given?
           @line_definitions[name] = RequestLogAnalyzer::LineDefinition.define(name, &block)
@@ -29,25 +29,26 @@ module RequestLogAnalyzer
     attr_reader :name
     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 = {})
       @name     = name
       @captures = []
+      @teaser   = nil
       definition.each { |key, value| self.send("#{key.to_s}=".to_sym, value) }
     end
-        
+
     def self.define(name, &block)
       definition = self.new(name)
       yield(definition) if block_given?
       return definition
     end
-    
-    # Checks whether a given line matches this definition. 
+
+    # Checks whether a given line matches this definition.
     # It will return false if a line does not match. If the line matches, a hash is returned
     # 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
@@ -66,7 +67,7 @@ module RequestLogAnalyzer
         return false
       end
     end
-    
+
     alias :=~ :matches
 
     # matches the line and converts the captured values using the request's
@@ -84,17 +85,17 @@ module RequestLogAnalyzer
     def convert_captured_values(values, request)
       value_hash = {}
       captures.each_with_index do |capture, index|
-        
+
         # convert the value using the request convert_value function
         converted = request.convert_value(values[index], capture)
         value_hash[capture[:name]] ||= converted
-        
+
         # Add items directly to the resulting hash from the converted value
         # if it is a hash and they are set in the :provides hash for this line definition
         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
       end
       return value_hash
@@ -106,5 +107,5 @@ module RequestLogAnalyzer
     end
 
   end
-  
+
 end

data/lib/request_log_analyzer/log_processor.rb

@@ -1,55 +1,53 @@
 module RequestLogAnalyzer
-  
+
   # The Logprocessor class is used to perform simple processing actions over log files.
-  # It will go over the log file/stream line by line, pass the line to a processor and 
-  # write the result back to the output file or stream. The processor can alter the 
+  # It will go over the log file/stream line by line, pass the line to a processor and
+  # write the result back to the output file or stream. The processor can alter the
   # contents of the line, remain it intact or remove it altogether, based on the current
   # file format
   #
   # Currently, one processors is supported:
-  #  * :strip will remove all irrelevent lines (according to the file format) from the 
+  #  * :strip will remove all irrelevent lines (according to the file format) from the
   #    sources. A compact, information packed log will remain/.
   #
   class LogProcessor
-    
-    include RequestLogAnalyzer::FileFormat::Awareness
-    
-    attr_reader :mode, :options, :sources
+
+    attr_reader :mode, :options, :sources, :file_format
     attr_accessor :output_file
-   
+
     # Builds a logprocessor instance from the arguments given on the command line
-    # <tt>command</tt> The command hat was used to start the log processor. This will set the 
+    # <tt>command</tt> The command hat was used to start the log processor. This will set the
     #    processing mode. Currently, only :strip is supported.
     # <tt>arguments</tt> The parsed command line arguments (a CommandLine::Arguments instance)
     def self.build(command, arguments)
-      
-      options = { 
-          :discard_teaser_lines => arguments[:discard_teaser_lines], 
-          :keep_junk_lines      => arguments[:keep_junk_lines], 
+
+      options = {
+          :discard_teaser_lines => arguments[:discard_teaser_lines],
+          :keep_junk_lines      => arguments[:keep_junk_lines],
         }
-          
+
       log_processor = RequestLogAnalyzer::LogProcessor.new(arguments[:format].to_sym, command, options)
       log_processor.output_file = arguments[:output] if arguments[:output]
 
       arguments.parameters.each do |input|
         log_processor.sources << input
       end
-      
+
       return log_processor
     end
-    
+
     # Initializes a new LogProcessor instance.
     # <tt>format</tt> The file format to use (e.g. :rails).
     # <tt>mode</tt> The processing mode
     # <tt>options</tt> A hash with options to take into account
     def initialize(format, mode, options = {})
-      @options = options
-      @mode    = mode
-      @sources = []
+      @options     = options
+      @mode        = mode
+      @sources     = []
+      @file_format = format
       $output_file = nil
-      self.register_file_format(format)
     end
-    
+
     # Processes input files by opening it and sending the filestream to <code>process_io</code>,
     # in which the actual processing is performed.
     # <tt>file</tt> The file to process
@@ -65,7 +63,7 @@ module RequestLogAnalyzer
         when :strip;     io.each_line { |line| @output << strip_line(line) }
       end
     end
-    
+
     # Returns the line itself if the string matches any of the line definitions. If no match is
     # found, an empty line is returned, which will strip the line from the output.
     # <tt>line</tt> The line to strip
@@ -74,25 +72,25 @@ module RequestLogAnalyzer
     end
 
     # Runs the log processing by setting up the output stream and iterating over all the
-    # input sources. Input sources can either be filenames (String instances) or IO streams 
+    # input sources. Input sources can either be filenames (String instances) or IO streams
     # (IO instances). The strings "-" and "STDIN" will be substituted for the $stdin variable.
     def run!
       if @output_file.nil?
-        @output = $stdout 
+        @output = $stdout
       else
-        @output = File.new(@output_file, 'a')        
+        @output = File.new(@output_file, 'a')
       end
-      
+
       @sources.each do |source|
         if source.kind_of?(String) && File.exist?(source)
           process_file(source)
         elsif source.kind_of?(IO)
           process_io(source)
         elsif ['-', 'STDIN'].include?(source)
-          process_io($stdin)        
+          process_io($stdin)
         end
       end
-    
+
     ensure
       @output.close if @output.kind_of?(File)
     end

data/lib/request_log_analyzer/mailer.rb

@@ -1,21 +1,23 @@
 module RequestLogAnalyzer
 
   class Mailer
-    
+
     attr_accessor :data, :to, :host
-    
+
     # Initialize a mailer
     # <tt>to</tt> to address
     # <tt>host</tt> the mailer host
     # <tt>options</tt> Specific style options
+    # Options
+    # <tt>:debug</tt> Do not actually mail
     def initialize(to, host = 'localhost', options = {})
-      require 'net/smtp' 
+      require 'net/smtp'
       @to      = to
       @host    = host
       @options = options
       @data    = []
     end
-    
+
     def mail
       from        = @options[:from]        || 'contact@railsdoctors.com'
       from_alias  = @options[:from_alias]  || 'Request-log-analyzer reporter'
@@ -28,16 +30,20 @@ Subject: #{subject}
 
 #{@data.to_s}
 END_OF_MESSAGE
-      
-      Net::SMTP.start(@host) do |smtp|
-        smtp.send_message msg, from, to
+    
+      unless @options[:debug]
+        Net::SMTP.start(@host) do |smtp|
+          smtp.send_message msg, from, to
+        end
       end
+
+      return [msg, from, to] 
     end
-  
+
     def << string
       data << string
     end
-    
+
     def puts string
       data << string
     end

data/lib/request_log_analyzer/output/fixed_width.rb

@@ -1,23 +1,23 @@
 # coding: utf-8
 module RequestLogAnalyzer::Output
-  
+
   # Fixed Width output class.
   # Outputs a fixed width ASCII or UF8 report.
   class FixedWidth < Base
-  
+
     # Mixin module. Will disable any colorizing.
     module Monochrome
       def colorize(text, *options)
         text
       end
     end
-  
+
     # Colorize module
     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 }
-    
+
       # Colorize text
       # <tt>text</tt> The text to colorize
       # Options
@@ -25,18 +25,18 @@ module RequestLogAnalyzer::Output
       #  * <tt>:color</tt> The foreground color to paint. Defined in Color::COLORS
       #  * <tt>:on</tt> Alias for :background
       #  * <tt>:style</tt> Font style, defined in Color::STYLES
-      # 
+      #
       # Returns ASCII colored string
       def colorize(text, *options)
-    
+
         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)          
+            font_style       = "#{STYLES[option]};" if STYLES.include?(option)
           elsif option.kind_of?(Hash)
             options.each do |key, value|
               case key
@@ -50,16 +50,16 @@ module RequestLogAnalyzer::Output
         end
         return "\e[#{background_color}#{font_style}#{foreground_color}m#{text}\e[0m"
       end
-    
+
     end
-  
+
     attr_reader :characters
-  
+
     CHARACTERS = {
       :ascii => { :horizontal_line => '-', :vertical_line => '|', :block => '=' },
       :utf   => { :horizontal_line => '━', :vertical_line => '┃', :block => '░' }
     }
-  
+
     # Initialize a report
     # <tt>io</tt> iO Object (file, STDOUT, etc.)
     # <tt>options</tt>
@@ -71,25 +71,25 @@ module RequestLogAnalyzer::Output
       @options[:width]      ||= 80
       @options[:characters] ||= :utf
       @characters = CHARACTERS[@options[:characters]]
-    
+
       color_module = @options[:color] ? Color : Monochrome
-      (class << self; self; end).send(:include, color_module) 
+      (class << self; self; end).send(:include, color_module)
     end
-  
+
     # Write a string to the output object.
     # <tt>str</tt> The string to write.
     def print(str)
       @io << str
     end
-  
+
     alias :<< :print
-  
+
     # Write a string to the output object with a newline at the end.
     # <tt>str</tt> The string to write.
     def puts(str = '')
       @io << str << "\n"
     end
-  
+
     # Write the title of a report
     # <tt>title</tt> The title to write
     def title(title)
@@ -97,14 +97,14 @@ module RequestLogAnalyzer::Output
       puts colorize(title, :bold, :white)
       line(:green)
     end
-    
+
     # Write a line
-    def line(*font)  
+    def line(*font)
       puts colorize(characters[:horizontal_line] * @options[:width], *font)
     end
 
     # Write a link
-    # <tt>text</tt> The text in the link
+    # <tt>text</tt> The text in the link, or the URL itself if no text is given
     # <tt>url</tt> The url to link to.
     def link(text, url = nil)
       if url.nil?
@@ -113,30 +113,31 @@ module RequestLogAnalyzer::Output
         "#{text} (#{colorize(url, :blue, :bold)})"
       end
     end
-    
-    # Generate a header for a report    
+
+    # Generate a header for a report
     def header
       if io.kind_of?(File)
-        puts "Request-log-analyzer summary report"
-        line
+        puts colorize("Request-log-analyzer summary report", :white, :bold)
+        line(:green)
         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"
+        puts "Website: #{link('http://github.com/wvanbergen/request-log-analyzer')}"
       end
     end
-    
+
     # Generate a footer for a report
     def footer
       puts
       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!"
+      puts "Mail to #{link('contact@railsdoctors.com')} or visit us at #{link('http://railsdoctors.com')}."
+      line(:green)
+      puts "Thanks for using #{colorize('request-log-analyzer', :white, :bold)}!"
     end
-    
+
     # Generate a report table and push it into the output object.
     # <tt>*colums<tt> Columns hash
     # <tt>&block</tt>: A block yeilding the rows.
     def table(*columns, &block)
-    
+
       rows = Array.new
       yield(rows)
 
@@ -146,7 +147,7 @@ module RequestLogAnalyzer::Output
         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
@@ -161,29 +162,28 @@ module RequestLogAnalyzer::Output
           column[:actual_width]
         end
       end
-     
+
       if column_widths.include?(nil)
         fill_column = columns[column_widths.index(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)] = case fill_column[:type]
-          when :ratio; width_left # max out
-          else;        [width_left, fill_column[:actual_width]].min
-        end
+        column_widths[column_widths.index(nil)] = width_left
       end
-    
+
+      line(:green) if @style[:top_line]
+
       # Print table header
       if table_has_header?(columns)
         column_titles = []
         columns.each_with_index do |column, index|
-          width = column_widths[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 column_titles.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')
         line(:green)
       end
-    
+
       # Print the rows
       rows.each do |row|
         row_values = []
@@ -194,12 +194,12 @@ module RequestLogAnalyzer::Output
             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) 
+                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
                 # Create a bar by combining block characters
-                row_values.push(characters[:block] * (width.to_f * row[index].to_f).round) 
+                row_values.push(characters[:block] * (width.to_f * row[index].to_f).round)
               end
             else
               # Too few characters for a ratio bar. Display nothing
@@ -212,9 +212,9 @@ module RequestLogAnalyzer::Output
             row_values.push(cell_value)
           end
         end
-        puts row_values.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')      
+        puts row_values.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')
       end
     end
-  
+
   end
 end

data/lib/request_log_analyzer/output/html.rb

@@ -1,12 +1,12 @@
 module RequestLogAnalyzer::Output
-  
+
   # HTML Output class. Generated a HTML-formatted report, including CSS.
   class HTML < Base
-  
+
     # def initialize(io, options = {})
     #   super(io, options)
     # end
-  
+
     # Print a string to the io object.
     def print(str)
       @io << str
@@ -26,10 +26,10 @@ module RequestLogAnalyzer::Output
 
     # Render a single line
     # <tt>*font</tt> The font.
-    def line(*font)  
+    def line(*font)
       @io.puts(tag(:hr))
     end
-    
+
     # Write a link
     # <tt>text</tt> The text in the link
     # <tt>url</tt> The url to link to.
@@ -44,29 +44,29 @@ module RequestLogAnalyzer::Output
     def table(*columns, &block)
       rows = Array.new
       yield(rows)
-    
+
       @io << tag(:table, {:id => 'mytable', :cellspacing => 0}) do |content|
         if table_has_header?(columns)
           content << tag(:tr) do
             columns.map { |col| tag(:th, col[:title]) }.join("\n")
           end
         end
-      
+
         odd = false
         rows.each do |row|
           odd = !odd
           content << tag(:tr) do
             if odd
-              row.map { |cell| tag(:td, cell, :class => 'alt') }.join("\n") 
+              row.map { |cell| tag(:td, cell, :class => 'alt') }.join("\n")
             else
-              row.map { |cell| tag(:td, cell) }.join("\n") 
+              row.map { |cell| tag(:td, cell) }.join("\n")
             end
           end
         end
       end
-    
+
     end
-  
+
     # Genrate HTML header and associated stylesheet
     def header
       @io << "<html>"
@@ -85,13 +85,13 @@ module RequestLogAnalyzer::Output
         a {
         	color: #c75f3e;
         }
-      
+
         .color_bar {
           border: 1px solid;
           height:10px;
         	background: #CAE8EA;
         }
-      
+
         #mytable {
         	width: 700px;
         	padding: 0;
@@ -101,7 +101,7 @@ module RequestLogAnalyzer::Output
 
         caption {
         	padding: 0 0 5px 0;
-        	width: 700px;	 
+        	width: 700px;	
         	font: italic 11px "Trebuchet MS", Verdana, Arial, Helvetica, sans-serif;
         	text-align: right;
         }
@@ -138,7 +138,7 @@ module RequestLogAnalyzer::Output
       @io << tag(:h1, 'Request-log-analyzer summary report')
       @io << tag(:p, "Version #{RequestLogAnalyzer::VERSION} - written by Willem van Bergen and Bart ten Brinke")
     end
-  
+
     # Generate a footer for a report
     def footer
       @io << tag(:hr) << tag(:h2, 'Thanks for using request-log-analyzer')
@@ -146,9 +146,9 @@ module RequestLogAnalyzer::Output
       @io << tag(:p, 'If you need an expert who can analyze your application, mail to ' + link('contact@railsdoctors.com', 'mailto:contact@railsdoctors.com') + ' or visit us at ' + link('http://railsdoctors.com', 'http://railsdoctors.com') + '.')
       @io << "</body></html>\n"
     end
-  
-    protected 
-  
+
+    protected
+
     # HTML tag writer helper
     # <tt>tag</tt> The tag to generate
     # <tt>content</tt> The content inside the tag
@@ -158,7 +158,7 @@ module RequestLogAnalyzer::Output
         attributes = content.nil? ? '' : ' ' + content.map { |(key, value)| "#{key}=\"#{value}\"" }.join(' ')
         content_string = ''
         content = yield(content_string)
-        content = content_string unless content_string.empty? 
+        content = content_string unless content_string.empty?
         "<#{tag}#{attributes}>#{content}</#{tag}>"
       else
         attributes = attributes.nil? ? '' : ' ' + attributes.map { |(key, value)| "#{key}=\"#{value}\"" }.join(' ')
@@ -172,6 +172,6 @@ module RequestLogAnalyzer::Output
           end
         end
       end
-    end  
+    end
   end
 end