request-log-analyzer 1.3.7 → 1.4.0

data/lib/request_log_analyzer/filter/field.rb

@@ -1,24 +1,24 @@
 module RequestLogAnalyzer::Filter
-  
+
   # Filter to select or reject a specific field
   # Options
   # * <tt>:mode</tt> :reject or :accept.
   # * <tt>:field</tt> Specific field to accept or reject.
   # * <tt>:value</tt> Value that the field should match to be accepted or rejected.
   class Field < Base
-   
+
     attr_reader :field, :value, :mode
-   
+
     def initialize(file_format, options = {})
       super(file_format, options)
       setup_filter
     end
-   
+
     # Setup mode, field and value.
     def setup_filter
       @mode = (@options[:mode] || :accept).to_sym
       @field = @options[:field].to_sym
-      
+
       # Convert the timestamp to the correct formats for quick timestamp comparisons
       if @options[:value].kind_of?(String) && @options[:value][0, 1] == '/' && @options[:value][-1, 1] == '/'
         @value = Regexp.new(@options[:value][1..-2])
@@ -26,17 +26,17 @@ module RequestLogAnalyzer::Filter
         @value = @options[:value] # TODO: convert value?
       end
     end
-    
+
     # Keep request if @mode == :select and request has the field and value.
     # Drop request if @mode == :reject and request has the field and value.
     # Returns nil otherwise.
     # <tt>request</tt> Request Object
     def filter(request)
-      found_field = request.every(@field).any? { |value| @value === value.to_s }      
+      found_field = request.every(@field).any? { |value| @value === value.to_s }
       return nil if !found_field && @mode == :select
       return nil if found_field && @mode == :reject
       return request
-    end 
+    end
   end
-  
+
 end

data/lib/request_log_analyzer/filter/timespan.rb

@@ -1,26 +1,28 @@
 module RequestLogAnalyzer::Filter
-  
+
   # Reject all requests not in given timespan
   # Options
   # * <tt>:after</tt> Only keep requests after this DateTime.
   # * <tt>:before</tt> Only keep requests before this DateTime.
   class Timespan < Base
-   
+
     attr_reader :before, :after
-   
+
     def initialize(file_format, options = {})
+      @after  = nil
+      @before = nil
       super(file_format, options)
       setup_filter
     end
-   
-   
+
+
     # Convert the timestamp to the correct formats for quick timestamp comparisons.
     # These are stored in the before and after attr_reader fields.
     def setup_filter
-      @after  = @options[:after].strftime('%Y%m%d%H%M%S').to_i  if options[:after]     
+      @after  = @options[:after].strftime('%Y%m%d%H%M%S').to_i  if options[:after]
       @before = @options[:before].strftime('%Y%m%d%H%M%S').to_i if options[:before]
     end
-    
+
     # Returns request if:
     #   * @after <= request.timestamp <= @before
     #   * @after <= request.timestamp
@@ -32,12 +34,12 @@ module RequestLogAnalyzer::Filter
         return request
       elsif @after && @before.nil? && @after <= request.timestamp
         return request
-      elsif @before && @after.nil? && request.timestamp <= @before 
+      elsif @before && @after.nil? && request.timestamp <= @before
         return request
       end
 
       return nil
-    end 
+    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,41 +1,41 @@
 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
-    
+
     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
@@ -47,7 +47,7 @@ module RequestLogAnalyzer
       @file_format = format
       $output_file = nil
     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
@@ -63,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
@@ -72,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.rb

@@ -5,13 +5,49 @@ module RequestLogAnalyzer::Output
   def self.const_missing(const)
     RequestLogAnalyzer::load_default_class_file(self, const)
   end
+
+  # Loads a Output::Base subclass instance.
+  def self.load(file_format, *args)
+    
+    klass = nil
+    if file_format.kind_of?(RequestLogAnalyzer::Output::Base)
+      # this already is a file format! return itself
+      return file_format
+
+    elsif file_format.kind_of?(Class) && file_format.ancestors.include?(RequestLogAnalyzer::Output::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
+      const = RequestLogAnalyzer::to_camelcase(File.basename(file_format, '.rb'))
+      if RequestLogAnalyzer::FileFormat.const_defined?(const)
+        klass = RequestLogAnalyzer::Output.const_get(const)
+      elsif Object.const_defined?(const)
+        klass = Object.const_get(const)
+      else
+        raise "Cannot load class #{const} from #{file_format}!"
+      end
+
+    else
+      # load a provided file format
+      klass = RequestLogAnalyzer::Output.const_get(RequestLogAnalyzer::to_camelcase(file_format))
+    end
+
+    # check the returned klass to see if it can be used
+    raise "Could not load a file format from #{file_format.inspect}" if klass.nil?
+    raise "Invalid FileFormat class" unless klass.kind_of?(Class) && klass.ancestors.include?(RequestLogAnalyzer::Output::Base)
+
+    klass.create(*args) # return an instance of the class
+  end
   
   # Base Class used for generating output for reports.
   # All output should inherit fromt this class.
   class Base
-    
+
     attr_accessor :io, :options, :style
-    
+
     # Initialize a report
     # <tt>io</tt> iO Object (file, STDOUT, etc.)
     # <tt>options</tt> Specific style options
@@ -27,32 +63,37 @@ module RequestLogAnalyzer::Output
       @style = @style.merge(temp_style)
       yield(self) if block_given?
       @style = old_style
-    end    
-    
+    end
+
     # Generate a header for a report
     def header
     end
-    
-    # Generate the footer of a report 
+
+    # Generate the footer of a report
     def footer
     end
 
+    def slice_results(array)
+      return array if options[:amount] == :all
+      return array.slice(0, options[:amount]) # otherwise
+    end
+
     # Generate a report table and push it into the output object.
     # Yeilds a rows array into which the rows can be pushed
     # <tt>*colums<tt> Array of Column hashes (see Column options).
     # <tt>&block</tt>: A block yeilding the rows.
-    # 
+    #
     # === Column options
     # Columns is an array of hashes containing the column definitions.
     # * <tt>:align</tt> Alignment :left or :right
     # * <tt>:treshold</tt> Width in characters or :rest
     # * <tt>:type</tt> :ratio or nil
     # * <tt>:width</tt> Width in characters or :rest
-    # 
+    #
     # === Example
     # The output object should support table definitions:
     #
-    # output.table({:align => :left}, {:align => :right }, {:align => :right}, {:type => :ratio, :width => :rest}) do |rows|        
+    # output.table({:align => :left}, {:align => :right }, {:align => :right}, {:type => :ratio, :width => :rest}) do |rows|
     #   sorted_frequencies.each do |(cat, count)|
     #     rows << [cat, "#{count} hits", '%0.1f%%' % ((count.to_f / total_hits.to_f) * 100.0), (count.to_f / total_hits.to_f)]
     #   end
@@ -60,13 +101,13 @@ module RequestLogAnalyzer::Output
     #
     def table(*columns, &block)
     end
-    
+
     protected
     # Check if a given table defination hash includes a header (title)
     # <tt>columns</tt> The columns hash
     def table_has_header?(columns)
-      columns.any? { |column| !column[:title].nil? } 
+      columns.any? { |column| !column[:title].nil? }
     end
-    
+
   end
 end