request-log-analyzer 1.0.4 → 1.1.0

data/lib/request_log_analyzer/filter/field.rb

@@ -9,6 +9,7 @@ module RequestLogAnalyzer::Filter
    
     attr_reader :field, :value, :mode
    
+    # Setup mode, field and value.
     def prepare
       @mode = (@options[:mode] || :accept).to_sym
       @field = @options[:field].to_sym
@@ -21,6 +22,10 @@ module RequestLogAnalyzer::Filter
       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)
       return nil unless request
       

data/lib/request_log_analyzer/filter/timespan.rb

@@ -8,12 +8,19 @@ module RequestLogAnalyzer::Filter
    
     attr_reader :before, :after
    
+    # Convert the timestamp to the correct formats for quick timestamp comparisons.
+    # These are stored in the before and after attr_reader fields.
     def prepare
-      # Convert the timestamp to the correct formats for quick timestamp comparisons
       @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
+    #   * request.timestamp <= @before
+    # Returns nil otherwise
+    # <tt>request</tt> Request object.
     def filter(request)
       return nil unless request
       

data/lib/request_log_analyzer/output/fixed_width.rb

@@ -0,0 +1,158 @@
+class RequestLogAnalyzer::Output::FixedWidth < RequestLogAnalyzer::Output
+  
+  module Monochrome
+    def colorize(text, *options)
+      text
+    end
+  end
+  
+  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 }
+    
+    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)          
+        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
+    
+  end
+  
+  attr_reader :characters
+  
+  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]]
+    
+    color_module = @options[:color] ? Color : Monochrome
+    (class << self; self; end).send(:include, color_module) 
+  end
+  
+  def print(str)
+    @io << str
+  end
+  
+  alias :<< :print
+  
+  def puts(str = '')
+    @io << str << "\n"
+  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 link(text, url = nil)
+    if url.nil?
+      colorize(text, :blue, :bold)
+    else
+      "#{text} (#{colorize(url, :blue, :bold)})"
+    end
+  end
+    
+  def table(*columns, &block)
+    
+    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 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
+     
+    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
+    
+    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('')
+          end
+        else
+          alignment = (columns[index][:align] == :right ? '' : '-')        
+          row_values.push("%#{alignment}#{width}s" % row[index].to_s[0...width])
+        end
+      end
+      puts row_values.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')      
+    end
+  end
+  
+end

data/lib/request_log_analyzer/output/html.rb

@@ -0,0 +1,80 @@
+class RequestLogAnalyzer::Output::HTML < RequestLogAnalyzer::Output
+
+  # def initialize(io, options = {})
+  #   super(io, options)
+  # end
+
+  def print(str)
+    @io << str
+  end
+
+  alias :<< :print
+
+  def puts(str = '')
+    @io << str << "<br />\n"
+  end
+
+  def title(title)
+    @io.puts(tag(:h2, title))
+  end
+
+  def line(*font)  
+    @io.puts(tag(:hr))
+  end
+
+  def link(text, url = nil)
+    url = text if url.nil?
+    tag(:a, text, :href => url)
+  end
+
+  def table(*columns, &block)
+    rows = Array.new
+    yield(rows)
+    
+    @io << tag(:table) do |content|
+      if table_has_header?(columns)
+        content << tag(:tr) do
+          columns.map { |col| tag(:th, col[:title]) }.join("\n")
+        end
+      end
+      
+      rows.each do |row|
+        content << tag(:tr) do
+          row.map { |cell| tag(:td, cell) }.join("\n") 
+        end
+      end
+    end
+    
+  end
+  
+  def header
+    @io << "<html>"
+    @io << tag(:head) do |headers|
+      headers << tag(:title, 'Request-log-analyzer report')
+    end
+    @io << '<body>'
+  end
+  
+  def footer
+    @io << "</body></html>\n"
+  end
+  
+  protected 
+  
+  def tag(tag, content = nil, attributes = nil)
+    if block_given?
+      attributes = content.nil? ? '' : ' ' + content.map { |(key, value)| "#{key}=\"#{value}\"" }.join(' ')
+      content_string = ''
+      content = yield(content_string)
+      content = content_string unless content_string.empty? 
+      "<#{tag}#{attributes}>#{content}</#{tag}>"
+    else
+      attributes = attributes.nil? ? '' : ' ' + attributes.map { |(key, value)| "#{key}=\"#{value}\"" }.join(' ')
+      if content.nil?
+        "<#{tag}#{attributes} />"
+      else
+        "<#{tag}#{attributes}>#{content}</#{tag}>"
+      end
+    end
+  end  
+end

data/lib/request_log_analyzer/output.rb

