request-log-analyzer 1.1.0 → 1.1.1

data/lib/request_log_analyzer/file_format/rails_development.rb

@@ -1,114 +1,112 @@
-class RequestLogAnalyzer::FileFormat::RailsDevelopment < RequestLogAnalyzer::FileFormat
+module RequestLogAnalyzer::FileFormat
   
-  # 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
+  class RailsDevelopment < Base
+  
+    # 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/
-  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/
+    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 }
-  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 }
+    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.captures << { :name => :query_class,    :type  => :string } \
-                  << { :name => :query_duration, :type  => :msec } \
-                  << { :name => :query_sql,      :type  => :string }
-  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.captures << { :name => :query_class,    :type  => :string } \
+                    << { :name => :query_duration, :type  => :msec } \
+                    << { :name => :query_sql,      :type  => :string }
+    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 }
-  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 }
+    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
+    # 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 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.+)\]/
+    # 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|
+    # 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.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 => :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
+      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
 
-
-  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'
+    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
+      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
     
-    analyze.category :category => REQUEST_CATEGORIZER, :title => 'Process blockers (> 1 sec duration)', 
-            :if => lambda { |request| request[:duration] && request[:duration] > 1.0 }, :amount => 20
+      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
+      analyze.hourly_spread :line_type => :processing
+      analyze.category :error, :title => 'Failed requests', :line_type => :failed, :amount => 20
+    end
   end
-
-
-
-end
+end

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/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/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.rb

@@ -1,15 +1,13 @@
-module RequestLogAnalyzer
+module RequestLogAnalyzer::Output
+
+  def self.const_missing(const)
+    RequestLogAnalyzer::load_default_class_file(self, const)
+  end
   
-  class Output
+  class Base
     
     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

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