request-log-analyzer 1.13.1 → 1.13.3

data/lib/request_log_analyzer/output/fixed_width.rb

@@ -1,22 +1,19 @@
 # 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)
+      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 }
+      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
@@ -28,36 +25,34 @@ module RequestLogAnalyzer::Output
       #
       # Returns ASCII colored string
       def colorize(text, *options)
-
         font_style       = ''
         foreground_color = '0'
         background_color = ''
 
         options.each do |option|
-          if option.kind_of?(Symbol)
+          if option.is_a?(Symbol)
             foreground_color = "3#{COLORS[option]}" if COLORS.include?(option)
             font_style       = "#{STYLES[option]};" if STYLES.include?(option)
-          elsif option.kind_of?(Hash)
+          elsif option.is_a?(Hash)
             option.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)
+              when :color then      foreground_color = "3#{COLORS[value]}"  if COLORS.include?(value)
+              when :background then background_color = "4#{COLORS[value]};" if COLORS.include?(value)
+              when :on then         background_color = "4#{COLORS[value]};" if COLORS.include?(value)
+              when :style then      font_style       = "#{STYLES[value]};"  if STYLES.include?(value)
               end
             end
           end
         end
-        return "\e[#{background_color}#{font_style}#{foreground_color}m#{text}\e[0m"
+        "\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 => '░' }
+      ascii: { horizontal_line: '-', vertical_line: '|', block: '=' },
+      utf: { horizontal_line: '━', vertical_line: '┃', block: '░' }
     }
 
     # Initialize a report
@@ -82,7 +77,7 @@ module RequestLogAnalyzer::Output
       @io << str
     end
 
-    alias :<< :print
+    alias_method :<<, :print
 
     # Write a string to the output object with a newline at the end.
     # <tt>str</tt> The string to write.
@@ -116,8 +111,8 @@ module RequestLogAnalyzer::Output
 
     # Generate a header for a report
     def header
-      if io.kind_of?(File)
-        puts colorize("Request-log-analyzer summary report", :white, :bold)
+      if io.is_a?(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')}"
@@ -127,7 +122,7 @@ module RequestLogAnalyzer::Output
     # Generate a footer for a report
     def footer
       puts
-      puts "Need an expert to analyze your application?"
+      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)}!"
@@ -136,13 +131,12 @@ module RequestLogAnalyzer::Output
     # 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
+    def table(*columns, &_block)
+      rows = []
       yield(rows)
 
       # determine maximum cell widths
-      max_cell_widths = rows.inject(Array.new(columns.length, 0)) do |result, row|
+      max_cell_widths = rows.reduce(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
@@ -164,7 +158,7 @@ module RequestLogAnalyzer::Output
       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}
+        width_left = options[:width] - ((columns.length - 1) * (style[:cell_separator] ? 3 : 1)) - column_widths.compact.reduce(0) { |sum, col| sum + col }
         column_widths[column_widths.index(nil)] = width_left
       end
 
@@ -214,6 +208,5 @@ module RequestLogAnalyzer::Output
         puts row_values.join(style[:cell_separator] ? " #{characters[:vertical_line]} " : ' ')
       end
     end
-
   end
-end
+end

data/lib/request_log_analyzer/output/html.rb

@@ -1,8 +1,6 @@
 module RequestLogAnalyzer::Output
-
   # HTML Output class. Generated a HTML-formatted report, including CSS.
   class HTML < Base
-
     # def initialize(io, options = {})
     #   super(io, options)
     # end
@@ -20,7 +18,7 @@ module RequestLogAnalyzer::Output
       @io << str
     end
 
-    alias :<< :print
+    alias_method :<<, :print
 
     # Put a string with newline
     def puts(str = '')
@@ -34,7 +32,7 @@ module RequestLogAnalyzer::Output
 
     # Render a single line
     # <tt>*font</tt> The font.
-    def line(*font)
+    def line(*_font)
       @io.puts(tag(:hr))
     end
 