@@ -0,0 +1,39 @@
+module RequestLogAnalyzer
+  
+  class Output
+    
+    attr_accessor :io, :options, :style
+    
+    def self.const_missing(const)
+      filename = const.to_s.gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+      require File.dirname(__FILE__) + '/output/' + filename
+      self.const_get(const)
+    end
+    
+    def initialize(io, options = {})
+      @io      = io
+      @options = options
+      @style   = options[:style] || { :cell_separator => true, :table_border => false }
+    end
+
+    def with_style(temp_style = {})
+      old_style = @style
+      @style = @style.merge(temp_style)
+      yield(self) if block_given?
+      @style = old_style
+    end    
+    
+    def header
+    end
+    
+    def footer
+    end
+    
+    protected
+    
+    def table_has_header?(columns)
+      columns.any? { |column| !column[:title].nil? } 
+    end
+    
+  end
+end

data/lib/request_log_analyzer/tracker/base.rb

@@ -44,7 +44,7 @@ module RequestLogAnalyzer
         return true
       end
       
-      def report(output=STDOUT, report_width = 80, color = false)
+      def report(output)
         output << self.inspect
         output << "\n"  
       end

data/lib/request_log_analyzer/tracker/category.rb

@@ -14,11 +14,11 @@ module RequestLogAnalyzer::Tracker
   #
   # Example output:
   #  HTTP methods
-  #   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  #  GET    ┃  22248 hits (46.2%) ┃░░░░░░░░░░░░░░░░░
-  #  PUT    ┃  13685 hits (28.4%) ┃░░░░░░░░░░░
-  #  POST   ┃  11662 hits (24.2%) ┃░░░░░░░░░
-  #  DELETE ┃    512 hits (1.1%)  ┃
+  #  ----------------------------------------------------------------------
+  #  GET    |  22248 hits (46.2%) |░░░░░░░░░░░░░░░░░
+  #  PUT    |  13685 hits (28.4%) |░░░░░░░░░░░
+  #  POST   |  11662 hits (24.2%) |░░░░░░░░░
+  #  DELETE |    512 hits (1.1%)  |
   class Category < RequestLogAnalyzer::Tracker::Base
   
     attr_reader :categories
@@ -39,12 +39,9 @@ module RequestLogAnalyzer::Tracker
       end
     end
   
-    def report(output = STDOUT, report_width = 80, color = false)
-      if options[:title]
-        output << "\n#{options[:title]}\n"
-        output << green(('━' * report_width), color) + "\n"
-      end
-    
+    def report(output)
+      output.title(options[:title]) if options[:title]
+      
       if @categories.empty?
         output << "None found.\n" 
       else
@@ -52,18 +49,12 @@ module RequestLogAnalyzer::Tracker
         total_hits        = sorted_categories.inject(0) { |carry, item| carry + item[1] }
         sorted_categories = sorted_categories.slice(0...options[:amount]) if options[:amount]
 
-        adjuster = color ? 33 : 24 # justifcation calcultaion is slight different when color codes are inserterted
-        max_cat_length = [sorted_categories.map { |c| c[0].to_s.length }.max, report_width - adjuster].min
-        sorted_categories.each do |(cat, count)|
-          text = "%-#{max_cat_length+1}s┃%7d hits %s" % [cat.to_s[0..max_cat_length], count, (green("(%0.01f%%)", color) % [(count.to_f / total_hits) * 100])]
-          space_left  = report_width - (max_cat_length + adjuster + 3)
-          if space_left > 3
-            bar_chars  = (space_left * (count.to_f / total_hits)).round
-            output << "%-#{max_cat_length + adjuster}s %s%s" % [text, '┃', '░' * bar_chars] + "\n"
-          else
-            output << text + "\n"
+        output.table({:align => :left}, {:align => :right }, {:align => :right}, {:type => :ratio, :width => :rest}) do |rows|        
+          sorted_categories.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
         end
+
       end
     end
 

data/lib/request_log_analyzer/tracker/duration.rb

@@ -2,7 +2,7 @@ module RequestLogAnalyzer::Tracker
 
   # Analyze the duration of a specific attribute
   #
-  # Accepts the following options:
+  # Options:
   # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
   # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
   # * <tt>:title</tt> Title do be displayed above the report  
@@ -13,11 +13,11 @@ module RequestLogAnalyzer::Tracker
   # The items in the update request hash are set during the creation of the Duration tracker.
   #
   # Example output:
