ngmoco-request-log-analyzer 1.4.2

data/lib/request_log_analyzer/output.rb

@@ -0,0 +1,113 @@
+# Module for generating output
+module RequestLogAnalyzer::Output
+
+  # Load class files if needed
+  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
+    def initialize(io, options = {})
+      @io      = io
+      @options = options
+      @style   = options[:style] || { :cell_separator => true, :table_border => false }
+    end
+
+    # Apply a style block.. with style :)
+    def with_style(temp_style = {})
+      old_style = @style
+      @style = @style.merge(temp_style)
+      yield(self) if block_given?
+      @style = old_style
+    end
+
+    # Generate a header for a report
+    def header
+    end
+
+    # 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|
+    #   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
+    # end
+    #
+    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? }
+    end
+
+  end
+end

data/lib/request_log_analyzer/output/fixed_width.rb

@@ -0,0 +1,220 @@
+# coding: utf-8
+module RequestLogAnalyzer::Output
+
+  # Fixed Width output class.
+  # Outputs a fixed width ASCII or UF8 report.
+  class FixedWidth < Base
+
+    # Mixin module. Will disable any colorizing.
+    module Monochrome
+      def colorize(text, *options)
+        text
+      end
+    end
+
+    # Colorize module
+    module Color
+
+      STYLES = { :normal => 0, :bold => 1, :underscore => 4, :blink => 5, :inverse => 7, :concealed => 8 }
+      COLORS = { :black  => 0, :blue => 4, :green => 2, :cyan => 6, :red => 1, :purple => 5, :brown => 3, :white => 7 }
+
+      # Colorize text
+      # <tt>text</tt> The text to colorize
+      # Options
+      #  * <tt>:background</tt> The background color to paint. Defined in Color::COLORS
+      #  * <tt>:color</tt> The foreground color to paint. Defined in Color::COLORS
+      #  * <tt>:on</tt> Alias for :background
+      #  * <tt>:style</tt> Font style, defined in Color::STYLES
+      #
+      # Returns ASCII colored string
+      def colorize(text, *options)
+
+        font_style       = ''
+        foreground_color = '0'
+        background_color = ''
+
+        options.each do |option|
+          if option.kind_of?(Symbol)
+            foreground_color = "3#{COLORS[option]}" if COLORS.include?(option)
+            font_style       = "#{STYLES[option]};" if STYLES.include?(option)
+          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 => '░' }
+    }
+
+    # Initialize a report
+    # <tt>io</tt> iO Object (file, STDOUT, etc.)
+    # <tt>options</tt>
+    #  * <tt>:characters</tt> :utf for UTF8 or :ascii for ANSI compatible output. Defaults to :utf.
+    #  * <tt>:color</tt> If true, ASCII colorization is used, else Monochrome. Defaults to Monochrome.
+    #  * <tt>:width</tt> Output width in characters. Defaults to 80.
+    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
+
+    # Write a string to the output object.
+    # <tt>str</tt> The string to write.
+    def print(str)
+      @io << str
+    end
+
+    alias :<< :print
+
+    # Write a string to the output object with a newline at the end.
+    # <tt>str</tt> The string to write.
+    def puts(str = '')
+      @io << str << "\n"
+    end
+
+    # Write the title of a report
+    # <tt>title</tt> The title to write
+    def title(title)
+      puts
+      puts colorize(title, :bold, :white)
+      line(:green)
+    end
+
+    # Write a line
+    def line(*font)
+      puts colorize(characters[:horizontal_line] * @options[:width], *font)
+    end
+
+    # Write a link
+    # <tt>text</tt> The text in the link, or the URL itself if no text is given
+    # <tt>url</tt> The url to link to.
+    def link(text, url = nil)
+      if url.nil?
+        colorize(text, :blue, :bold)
+      else
+        "#{text} (#{colorize(url, :blue, :bold)})"
+      end
+    end
+
+    # Generate a header for a report
+    def header
+      if io.kind_of?(File)
+        puts colorize("Request-log-analyzer summary report", :white, :bold)
+        line(:green)
+        puts "Version #{RequestLogAnalyzer::VERSION} - written by Willem van Bergen and Bart ten Brinke"
+        puts "Website: #{link('http://github.com/wvanbergen/request-log-analyzer')}"
+      end
+    end
+
+    # Generate a footer for a report
+    def footer
+      puts
+      puts "Need an expert to analyze your application?"
+      puts "Mail to #{link('contact@railsdoctors.com')} or visit us at #{link('http://railsdoctors.com')}."
+      line(:green)
+      puts "Thanks for using #{colorize('request-log-analyzer', :white, :bold)}!"
+    end
+
+    # Generate a report table and push it into the output object.
+    # <tt>*colums<tt> Columns hash
+    # <tt>&block</tt>: A block yeilding the rows.
+    def table(*columns, &block)
+
+      rows = Array.new
+      yield(rows)
+
+      # 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)
+        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
+      end
+
+      line(:green) if @style[:top_line]
+
+      # Print table header
+      if table_has_header?(columns)
+        column_titles = []
+        columns.each_with_index do |column, index|
+          width = column_widths[index]
+          alignment = (column[:align] == :right ? '' : '-')
+          column_titles.push(colorize("%#{alignment}#{width}s" % column[:title].to_s[0...width], :bold))
+        end
+
+        puts column_titles.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')
+        line(:green)
+      end
+
+      # Print the rows
+      rows.each do |row|
+        row_values = []
+        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
+                # 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 ? '' : '-')
+            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]} " : ' ')
+      end
+    end
+
+  end
+end

