request-log-analyzer 1.1.1 → 1.2.0

data/lib/request_log_analyzer/file_format/rails_development.rb

@@ -1,112 +1,57 @@
 module RequestLogAnalyzer::FileFormat
   
-  class RailsDevelopment < Base
+  # The RailsDevelopment FileFormat is an extention to the default Rails file format. It includes
+  # all lines of the normal Rails file format, but parses SQL queries and partial rendering lines
+  # as well.
+  class RailsDevelopment < Rails
   
-    # Processing EmployeeController#index (for 123.123.123.123 at 2008-07-13 06:00:00) [GET]
-    line_definition :processing do |line|
-      line.header = true # this line is the first log line for a request 
-      line.teaser = /Processing /
-      line.regexp = /Processing ((?:\w+::)?\w+)#(\w+)(?: to (\w+))? \(for (\d+\.\d+\.\d+\.\d+) at (\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d)\) \[([A-Z]+)\]/
-      line.captures << { :name => :controller, :type  => :string } \
-                    << { :name => :action,     :type  => :string } \
-                    << { :name => :format,     :type  => :string } \
-                    << { :name => :ip,         :type  => :string, :anonymize => :ip } \
-                    << { :name => :timestamp,  :type  => :timestamp, :anonymize => :slightly } \
-                    << { :name => :method,     :type  => :string }
-    end
-
-    # Filter chain halted as [#<ActionController::Caching::Actions::ActionCacheFilter:0x2a999ad620 @check=nil, @options={:store_options=>{}, :layout=>nil, :cache_path=>#<Proc:0x0000002a999b8890@/app/controllers/cached_controller.rb:8>}>] rendered_or_redirected.    
-    line_definition :cache_hit do |line|
-      line.regexp = /Filter chain halted as \[\#<ActionController::Caching::Actions::ActionCacheFilter:.+>\] rendered_or_redirected/
+    #   Parameters: {"action"=>"demo", "controller"=>"page"}
+    line_definition :parameters do |line|
+      line.teaser = /Parameters/
+      line.regexp = /\s+Parameters:\s+(\{.*\})/
+      line.captures << { :name => :params, :type => :eval }
     end
   
     # Rendered layouts/_footer (2.9ms)
     line_definition :rendered do |line|
-      line.teaser = /Rendered /
       line.regexp = /Rendered (\w+(?:\/\w+)+) \((\d+\.\d+)ms\)/
       line.captures << { :name => :render_file,     :type  => :string } \
-                    << { :name => :render_duration, :type  => :msec }
+                    << { :name => :render_duration, :type  => :duration, :unit => :msec }
     end
   
     #  User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) 
     line_definition :query_executed do |line|
-      line.regexp = /\s+(?:\e\[4;36;1m)?((?:\w+::)*\w+) Load \((\d+\.\d+)ms\)(?:\e\[0m)?\s+(?:\e\[0;1m)?(.+) (?:\e\[0m)?/
+      line.regexp = /\s+(?:\e\[4;36;1m)?((?:\w+::)*\w+) Load \((\d+\.\d+)ms\)(?:\e\[0m)?\s+(?:\e\[0;1m)?([^\e]+) ?(?:\e\[0m)?/
       line.captures << { :name => :query_class,    :type  => :string } \
-                    << { :name => :query_duration, :type  => :msec } \
-                    << { :name => :query_sql,      :type  => :string }
+                    << { :name => :query_duration, :type  => :duration, :unit => :msec } \
+                    << { :name => :query_sql,      :type  => :sql }
     end
 
     #  CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0)   
     line_definition :query_cached do |line|
-      line.teaser = /\s+(?:\e\[4;35;1m)?CACHE \((\d+\.\d+)ms\)(?:\e\[0m)?\s+(?:\e\[0m)?(.+) (?:\e\[0m)?/  
-      line.regexp = /\s+(?:\e\[4;35;1m)?CACHE \((\d+\.\d+)ms\)(?:\e\[0m)?\s+(?:\e\[0m)?(.+) (?:\e\[0m)?/
-      line.captures << { :name => :cached_duration, :type  => :msec } \
-                    << { :name => :cached_sql,      :type  => :string }
+      line.regexp = /\s+(?:\e\[4;35;1m)?CACHE \((\d+\.\d+)ms\)(?:\e\[0m)?\s+(?:\e\[0m)?([^\e]+) ?(?:\e\[0m)?/
+      line.captures << { :name => :cached_duration, :type  => :duration, :unit => :msec } \
+                    << { :name => :cached_sql,      :type  => :sql }
     end  
-  
-    # RuntimeError (Cannot destroy employee):  /app/models/employee.rb:198:in `before_destroy' 
-    line_definition :failed do |line|
-      line.footer = true
-      line.regexp = /((?:[A-Z]\w+\:\:)*[A-Z]\w+) \((.*)\)(?: on line #(\d+) of .+)?\:(.*)/
-      line.captures << { :name => :error,       :type => :string } \
-                    << { :name => :message,     :type => :string } \
-                    << { :name => :line,        :type => :integer } \
-                    << { :name => :file,        :type => :string } \
-                    << { :name => :stack_trace, :type => :string, :anonymize => true }
-    end
 
-
-    # Rails < 2.1 completed line example
-    # Completed in 0.21665 (4 reqs/sec) | Rendering: 0.00926 (4%) | DB: 0.00000 (0%) | 200 OK [http://demo.nu/employees]
-    RAILS_21_COMPLETED = /Completed in (\d+\.\d{5}) \(\d+ reqs\/sec\) (?:\| Rendering: (\d+\.\d{5}) \(\d+\%\) )?(?:\| DB: (\d+\.\d{5}) \(\d+\%\) )?\| (\d\d\d).+\[(http.+)\]/
-
-    # Rails > 2.1 completed line example
-    # Completed in 614ms (View: 120, DB: 31) | 200 OK [http://floorplanner.local/demo]  
-    RAILS_22_COMPLETED = /Completed in (\d+)ms \((?:View: (\d+), )?DB: (\d+)\) \| (\d\d\d).+\[(http.+)\]/
-
-    # The completed line uses a kind of hack to ensure that both old style logs and new style logs 
-    # are both parsed by the same regular expression. The format in Rails 2.2 was slightly changed,
-    # but the line contains exactly the same information.
-    line_definition :completed do |line|
-    
-      line.footer = true
-      line.teaser = /Completed in /
-      line.regexp = Regexp.new("(?:#{RAILS_21_COMPLETED}|#{RAILS_22_COMPLETED})")
-    
-      line.captures << { :name => :duration, :type => :sec,    :anonymize => :slightly } \
-                    << { :name => :view,     :type => :sec,    :anonymize => :slightly } \
-                    << { :name => :db,       :type => :sec,    :anonymize => :slightly } \
-                    << { :name => :status,   :type => :integer } \
-                    << { :name => :url,      :type => :string, :anonymize => :url } # Old variant 
-                  
-      line.captures << { :name => :duration, :type => :msec,   :anonymize => :slightly } \
-                    << { :name => :view,     :type => :msec,   :anonymize => :slightly } \
-                    << { :name => :db,       :type => :msec,   :anonymize => :slightly } \
-                    << { :name => :status,   :type => :integer} \
-                    << { :name => :url,      :type => :string, :anonymize => :url }  # 2.2 variant 
-    end
-
-    REQUEST_CATEGORIZER = Proc.new do |request|
-      format = request[:format] || 'html'
-      "#{request[:controller]}##{request[:action]}.#{format} [#{request[:method]}]"
-    end
-
-    report do |analyze|
-      analyze.timespan :line_type => :processing
-      analyze.category :category => REQUEST_CATEGORIZER, :title => 'Top 20 hits', :amount => 20, :line_type => :processing
-      analyze.category :method, :title => 'HTTP methods'
-      analyze.category :status, :title => 'HTTP statuses returned'
-      analyze.category :category => lambda { |request| request =~ :cache_hit ? 'Cache hit' : 'No hit' }, :title => 'Rails action cache hits'
-    
-      analyze.duration :duration, :category => REQUEST_CATEGORIZER, :title => "Request duration",    :line_type => :completed
-      analyze.duration :view,     :category => REQUEST_CATEGORIZER, :title => "Database time",       :line_type => :completed
-      analyze.duration :db,       :category => REQUEST_CATEGORIZER, :title => "View rendering time", :line_type => :completed
+    # Define the reporting for the additional parsed lines
+    report(:append) do |analyze|
+      
+      analyze.duration :render_duration, :category => :render_file, :multiple_per_request => true, 
+              :amount => 20, :title => 'Partial rendering duration'
+              
+      analyze.duration :query_duration, :category => :query_sql, :multiple_per_request => true, 
+              :amount => 20, :title => 'Query duration'
+              
+    end  
     
-      analyze.category :category => REQUEST_CATEGORIZER, :title => 'Process blockers (> 1 sec duration)', 
-              :if => lambda { |request| request[:duration] && request[:duration] > 1.0 }, :amount => 20
-            
-      analyze.hourly_spread :line_type => :processing
-      analyze.category :error, :title => 'Failed requests', :line_type => :failed, :amount => 20
+    # Add a converter method for the SQL fields the the Rails request class
+    class Request < Rails::Request
+      
+      # Sanitizes SQL queries so that they can be grouped
+      def convert_sql(sql, definition) 
+        sql.gsub(/\b\d+\b/, ':int').gsub(/`([^`]+)`/, '\1').gsub(/'[^']*'/, ':string').rstrip
+      end
     end
   end
 end

data/lib/request_log_analyzer/file_format.rb

@@ -1,6 +1,5 @@
 module RequestLogAnalyzer::FileFormat
   
-  
   def self.const_missing(const)
     RequestLogAnalyzer::load_default_class_file(self, const)
   end  
@@ -24,14 +23,24 @@ module RequestLogAnalyzer::FileFormat
     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')))
+      const = RequestLogAnalyzer::to_camelcase(File.basename(file_format, '.rb'))
+      if RequestLogAnalyzer::FileFormat.const_defined?(const)
+        klass = RequestLogAnalyzer::FileFormat.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::FileFormat.const_get(RequestLogAnalyzer::to_camelcase(file_format))      
     end
     
-    raise if klass.nil?
+    # 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::FileFormat::Base)
+    
     @current_file_format = klass.new # return an instance of the class
   end  
   
@@ -56,13 +65,29 @@ module RequestLogAnalyzer::FileFormat
       
     # 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 }
-       
-       unless subclass.const_defined?('Request')
-         subclass.const_set('Request', Class.new(RequestLogAnalyzer::Request))         
-       end
+      if subclass.superclass == RequestLogAnalyzer::FileFormat::Base
+        
+        # Create aline and report definer for this class
+        subclass.class_eval do 
+          instance_variable_set(:@line_definer, RequestLogAnalyzer::LineDefinition::Definer.new)
+          instance_variable_set(:@report_definer, RequestLogAnalyzer::Aggregator::Summarizer::Definer.new)
+          class << self; attr_accessor :line_definer, :report_definer; end
+        end        
+
+        # Create a custom Request class for this file format
+        subclass.const_set('Request', Class.new(RequestLogAnalyzer::Request)) unless subclass.const_defined?('Request')
+      else
+        
+        # Copy the line and report definer from the parent class.
+        subclass.class_eval do 
+          instance_variable_set(:@line_definer, superclass.line_definer.clone)
+          instance_variable_set(:@report_definer, superclass.report_definer.clone)
+          class << self; attr_accessor :line_definer, :report_definer; end
+        end        
+        
+        # Create a custom Request class based on the superclass's Request class
+        subclass.const_set('Request', Class.new(subclass.superclass::Request)) unless subclass.const_defined?('Request')
+      end
     end    
     
     # Specifies a single line defintions.
@@ -70,23 +95,30 @@ module RequestLogAnalyzer::FileFormat
       @line_definer.send(name, &block)
     end
     
-    def create_request(*hashes)
-      self.class::Request.create(self, *hashes)
+    def request_class
+      self.class::Request
+    end
+    
+    def request(*hashes)
+      request_class.create(self, *hashes)
     end
     
     # Specifies multiple line definitions at once using a block
     def self.format_definition(&block)
       if block_given?
-        yield(@line_definer) 
+        yield self.line_definer
       else
-        return @line_definer
+        return self.line_definer
       end
     end
     
     # Specifies the summary report using a block.
-    def self.report(&block)
-      @report_definer = RequestLogAnalyzer::Aggregator::Summarizer::Definer.new
-      yield(@report_definer)
+    def self.report(mode = :append, &block)
+      if mode == :overwrite
+        self.report_definer.reset!
+      end
+      
+      yield(self.report_definer)
     end
 
     # Returns all line definitions
@@ -96,7 +128,7 @@ module RequestLogAnalyzer::FileFormat
     
     # Returns all the defined trackers for the summary report.
     def report_trackers
-      self.class.instance_variable_get(:@report_definer).trackers rescue []
+      self.class.report_definer.trackers# =>  rescue []
     end
     
     # Checks whether the line definitions form a valid language.

data/lib/request_log_analyzer/filter/{anonimize.rb → anonymize.rb}

@@ -1,15 +1,12 @@
 module RequestLogAnalyzer::Filter
   
-  # Filter to select or reject a specific field
+  # Filter to anonymize parsed values
   # 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 Anonimize < Base
+  class Anonymize < Base
    
-    def prepare
-    end
-
     def generate_random_ip
       "#{rand(256)}.#{rand(256)}.#{rand(256)}.#{rand(256)}"
     end
@@ -22,9 +19,7 @@ module RequestLogAnalyzer::Filter
       value * ((75 + rand(50)) / 100.0)
     end
 
-    def filter(request)
-      return nil unless request
-      
+    def filter(request)    
       request.attributes.each do |key, value|
         if key == :ip
           request.attributes[key] = generate_random_ip

data/lib/request_log_analyzer/filter/field.rb

@@ -9,8 +9,13 @@ module RequestLogAnalyzer::Filter
    
     attr_reader :field, :value, :mode
    
+    def initialize(file_format, options = {})
+      super(file_format, options)
+      setup_filter
+    end
+   
     # Setup mode, field and value.
-    def prepare
+    def setup_filter
       @mode = (@options[:mode] || :accept).to_sym
       @field = @options[:field].to_sym
       
@@ -27,13 +32,9 @@ module RequestLogAnalyzer::Filter
     # Returns nil otherwise.
     # <tt>request</tt> Request Object
     def filter(request)
-      return nil unless request
-      
-      found_field = request.every(@field).any? { |value| @value === value }
-      
+      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

data/lib/request_log_analyzer/filter/timespan.rb

@@ -8,9 +8,15 @@ module RequestLogAnalyzer::Filter
    
     attr_reader :before, :after
    
+    def initialize(file_format, options = {})
+      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 prepare
+    def setup_filter
       @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
@@ -22,8 +28,6 @@ module RequestLogAnalyzer::Filter
     # Returns nil otherwise
     # <tt>request</tt> Request object.
     def filter(request)
-      return nil unless request
-      
       if @after && @before && request.timestamp <= @before && @after <= request.timestamp
         return request
       elsif @after && @before.nil? && @after <= request.timestamp

data/lib/request_log_analyzer/filter.rb

@@ -23,10 +23,6 @@ module RequestLogAnalyzer::Filter
       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)

data/lib/request_log_analyzer/line_definition.rb

@@ -1,22 +1,10 @@
 module RequestLogAnalyzer
   
-  module Anonymizers
-    def anonymizer_for_ip(value, capture_definition)
-      '127.0.0.1'
-    end
-
-    def anonymizer_for_url(value, capture_definition)
-      value.sub(/^https?\:\/\/[A-Za-z0-9\.-]+\//, "http://example.com/")
-    end
-  end  
-  
   # 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
 
-    include RequestLogAnalyzer::Anonymizers
-
     class Definer
       
       attr_accessor :line_definitions
@@ -24,6 +12,10 @@ module RequestLogAnalyzer
       def initialize
         @line_definitions = {}
       end
+
+      def initialize_copy(other)
+        @line_definitions = other.line_definitions.dup
+      end
       
       def method_missing(name, *args, &block)
         if block_given?
@@ -45,27 +37,13 @@ module RequestLogAnalyzer
       @captures = []
       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
     
-    # Converts a parsed value (String) to the desired value using some heuristics.
-    def convert_value(value, type)
-      case type
-      when :integer;   value.to_i
-      when :float;     value.to_f
-      when :decimal;   value.to_f          
-      when :symbol;    value.to_sym
-      when :sec;       value.to_f
-      when :msec;      value.to_f / 1000
-      when :timestamp; value.gsub(/[^0-9]/,'')[0..13].to_i # Retrieve with: DateTime.parse(value, '%Y%m%d%H%M%S')
-      else value
-      end
-    end
-    
     # 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.
@@ -74,17 +52,7 @@ module RequestLogAnalyzer
     def matches(line, lineno = nil, parser = nil)
       if @teaser.nil? || @teaser =~ line
         if match_data = line.match(@regexp)
-          request_info = { :line_type => name, :lineno => lineno }
-          
-          captures.each_with_index do |capture, index|
-            next if capture == :ignore
-
-            if match_data.captures[index]
-              request_info[capture[:name]] = convert_value(match_data.captures[index], capture[:type])
-            end
-
-          end
-          return request_info
+          return { :line_definition => self, :lineno => lineno, :captures => match_data.captures}
         else
           if @teaser && parser
             parser.warn(:teaser_check_failed, "Teaser matched for #{name.inspect}, but full line did not:\n#{line.inspect}")
@@ -97,63 +65,29 @@ module RequestLogAnalyzer
     end
     
     alias :=~ :matches
-    
-    def anonymize_value(value, capture_definition)
-      if capture_definition[:anonymize].respond_to?(:call)
-        capture_definition[:anonymize].call(value, capture_definition)
+
+    def match_for(line, request, lineno = nil, parser = nil)
+      if match_info = matches(line, lineno, parser)
+        convert_captured_values(match_info[:captures], request)
       else
-        case capture_definition[:anonymize]
-        when nil;   value
-        when false; value
-        when true;  '***'
-        when :slightly; anonymize_slightly(value, capture_definition)
-        else 
-          method_name = "anonymizer_for_#{capture_definition[:anonymize]}".to_sym
-          self.respond_to?(method_name) ? self.send(method_name, value, capture_definition) : '***'
-        end
+        false
       end
     end
-    
-    def anonymize_slightly(value, capture_definition)  
-      case capture_definition[:type]
-      when :integer
-        (value.to_i * (0.8 + rand * 0.4)).to_i
-      when :double
-        (value.to_f * (0.8 + rand * 0.4)).to_f          
-      when :msec
-        (value.to_i * (0.8 + rand * 0.4)).to_i
-      when :sec
-        (value.to_f * (0.8 + rand * 0.4)).to_f
-      when :timestamp
-        (DateTime.parse(value) + (rand(100) - 50)).to_s
-      else
-        puts "Cannot anonymize #{capture_definition[:type].inspect} slightly, using ***"
-        '***'
-      end  
-    end
 
-    # Anonymize a log line
-    def anonymize(line, options = {})
-      if self.teaser.nil? || self.teaser =~ line
-        if self.regexp =~ line
-          pos_adjustment = 0
-          captures.each_with_index do |capture, index|
-            unless $~[index + 1].nil?
-              anonymized_value = anonymize_value($~[index + 1], capture).to_s
-              line[($~.begin(index + 1) + pos_adjustment)...($~.end(index + 1) + pos_adjustment)] = anonymized_value
-              pos_adjustment += anonymized_value.length - $~[index + 1].length                    
-            end
-          end
-          line
-        elsif self.teaser.nil?
-          nil
-        else
-          options[:discard_teaser_lines] ? "" : line
+    def convert_captured_values(values, request)
+      value_hash = {}
+      captures.each_with_index do |capture, index|
+        converted = request.convert_value(values[index], capture)
+        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
-      else
-        nil
       end
+      return value_hash
     end
+
   end
   
 end

data/lib/request_log_analyzer/log_processor.rb

@@ -6,12 +6,9 @@ module RequestLogAnalyzer
   # contents of the line, remain it intact or remove it altogether, based on the current
   # file format
   #
-  # Currently, two processors are supported, :strip and :anonymize. 
+  # Currently, one processors is supported:
   #  * :strip will remove all irrelevent lines (according to the file format) from the 
   #    sources. A compact, information packed log will remain/.
-  #  * :anonymize will anonymize sensitive information from the lines according to the 
-  #    anonymization rules in the file format. The result can be passed to third parties
-  #    without privacy concerns.
   #
   class LogProcessor
     
@@ -21,8 +18,8 @@ module RequestLogAnalyzer
     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 can either be 
-    #   :strip or :anonymize. This will set the processing mode.
+    # <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)
       
@@ -43,7 +40,7 @@ module RequestLogAnalyzer
     
     # Initializes a new LogProcessor instance.
     # <tt>format</tt> The file format to use (e.g. :rails).
-    # <tt>mode</tt> The processing mode (:anonymize or :strip)
+    # <tt>mode</tt> The processing mode
     # <tt>options</tt> A hash with options to take into account
     def initialize(format, mode, options = {})
       @options = options
@@ -61,12 +58,11 @@ module RequestLogAnalyzer
     end
 
     # Processes an input stream by iteration over each line and processing it according to
-    # the current operation mode (:strip, :anonymize)
+    # the current operation mode
     # <tt>io</tt> The IO instance to process.
     def process_io(io)
       case mode
         when :strip;     io.each_line { |line| @output << strip_line(line) }
-        when :anonymize; io.each_line { |line| @output << anonymize_line(line) }
       end
     end
     
@@ -77,22 +73,6 @@ module RequestLogAnalyzer
       file_format.line_definitions.any? { |name, definition| definition =~ line } ? line : ""
     end
 
-    # Returns an anonymized version of the provided line. This can be a copy of the line it self, 
-    # an empty string or a string in which some substrings are substituted for anonymized values.
-    # <tt>line</tt> The line to anonymize
-    def anonymize_line(line)
-      anonymized_line = nil
-      file_format.line_definitions.detect { |name, definition| anonymized_line = definition.anonymize(line, options) }
-      
-      if anonymized_line
-        return anonymized_line
-      elsif options[:keep_junk_lines]
-        return line
-      else
-        return ""
-      end
-    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 
     # (IO instances). The strings "-" and "STDIN" will be substituted for the $stdin variable.

data/lib/request_log_analyzer/output/fixed_width.rb

@@ -1,5 +1,8 @@
+# coding: utf-8
 module RequestLogAnalyzer::Output
   
+  # Fixed Width output class.
+  # Outputs a fixed width ASCII or UF8 report.
   class FixedWidth < Base
   
     module Monochrome
@@ -126,8 +129,12 @@ module RequestLogAnalyzer::Output
       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)] = width_left
+        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
       end
     
       # Print table header
@@ -156,14 +163,18 @@ module RequestLogAnalyzer::Output
                 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) 
               end
             else
+              # Too few characters for a ratio bar. Display nothing
               row_values.push('')
             end
           else
-            alignment = (columns[index][:align] == :right ? '' : '-')        
-            row_values.push("%#{alignment}#{width}s" % row[index].to_s[0...width])
+            alignment = (columns[index][:align] == :right ? '' : '-')
+            cell_value = "%#{alignment}#{width}s" % row[index].to_s[0...width]
+            cell_value = colorize(cell_value, :bold, :brown) if columns[index][:highlight]
+            row_values.push(cell_value)
           end
         end
         puts row_values.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')      

data/lib/request_log_analyzer/output/html.rb

@@ -1,5 +1,6 @@
 module RequestLogAnalyzer::Output
   
+  # HTML Output class. Generated a HTML-formatted report, including CSS.
   class HTML < Base
   
     # def initialize(io, options = {})