@@ -43,17 +41,17 @@ module RequestLogAnalyzer::Output
     # <tt>url</tt> The url to link to.
     def link(text, url = nil)
       url = text if url.nil?
-      tag(:a, text, :href => url)
+      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
+    def table(*columns, &_block)
+      rows = []
       yield(rows)
 
-      @io << tag(:table, {:class => 'rla-report-table', :cellspacing => 0}) do |content|
+      @io << tag(:table, class: 'rla-report-table', cellspacing: 0) do |content|
         if table_has_header?(columns)
           content << tag(:tr) do
             columns.map { |col| tag(:th, col[:title]) }.join("\n")
@@ -65,21 +63,20 @@ module RequestLogAnalyzer::Output
           odd = !odd
           content << tag(:tr) do
             if odd
-              row.map { |cell| tag(:td, cell, :class => 'alt') }.join("\n")
+              row.map { |cell| tag(:td, cell, class: 'alt') }.join("\n")
             else
               row.map { |cell| tag(:td, cell) }.join("\n")
             end
           end
         end
       end
-
     end
 
     # Genrate HTML header and associated stylesheet
     def header
       @io.content_type = content_type if @io.respond_to?(:content_type)
 
-      @io << "<html>"
+      @io << '<html>'
       @io << tag(:head) do |headers|
         headers << tag(:title, 'Request-log-analyzer report')
         headers << tag(:style, '
@@ -111,7 +108,7 @@ module RequestLogAnalyzer::Output
 
         caption {
         	padding: 0 0 5px 0;
-        	width: 700px;	
+        	width: 700px;
         	font: italic 11px "Trebuchet MS", Verdana, Arial, Helvetica, sans-serif;
         	text-align: right;
         }
@@ -142,7 +139,7 @@ module RequestLogAnalyzer::Output
         	background: #F5FAFA;
         	color: #797268;
         }
-        ', :type => "text/css")
+        ', type: 'text/css')
       end
       @io << '<body>'
       @io << tag(:h1, 'Request-log-analyzer summary report')
@@ -176,7 +173,7 @@ module RequestLogAnalyzer::Output
           "<#{tag}#{attributes} />"
         else
           if content.class == Float
-            "<#{tag}#{attributes}><div class='color_bar' style=\"width:#{(content*200).floor}px;\"/></#{tag}>"
+            "<#{tag}#{attributes}><div class='color_bar' style=\"width:#{(content * 200).floor}px;\"/></#{tag}>"
           else
             "<#{tag}#{attributes}>#{content}</#{tag}>"
           end

data/lib/request_log_analyzer/request.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer
-
   # The Request class represents a parsed request from the log file.
   # Instances are created by the LogParser and are passed to the different aggregators, so they
   # can do their aggregating work.
@@ -8,9 +7,7 @@ module RequestLogAnalyzer
   # Request#first(field_name) returns the first (only) value corresponding to the given field
   # Request#every(field_name) returns all values corresponding to the given field name as array.
   class Request
-
     module Converters
-
       # Default converter function, which converts the parsed strings to a native Ruby type
       # using the type indication in the line definition. It will use a custom connverter
       # method if one is available.
@@ -20,24 +17,47 @@ module RequestLogAnalyzer
         send(custom_converter_method, value, capture_definition)
       end
 
-      def convert_string(value, capture_definition);  value; end
-      def convert_float(value, capture_definition);   value.to_f; end
-      def convert_decimal(value, capture_definition); value.to_f; end
-      def convert_int(value, capture_definition);     value.to_i; end
-      def convert_integer(value, capture_definition); value.to_i; end
-      def convert_sym(value, capture_definition);     value.to_sym; end
-      def convert_symbol(value, capture_definition);  value.to_sym; end
-      def convert_nillable_string(value, definition); value == '-' ? nil : value ; end
-      
+      def convert_string(value, _capture_definition)
+        value
+      end
+
+      def convert_float(value, _capture_definition)
+        value.to_f
+      end
+
+      def convert_decimal(value, _capture_definition)
+        value.to_f
+      end
+
+      def convert_int(value, _capture_definition)
+        value.to_i
+      end
+
+      def convert_integer(value, _capture_definition)
+        value.to_i
+      end
+
+      def convert_sym(value, _capture_definition)
+        value.to_sym
+      end
+
+      def convert_symbol(value, _capture_definition)
+        value.to_sym
+      end
+
+      def convert_nillable_string(value, _definition)
+        value == '-' ? nil : value
+      end
+
       # This function can be overridden to rewrite the path for better categorization in the
       # reports.