-  #  Request duration - top 20 by cumulative time   ┃    Hits ┃      Sum. |      Avg.
-  #   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-  #  EmployeeController#show.html [GET]             ┃    4742 ┃  4922.56s ┃     1.04s
-  #  EmployeeController#update.html [POST]          ┃    4647 ┃  2731.23s ┃     0.59s
-  #  EmployeeController#index.html [GET]            ┃    5802 ┃  1477.32s ┃     0.25s
+  #  Request duration - top 20 by cumulative time   |    Hits |      Sum. |      Avg.
+  #  ---------------------------------------------------------------------------------
+  #  EmployeeController#show.html [GET]             |    4742 |  4922.56s |     1.04s
+  #  EmployeeController#update.html [POST]          |    4647 |  2731.23s |     0.59s
+  #  EmployeeController#index.html [GET]            |    5802 |  1477.32s |     0.25s
   #  .............
   class Duration < RequestLogAnalyzer::Tracker::Base
     attr_reader :categories
@@ -40,25 +40,20 @@ module RequestLogAnalyzer::Tracker
       end
     end
   
-    def report_table(output = STDOUT, amount = 10, options = {}, &block)
+    def report_table(output, amount = 10, options = {}, &block)
       
       top_categories = @categories.sort { |a, b| yield(b[1]) <=> yield(a[1]) }.slice(0...amount)
-      max_cat_length = top_categories.map { |a| a[0].length }.max || 0
-      space_left = [options[:report_width] - 33, [max_cat_length + 1, options[:title].length].max].min
-      
-      output << "\n"
-      output << "%-#{space_left+1}s┃    Hits ┃      Sum. |      Avg." % [options[:title][0...space_left]] + "\n"
-      output << green('━' * options[:report_width], options[:color]) + "\n"
-          
-      top_categories.each do |(cat, info)|
-        hits  = info[:count]
-        total = "%0.02f" % info[:total_duration]
-        avg   = "%0.02f" % (info[:total_duration] / info[:count])
-        output << "%-#{space_left+1}s┃%8d ┃%9ss ┃%9ss" % [cat[0...space_left], hits, total, avg] + "\n"
+      output.table({:title => options[:title]}, {:title => 'Hits', :align => :right, :min_width => 4}, 
+            {:title => 'Cumulative', :align => :right, :min_width => 10}, {:title => 'Average', :align => :right, :min_width => 8}) do |rows|
+        
+        top_categories.each do |(cat, info)|
+          rows << [cat, info[:count], "%0.02fs" % info[:total_duration], "%0.02fs" % (info[:total_duration] / info[:count])]
+        end        
       end
+
     end
   
-    def report(output = STDOUT, report_width = 80, color = false)
+    def report(output)
 
       options[:title]  ||= 'Request duration'
       options[:report] ||= [:total, :average]
@@ -67,11 +62,11 @@ module RequestLogAnalyzer::Tracker
       options[:report].each do |report|
         case report
         when :average
-          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by average time", :color => color, :report_width => report_width) { |request| request[:total_duration] / request[:count] }  
+          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by average time") { |request| request[:total_duration] / request[:count] }  
         when :total
-          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by cumulative time", :color => color, :report_width => report_width) { |request| request[:total_duration] }
+          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by cumulative time") { |request| request[:total_duration] }
         when :hits
-          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by hits", :color => color, :report_width => report_width) { |request| request[:count] }
+          report_table(output, options[:top], :title => "#{options[:title]} - top #{options[:top]} by hits") { |request| request[:count] }
         else
           output << "Unknown duration report specified\n"
         end

data/lib/request_log_analyzer/tracker/hourly_spread.rb

@@ -12,7 +12,7 @@ module RequestLogAnalyzer::Tracker
   #
   # Example output:
   #  Requests graph - average per day per hour
-  #   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  #  --------------------------------------------------
   #    7:00 - 330 hits        : ░░░░░░░
   #    8:00 - 704 hits        : ░░░░░░░░░░░░░░░░░
   #    9:00 - 830 hits        : ░░░░░░░░░░░░░░░░░░░░
@@ -44,37 +44,27 @@ module RequestLogAnalyzer::Tracker
       @last  = timestamp if @last.nil?  || timestamp > @last
     end
   