data/lib/request_log_analyzer/output/html.rb

@@ -0,0 +1,184 @@
+module RequestLogAnalyzer::Output
+
+  # HTML Output class. Generated a HTML-formatted report, including CSS.
+  class HTML < Base
+
+    # def initialize(io, options = {})
+    #   super(io, options)
+    # end
+
+    # Print a string to the io object.
+    def print(str)
+      @io << str
+    end
+
+    alias :<< :print
+
+    # Put a string with newline
+    def puts(str = '')
+      @io << str << "<br/>\n"
+    end
+
+    # Place a title
+    def title(title)
+      @io.puts(tag(:h2, title))
+    end
+
+    # Render a single line
+    # <tt>*font</tt> The font.
+    def line(*font)
+      @io.puts(tag(:hr))
+    end
+
+    # Write a link
+    # <tt>text</tt> The text in the link
+    # <tt>url</tt> The url to link to.
+    def link(text, url = nil)
+      url = text if url.nil?
+      tag(:a, text, :href => url)
+    end
+
+    # Generate a report table in HTML and push it into the output object.
+    # <tt>*colums<tt> Columns hash
+    # <tt>&block</tt>: A block yeilding the rows.
+    def table(*columns, &block)
+      rows = Array.new
+      yield(rows)
+
+      @io << tag(:table, {:id => 'mytable', :cellspacing => 0}) do |content|
+        if table_has_header?(columns)
+          content << tag(:tr) do
+            columns.map { |col| tag(:th, col[:title]) }.join("\n")
+          end
+        end
+
+        odd = false
+        rows.each do |row|
+          odd = !odd
+          content << tag(:tr) do
+            if odd
+              row.map { |cell| tag(:td, cell, :class => 'alt') }.join("\n")
+            else
+              row.map { |cell| tag(:td, cell) }.join("\n")
+            end
+          end
+        end
+      end
+
+    end
+
+    # Generate HTML content type
+    def content_type
+      'text/html; charset="ISO-8859-1";'
+    end
+    
+    # Genrate HTML header and associated stylesheet
+    def header
+      @io.content_type = content_type if @io.respond_to?(:content_type)
+
+      @io << "<html>"
+      @io << tag(:head) do |headers|
+        headers << tag(:title, 'Request-log-analyzer report')
+        headers << tag(:style, '
+        body {
+        	font: normal 11px auto "Trebuchet MS", Verdana, Arial, Helvetica, sans-serif;
+        	color: #4f6b72;
+        	background: #E6EAE9;
+        	padding-left:20px;
+        	padding-top:20px;
+        	padding-bottom:20px;
+        }
+
+        a {
+        	color: #c75f3e;
+        }
+
+        .color_bar {
+          border: 1px solid;
+          height:10px;
+        	background: #CAE8EA;
+        }
+
+        #mytable {
+        	width: 700px;
+        	padding: 0;
+        	margin: 0;
+        	padding-bottom:10px;
+        }
+
+        caption {
+        	padding: 0 0 5px 0;
+        	width: 700px;	
+        	font: italic 11px "Trebuchet MS", Verdana, Arial, Helvetica, sans-serif;
+        	text-align: right;
+        }
+
+        th {
+        	font: bold 11px "Trebuchet MS", Verdana, Arial, Helvetica, sans-serif;
+        	color: #4f6b72;
+        	border-right: 1px solid #C1DAD7;
+        	border-bottom: 1px solid #C1DAD7;
+        	border-top: 1px solid #C1DAD7;
+        	letter-spacing: 2px;
+        	text-transform: uppercase;
+        	text-align: left;
+        	padding: 6px 6px 6px 12px;
+        	background: #CAE8EA url(images/bg_header.jpg) no-repeat;
+        }
+
+        td {
+        	font: bold 11px "Trebuchet MS", Verdana, Arial, Helvetica, sans-serif;
+        	border-right: 1px solid #C1DAD7;
+        	border-bottom: 1px solid #C1DAD7;
+        	background: #fff;
+        	padding: 6px 6px 6px 12px;
+        	color: #4f6b72;
+        }
+
+        td.alt {
+        	background: #F5FAFA;
+        	color: #797268;
+        }
+        ', :type => "text/css")
+      end
+      @io << '<body>'
+      @io << tag(:h1, 'Request-log-analyzer summary report')
+      @io << tag(:p, "Version #{RequestLogAnalyzer::VERSION} - written by Willem van Bergen and Bart ten Brinke")
+    end
+
+    # Generate a footer for a report
+    def footer
+      @io << tag(:hr) << tag(:h2, 'Thanks for using request-log-analyzer')
+      @io << tag(:p, 'For more information please visit the ' + link('Request-log-analyzer website', 'http://github.com/wvanbergen/request-log-analyzer'))
+      @io << tag(:p, 'If you need an expert who can analyze your application, mail to ' + link('contact@railsdoctors.com', 'mailto:contact@railsdoctors.com') + ' or visit us at ' + link('http://railsdoctors.com', 'http://railsdoctors.com') + '.')
+      @io << "</body></html>\n"
+    end
+
+    protected
+
+    # HTML tag writer helper
+    # <tt>tag</tt> The tag to generate
+    # <tt>content</tt> The content inside the tag
+    # <tt>attributes</tt> Attributes to write in the tag
+    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
+          if content.class == Float
+            "<#{tag}#{attributes}><div class='color_bar' style=\"width:#{(content*200).floor}px;\"/></#{tag}>"
+          else
+            "<#{tag}#{attributes}>#{content}</#{tag}>"
+          end
+        end
+      end
+    end
+  end
+end