-      def convert_path(value, definition)
+      def convert_path(value, _definition)
         value
       end
 
       # Converts :eval field, which should evaluate to a hash.
-      def convert_eval(value, capture_definition)
-        eval(sanitize_parameters(value)).inject({}) { |h, (k, v)| h[k.to_sym] = v; h}
+      def convert_eval(value, _capture_definition)
+        eval(sanitize_parameters(value)).reduce({}) { |h, (k, v)| h[k.to_sym] = v; h }
       rescue
         nil
       end
@@ -51,7 +71,7 @@ module RequestLogAnalyzer
       # Slow default method to parse timestamps.
       # Reimplement this function in a file format specific Request class
       # to improve the timestamp parsing speed.
-      def convert_timestamp(value, capture_definition)
+      def convert_timestamp(value, _capture_definition)
         DateTime.parse(value).strftime('%Y%m%d%H%M%S').to_i
       end
 
@@ -59,13 +79,13 @@ module RequestLogAnalyzer
       def convert_traffic(value, capture_definition)
         case capture_definition[:unit]
         when nil, :b, :B, :byte      then value.to_i
-        when :GB, :G, :gigabyte      then (value.to_f * 1000_000_000).round
-        when :GiB, :gibibyte         then (value.to_f * (2 ** 30)).round
-        when :MB, :M, :megabyte      then (value.to_f * 1000_000).round
-        when :MiB, :mebibyte         then (value.to_f * (2 ** 20)).round
+        when :GB, :G, :gigabyte      then (value.to_f * 1_000_000_000).round
+        when :GiB, :gibibyte         then (value.to_f * (2**30)).round
+        when :MB, :M, :megabyte      then (value.to_f * 1_000_000).round
+        when :MiB, :mebibyte         then (value.to_f * (2**20)).round
         when :KB, :K, :kilobyte, :kB then (value.to_f * 1000).round
-        when :KiB, :kibibyte         then (value.to_f * (2 ** 10)).round
-        else raise "Unknown traffic unit"
+        when :KiB, :kibibyte         then (value.to_f * (2**10)).round
+        else fail 'Unknown traffic unit'
         end
       end
 
@@ -73,14 +93,14 @@ module RequestLogAnalyzer
       def convert_duration(value, capture_definition)
         case capture_definition[:unit]
         when nil, :sec, :s     then value.to_f
-        when :microsec, :musec then value.to_f / 1000000.0
+        when :microsec, :musec then value.to_f / 1_000_000.0
         when :msec, :millisec  then value.to_f / 1000.0
-        else raise "Unknown duration unit"
+        else fail 'Unknown duration unit'
         end
       end
-      
+
       # Convert an epoch to an integer
-      def convert_epoch(value, capture_definition)
+      def convert_epoch(value, _capture_definition)
         Time.at(value.to_i).strftime('%Y%m%d%H%M%S').to_i
       end
     end
@@ -101,16 +121,16 @@ module RequestLogAnalyzer
     # Creates a new request that was parsed from the log with the given FileFormat. The hashes
     # that are passed to this function are added as lines to this request.
     def self.create(file_format, *hashes)
-      request = self.new(file_format)
+      request = new(file_format)
       hashes.flatten.each { |hash| request << hash }
-      return request
+      request
     end
 
     # Adds another line to the request when it is parsed in the LogParser.
     #
     # The line should be provided as a hash with the attributes line_definition, :captures,
     # :lineno and :source set. This function is called from LogParser.