-    def report(output = STDOUT, report_width = 80, color = false)
-      output << "\n"
-      output << "Requests graph - average per day per hour\n"
-      output << green("━" * report_width, color) + "\n"
+    def report(output)
+      output.title("Requests graph - average per day per hour")
       
       if @request_time_graph == [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
         output << "None found.\n"
         return
       end
 
-      first_date    = DateTime.parse(@first.to_s, '%Y%m%d%H%M%S')
-      last_date     = DateTime.parse(@last.to_s, '%Y%m%d%H%M%S')
-      days          = (@last && @first) ? (last_date - first_date).ceil : 1
-      deviation     = @request_time_graph.max / 20
-      deviation     = 1 if deviation == 0
-      color_cutoff  = 15
+      first_date     = DateTime.parse(@first.to_s, '%Y%m%d%H%M%S')
+      last_date      = DateTime.parse(@last.to_s, '%Y%m%d%H%M%S')
+      days           = (@last && @first) ? (last_date - first_date).ceil : 1
+      total_requests = @request_time_graph.inject(0) { |sum, value| sum + value }
       
-      @request_time_graph.each_with_index do |requests, index|
-        display_chars = requests / deviation
-        request_today = requests / days
+      output.table({}, {:align => :right}, {:type => :ratio, :width => :rest, :treshold => 0.15}) do |rows|
+        @request_time_graph.each_with_index do |requests, index|
+          ratio = requests.to_f / total_requests.to_f
+          requests_per_day = requests / days
       
-        if display_chars >= color_cutoff
-          display_chars_string = green(('░' * color_cutoff), color) + red(('░' * (display_chars - color_cutoff)), color)
-        else
-          display_chars_string = green(('░' * display_chars), color)
+          rows << ["#{index.to_s.rjust(3)}:00", "#{requests_per_day} hits", ratio]
         end
-      
-        output << "#{index.to_s.rjust(3)}:00 - #{(request_today.to_s + ' hits').ljust(15)} : #{display_chars_string}\n"
       end
-      output << "\n"
-
     end
   end
 end

data/lib/request_log_analyzer/tracker/timespan.rb

@@ -31,23 +31,23 @@ module RequestLogAnalyzer::Tracker
       @last  = timestamp if @last.nil?  || timestamp > @last
     end
   
-    def report(output = STDOUT, report_width = 80, color = false)
-      if options[:title]
-        output << "\n#{options[:title]}\n"
-        output << green('━' * options[:title].length, color) + "\n"
-      end
+    def report(output)
+      output.title(options[:title]) if options[:title]
       
       first_date  = DateTime.parse(@first.to_s, '%Y%m%d%H%M%S') rescue nil
       last_date   = DateTime.parse(@last.to_s, '%Y%m%d%H%M%S') rescue nil
       
       if @last && @first
         days        = (@last && @first) ? (last_date - first_date).ceil : 1
-
-        output << "First request:        #{first_date.strftime('%Y-%m-%d %H:%M:%I')}\n"
-        output << "Last request:         #{last_date.strftime('%Y-%m-%d %H:%M:%I')}\n"
-        output << "Total time analyzed:  #{days} days\n"
+             
+        output.with_style(:cell_separator => false) do         
+          output.table({:width => 20}, {}) do |rows|
+            rows << ['First request:', first_date.strftime('%Y-%m-%d %H:%M:%I')]
+            rows << ['Last request:', last_date.strftime('%Y-%m-%d %H:%M:%I')]
+            rows << ['Total time analyzed:', "#{days} days"]                    
+          end
+        end
       end
-      output << "\n"
       
     end
   end

data/lib/request_log_analyzer.rb

@@ -1,6 +1,5 @@
 require 'date'
 require File.dirname(__FILE__) + '/cli/progressbar'
-require File.dirname(__FILE__) + '/cli/bashcolorizer'
 
 require File.dirname(__FILE__) + '/request_log_analyzer/file_format'
 require File.dirname(__FILE__) + '/request_log_analyzer/line_definition'
@@ -12,3 +11,4 @@ require File.dirname(__FILE__) + '/request_log_analyzer/filter/base'
 require File.dirname(__FILE__) + '/request_log_analyzer/controller'
 require File.dirname(__FILE__) + '/request_log_analyzer/source/base'
 require File.dirname(__FILE__) + '/request_log_analyzer/source/log_file'
+require File.dirname(__FILE__) + '/request_log_analyzer/output'

data/spec/controller_spec.rb

@@ -10,9 +10,14 @@ describe RequestLogAnalyzer::Controller do
   # end
 
   it "should call the aggregators when run" do
+    
+    mock_output = mock('output')
+    mock_output.should_receive(:header)
+    mock_output.should_receive(:footer)    
+    
     file_format = RequestLogAnalyzer::FileFormat.load(:rails)
     source      = RequestLogAnalyzer::Source::LogFile.new(file_format, :source_files => log_fixture(:rails_1x))  
-    controller  = RequestLogAnalyzer::Controller.new(source)
+    controller  = RequestLogAnalyzer::Controller.new(source, :output => mock_output)
     
     mock_aggregator = mock('aggregator')
     mock_aggregator.should_receive(:prepare).once.ordered
@@ -26,7 +31,6 @@ describe RequestLogAnalyzer::Controller do
     another_mock_aggregator.should_receive(:finalize).once.ordered  
     another_mock_aggregator.should_receive(:report).once.ordered  
 
-    
     controller.aggregators << mock_aggregator << another_mock_aggregator
     controller.run!
   end