-    def add_parsed_line (parsed_line)
+    def add_parsed_line(parsed_line)
       value_hash = parsed_line[:line_definition].convert_captured_values(parsed_line[:captures], self)
       value_hash[:line_type] = parsed_line[:line_definition].name
       value_hash[:lineno] = parsed_line[:lineno]
@@ -148,10 +168,10 @@ module RequestLogAnalyzer
     # Checks whether the given line type was parsed from the log file for this request
     def has_line_type?(line_type)
       return true if @lines.length == 1 && @lines[0][:line_type] == line_type.to_sym
-      @lines.detect { |l| l[:line_type] == line_type.to_sym }
+      @lines.find { |l| l[:line_type] == line_type.to_sym }
     end
 
-    alias :=~ :has_line_type?
+    alias_method :=~, :has_line_type?
 
     # Returns the value that was captured for the "field" of this request.
     # This function will return the first value that was captured if the field
@@ -160,11 +180,11 @@ module RequestLogAnalyzer
       @attributes[field]
     end
 
-    alias :[] :first
+    alias_method :[], :first
 
     # Returns an array of all the "field" values that were captured for this request
     def every(field)
-      @lines.inject([]) { |result, fields| result << fields[field] if fields.has_key?(field); result }
+      @lines.reduce([]) { |result, fields| result << fields[field] if fields.key?(field); result }
     end
 
     # Returns true if this request does not yet contain any parsed lines. This should only occur

data/lib/request_log_analyzer/source.rb

@@ -7,13 +7,11 @@
 # - The base class for all sources is RequestLogAnalyzer::Source::Base. All source classes should inherit from this class.
 # - Currently, RequestLogAnalyzer::Source::LogParser is the only implemented source.
 module RequestLogAnalyzer::Source
-
   # The base Source class. All other sources should inherit from this class.
   #
   # A source implememtation should at least implement the each_request method, which should yield
   # RequestLogAnalyzer::Request instances that will be fed through the pipleine.
   class Base
-
     # A hash of options
     attr_reader :options
 
@@ -52,15 +50,14 @@ module RequestLogAnalyzer::Source
     # This function is called to actually produce the requests that will be send into the pipeline.
     # The implementation should yield instances of RequestLogAnalyzer::Request.
     # <tt>options</tt>:: A Hash of options that can be used in the implementation.
-    def each_request(options = {}, &block) # :yields: request
-      return true
+    def each_request(_options = {}, &_block) # :yields: request
+      true
     end
 
     # This function is called after RequestLogAnalyzer::Source::Base#each_request finished. Any code to
     # wrap up, free resources, etc. can be put in this method.
     def finalize
     end
-
   end
 end
 

data/lib/request_log_analyzer/source/log_parser.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer::Source
-
   # The LogParser class reads log data from a given source and uses a file format definition
   # to parse all relevent information about requests from the file. A FileFormat module should
   # be provided that contains the definitions of the lines that occur in the log data.
@@ -10,7 +9,6 @@ module RequestLogAnalyzer::Source
   # parser. It will emit warnings when this occurs. LogParser supports multiple parse strategies
   # that deal differently with this problem.
   class LogParser < Base
-
     include Enumerable
 
     # The maximum number of bytes to read from a line.
@@ -51,7 +49,7 @@ module RequestLogAnalyzer::Source
 
       @options[:parse_strategy] ||= DEFAULT_PARSE_STRATEGY
       unless PARSE_STRATEGIES.include?(@options[:parse_strategy])
-        raise "Unknown parse strategy: #{@options[@parse_strategy]}"
+        fail "Unknown parse strategy: #{@options[@parse_strategy]}"
       end
     end
 
@@ -68,11 +66,10 @@ module RequestLogAnalyzer::Source
     # that will be yielded. The actual parsing occurs in the parse_io method.
     # <tt>options</tt>:: A Hash of options that will be pased to parse_io.
     def each_request(options = {}, &block) # :yields: :request, request
-
       case @source_files
       when IO
         if @source_files == $stdin
-          puts "Parsing from the standard input. Press CTRL+C to finish." # FIXME: not here
+          puts 'Parsing from the standard input. Press CTRL+C to finish.' # FIXME: not here
         end
         parse_stream(@source_files, options, &block)
       when String
@@ -80,7 +77,7 @@ module RequestLogAnalyzer::Source
       when Array
         parse_files(@source_files, options, &block)
       else
-        raise "Unknown source provided"
+        fail 'Unknown source provided'
       end
     end
 
@@ -98,13 +95,13 @@ module RequestLogAnalyzer::Source
     # Check if a file has a compressed extention in the filename.
     # If recognized, return the command string used to decompress the file
     def decompress_file?(filename)
-      nice_command = "nice -n 5"
+      nice_command = 'nice -n 5'
 
       return "#{nice_command} gunzip -c -d #{filename}" if filename.match(/\.tar.gz$/) || filename.match(/\.tgz$/) || filename.match(/\.gz$/)
       return "#{nice_command} bunzip2 -c -d #{filename}" if filename.match(/\.bz2$/)
       return "#{nice_command} unzip -p #{filename}" if filename.match(/\.zip$/)
 
-      return ""
+      ''
     end
 
     # Parses a log file. Creates an IO stream for the provided file, and sends it to parse_io for
@@ -117,7 +114,6 @@ module RequestLogAnalyzer::Source
     # <tt>file</tt>:: The file that should be parsed.
     # <tt>options</tt>:: A Hash of options that will be pased to parse_io.
     def parse_file(file, options = {}, &block)
-
       if File.directory?(file)
         parse_files(Dir["#{ file }/*"], options, &block)
         return
@@ -145,7 +141,6 @@ module RequestLogAnalyzer::Source
       @source_changes_handler.call(:finished, @current_source) if @source_changes_handler
 
       @current_source = nil
-
     end
 
     # Parses an IO stream. It will simply call parse_io. This function does not support progress updates
@@ -187,7 +182,7 @@ module RequestLogAnalyzer::Source
         parse_line(line, &block)
       end
 
-      warn(:unfinished_request_on_eof, "End of file reached, but last request was not completed!") unless @current_request.nil?
+      warn(:unfinished_request_on_eof, 'End of file reached, but last request was not completed!') unless @current_request.nil?
       @current_lineno = nil
     end
 
@@ -214,7 +209,7 @@ module RequestLogAnalyzer::Source
         parse_line(line, &block)
       end
 
-      warn(:unfinished_request_on_eof, "End of file reached, but last request was not completed!") unless @current_request.nil?
+      warn(:unfinished_request_on_eof, 'End of file reached, but last request was not completed!') unless @current_request.nil?
       @current_lineno = nil
     end
 
@@ -227,7 +222,7 @@ module RequestLogAnalyzer::Source
     def parse_line(line, &block) # :yields: request
       if request_data = file_format.parse_line(line) { |wt, message| warn(wt, message) }
         @parsed_lines += 1
-        update_current_request(request_data.merge(:source => @current_source, :lineno => @current_lineno), &block)
+        update_current_request(request_data.merge(source: @current_source, lineno: @current_lineno), &block)
       end
     end
 
@@ -331,21 +326,19 @@ module RequestLogAnalyzer::Source
     # - It will update the parsed_requests and skipped_requests variables accordingly
     #
     # <tt>request</tt>:: The parsed request instance (RequestLogAnalyzer::Request)
-    def handle_request(request, &block) # :yields: :request, request
+    def handle_request(request, &_block) # :yields: :request, request
       @parsed_requests += 1
       request.validate
       accepted = block_given? ? yield(request) : true
       @skipped_requests += 1 unless accepted
     end
 
-
     # Checks whether a given line hash is an alternative header line according to the current file format.
     # <tt>hash</tt>:: A hash of data that was parsed from the line.
     def alternative_header_line?(hash)
       hash[:line_definition].header == :alternative
     end
 
-
     # Checks whether a given line hash is a header line according to the current file format.
     # <tt>hash</tt>:: A hash of data that was parsed from the line.
     def header_line?(hash)