request-log-analyzer 1.13.1 → 1.13.3

data/lib/request_log_analyzer/file_format/w3c.rb

@@ -1,15 +1,13 @@
 module RequestLogAnalyzer::FileFormat
-
   # FileFormat for W3C access logs.
   class W3c < Base
-    
     extend CommonRegularExpressions
 
     line_definition :access do |line|
       line.header = true
       line.footer = true
       line.regexp = /^(#{timestamp('%Y-%m-%d %H:%M:%S')}) (#{ip_address}) (.*) (#{ip_address}) (\d+) (\w+) (\S+) \- (\d+) (\d+) (\d+) (\d+) (.*) (\S+)/
-      
+
       line.capture(:timestamp).as(:timestamp)
       line.capture(:remote_ip)
       line.capture(:username).as(:nillable_string)
@@ -18,9 +16,9 @@ module RequestLogAnalyzer::FileFormat
       line.capture(:method)
       line.capture(:path).as(:path)
       line.capture(:http_status).as(:integer)
-      line.capture(:bytes_sent).as(:traffic, :unit => :byte)
-      line.capture(:bytes_received).as(:traffic, :unit => :byte)
-      line.capture(:duration).as(:duration, :unit => :msec)
+      line.capture(:bytes_sent).as(:traffic, unit: :byte)
+      line.capture(:bytes_received).as(:traffic, unit: :byte)
+      line.capture(:duration).as(:duration, unit: :msec)
       line.capture(:user_agent)
       line.capture(:referer)
     end
@@ -29,24 +27,24 @@ module RequestLogAnalyzer::FileFormat
       analyze.timespan
       analyze.hourly_spread
 
-      analyze.frequency :category => :http_method, :title => "HTTP methods"
-      analyze.frequency :category => :http_status, :title => "HTTP statuses"
-      
-      analyze.frequency :category => :path, :title => "Most popular URIs"
+      analyze.frequency category: :http_method, title: 'HTTP methods'
+      analyze.frequency category: :http_status, title: 'HTTP statuses'
 
-      analyze.frequency :category => :user_agent, :title => "User agents"
-      analyze.frequency :category => :referer,    :title => "Referers"
+      analyze.frequency category: :path, title: 'Most popular URIs'
 
-      analyze.duration :duration => :duration,  :category => :path, :title => 'Request duration'
-      analyze.traffic  :traffic => :bytes_sent, :category => :path, :title => 'Traffic out'
-      analyze.traffic  :traffic => :bytes_received, :category => :path, :title => 'Traffic in'
+      analyze.frequency category: :user_agent, title: 'User agents'
+      analyze.frequency category: :referer,    title: 'Referers'
+
+      analyze.duration duration: :duration,  category: :path, title: 'Request duration'
+      analyze.traffic traffic: :bytes_sent, category: :path, title: 'Traffic out'
+      analyze.traffic traffic: :bytes_received, category: :path, title: 'Traffic in'
     end
-    
+
     class Request < RequestLogAnalyzer::Request
       # Do not use DateTime.parse, but parse the timestamp ourselves to return a integer
       # to speed up parsing.
-      def convert_timestamp(value, definition)
-        "#{value[0,4]}#{value[5,2]}#{value[8,2]}#{value[11,2]}#{value[14,2]}#{value[17,2]}".to_i
+      def convert_timestamp(value, _definition)
+        "#{value[0, 4]}#{value[5, 2]}#{value[8, 2]}#{value[11, 2]}#{value[14, 2]}#{value[17, 2]}".to_i
       end
     end
   end

data/lib/request_log_analyzer/filter.rb

@@ -1,9 +1,7 @@
 module RequestLogAnalyzer::Filter
-
   # Base filter class used to filter input requests.
   # All filters should interit from this base.
   class Base
-
     attr_reader :file_format, :options
 
     # Initializer

data/lib/request_log_analyzer/filter/anonymize.rb

@@ -1,18 +1,16 @@
 module RequestLogAnalyzer::Filter
-
   # 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 Anonymize < Base
-
     def generate_random_ip
       "#{rand(256)}.#{rand(256)}.#{rand(256)}.#{rand(256)}"
     end
 
     def anonymize_url(value)
-      return value.sub(/^https?\:\/\/[A-Za-z0-9\.-]+\//, "http://example.com/")
+      value.sub(/^https?\:\/\/[A-Za-z0-9\.-]+\//, 'http://example.com/')
     end
 
     def fuzz(value)
@@ -26,14 +24,13 @@ module RequestLogAnalyzer::Filter
           request.attributes[key] = generate_random_ip
         elsif key == :url
           request.attributes[key] = anonymize_url(value)
-        elsif [ :duration, :view, :db, :type, :after_filters_time, :before_filters_time,
-                :action_time].include?(key)
+        elsif [:duration, :view, :db, :type, :after_filters_time, :before_filters_time,
+               :action_time].include?(key)
           request.attributes[key] = fuzz(value)
         end
       end
 
-      return request
+      request
     end
   end
-
 end

data/lib/request_log_analyzer/filter/field.rb

@@ -1,12 +1,10 @@
 module RequestLogAnalyzer::Filter
-
   # Filter to select or reject a specific field
   # 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 Field < Base
-
     attr_reader :field, :value, :mode
 
     def initialize(file_format, options = {})
@@ -20,7 +18,7 @@ module RequestLogAnalyzer::Filter
       @field = @options[:field].to_sym
 
       # Convert the timestamp to the correct formats for quick timestamp comparisons
-      if @options[:value].kind_of?(String) && @options[:value][0, 1] == '/' && @options[:value][-1, 1] == '/'
+      if @options[:value].is_a?(String) && @options[:value][0, 1] == '/' && @options[:value][-1, 1] == '/'
         @value = Regexp.new(@options[:value][1..-2])
       else
         @value = @options[:value] # TODO: convert value?
@@ -35,8 +33,7 @@ module RequestLogAnalyzer::Filter
       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
+      request
     end
   end
-
-end
+end

data/lib/request_log_analyzer/filter/timespan.rb

@@ -1,11 +1,9 @@
 module RequestLogAnalyzer::Filter
-
   # Reject all requests not in given timespan
   # Options
   # * <tt>:after</tt> Only keep requests after this DateTime.
   # * <tt>:before</tt> Only keep requests before this DateTime.
   class Timespan < Base
-
     attr_reader :before, :after
 
     def initialize(file_format, options = {})
@@ -15,7 +13,6 @@ module RequestLogAnalyzer::Filter
       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 setup_filter
@@ -38,8 +35,7 @@ module RequestLogAnalyzer::Filter
         return request
       end
 
-      return nil
+      nil
     end
   end
-
-end
+end

data/lib/request_log_analyzer/line_definition.rb

@@ -1,12 +1,9 @@
 module RequestLogAnalyzer
-
   # 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
-
     class Definer
-
       attr_accessor :line_definitions
 
       def initialize
@@ -16,7 +13,7 @@ module RequestLogAnalyzer
       def initialize_copy(other)
         @line_definitions = other.line_definitions.dup
       end
-      
+
       def define_line(name, arg = {}, &block)
         if block_given?
           @line_definitions[name] = RequestLogAnalyzer::LineDefinition.define(name, &block)
@@ -32,14 +29,14 @@ module RequestLogAnalyzer
 
     class CaptureDefiner
       attr_accessor :capture_hash
-      
+
       def initialize(hash)
         @capture_hash = hash
       end
-      
+
       def as(type, type_options = {})
-        @capture_hash.merge!(type_options.merge(:type => type))
-        return self
+        @capture_hash.merge!(type_options.merge(type: type))
+        self
       end
     end
 
@@ -57,15 +54,15 @@ module RequestLogAnalyzer
       @captures = []
       @teaser   = nil
       @compound = []
-      definition.each { |key, value| self.send("#{key.to_s}=".to_sym, value) }
+      definition.each { |key, value| send("#{key}=".to_sym, value) }
     end
 
-    def self.define(name, &block)
-      definition = self.new(name)
+    def self.define(name, &_block)
+      definition = new(name)
       yield(definition) if block_given?
-      return definition
+      definition
     end
-    
+
     def capture(name)
       new_capture_hash = {}
       new_capture_hash[:name] = name
@@ -73,7 +70,7 @@ module RequestLogAnalyzer
       captures << new_capture_hash
       CaptureDefiner.new(new_capture_hash)
     end
-    
+
     def all_captured_variables
       captures.map { |c| c[:name] } + captures.map { |c| c[:provides] }.compact.map { |pr| pr.keys }.flatten
     end
@@ -86,7 +83,7 @@ module RequestLogAnalyzer
     def matches(line, &warning_handler)
       if @teaser.nil? || @teaser =~ line
         if match_data = line.match(@regexp)
-          return { :line_definition => self, :captures => match_data.captures}
+          return { line_definition: self, captures: match_data.captures }
         else
           if @teaser && warning_handler
             warning_handler.call(:teaser_check_failed, "Teaser matched for #{name.inspect}, but full line did not:\n#{line.inspect}")
@@ -100,7 +97,7 @@ module RequestLogAnalyzer
       return false
     end
 
-    alias :=~ :matches
+    alias_method :=~, :matches
 
     # matches the line and converts the captured values using the request's
     # convert_value function.
@@ -124,13 +121,13 @@ module RequestLogAnalyzer
 
         # Add items directly to the resulting hash from the converted value
         # if it is a hash and they are set in the :provides hash for this line definition
-        if converted.kind_of?(Hash) && capture[:provides].kind_of?(Hash)
+        if converted.is_a?(Hash) && capture[:provides].is_a?(Hash)
           capture[:provides].each do |name, type|
-            value_hash[name] ||= request.convert_value(converted[name], { :type => type })
+            value_hash[name] ||= request.convert_value(converted[name],  type: type)
           end
         end
       end
-      return value_hash
+      value_hash
     end
 
     # Returns true if this line captures values of the given name

data/lib/request_log_analyzer/log_processor.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer
-
   # The Logprocessor class is used to perform simple processing actions over log files.
   # It will go over the log file/stream line by line, pass the line to a processor and
   # write the result back to the output file or stream. The processor can alter the
@@ -11,7 +10,6 @@ module RequestLogAnalyzer
   #    sources. A compact, information packed log will remain/.
   #
   class LogProcessor
-
     attr_reader :mode, :options, :sources, :file_format
     attr_accessor :output_file
 
@@ -20,11 +18,10 @@ module RequestLogAnalyzer
     #    processing mode. Currently, only :strip is supported.
     # <tt>arguments</tt> The parsed command line arguments (a CommandLine::Arguments instance)
     def self.build(command, arguments)
-
       options = {
-          :discard_teaser_lines => arguments[:discard_teaser_lines],
-          :keep_junk_lines      => arguments[:keep_junk_lines],
-        }
+        discard_teaser_lines: arguments[:discard_teaser_lines],
+        keep_junk_lines: arguments[:keep_junk_lines]
+      }
 
       log_processor = RequestLogAnalyzer::LogProcessor.new(arguments[:format].to_sym, command, options)
       log_processor.output_file = arguments[:output] if arguments[:output]
@@ -33,7 +30,7 @@ module RequestLogAnalyzer
         log_processor.sources << input
       end
 
-      return log_processor
+      log_processor
     end
 
     # Initializes a new LogProcessor instance.
@@ -60,7 +57,7 @@ module RequestLogAnalyzer
     # <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 :strip then     io.each_line { |line| @output << strip_line(line) }
       end
     end
 
@@ -68,7 +65,7 @@ module RequestLogAnalyzer
     # found, an empty line is returned, which will strip the line from the output.
     # <tt>line</tt> The line to strip
     def strip_line(line)
-      file_format.line_definitions.any? { |name, definition| definition =~ line } ? line : ""
+      file_format.line_definitions.any? { |_name, definition| definition =~ line } ? line : ''
     end
 
     # Runs the log processing by setting up the output stream and iterating over all the
@@ -82,9 +79,9 @@ module RequestLogAnalyzer
       end
 
       @sources.each do |source|
-        if source.kind_of?(String) && File.exist?(source)
+        if source.is_a?(String) && File.exist?(source)
           process_file(source)
-        elsif source.kind_of?(IO)
+        elsif source.is_a?(IO)
           process_io(source)
         elsif ['-', 'STDIN'].include?(source)
           process_io($stdin)
@@ -92,8 +89,7 @@ module RequestLogAnalyzer
       end
 
     ensure
-      @output.close if @output.kind_of?(File)
+      @output.close if @output.is_a?(File)
     end
   end
-
-end
+end

data/lib/request_log_analyzer/mailer.rb

@@ -1,8 +1,6 @@
 module RequestLogAnalyzer
-
   # Mail report to a specified emailaddress
   class Mailer
-
     attr_accessor :data, :to, :host, :port
 
     # Initialize a mailer
@@ -23,7 +21,7 @@ module RequestLogAnalyzer
       @port    = 25
       @options = options
       @host, @port = host.split(':') if @host.include?(':')
-      @data    = []      
+      @data    = []
     end
 
     # Send all data in @data to the email address used during initialization.
@@ -32,10 +30,10 @@ module RequestLogAnalyzer
       from          = @options[:from]        || 'contact@railsdoctors.com'
       from_alias    = @options[:from_alias]  || 'Request-log-analyzer reporter'
       to_alias      = @options[:to_alias]    || to
-      subject       = @options[:subject]     || "Request log analyzer report - generated on #{Time.now.to_s}"
-      content_type  = ""
-      content_type  = 'Content-Type: text/html; charset="ISO-8859-1";' if @data.map{|l| l.include?('html')}.include?(true)
-    msg = <<END_OF_MESSAGE
+      subject       = @options[:subject]     || "Request log analyzer report - generated on #{Time.now}"
+      content_type  = ''
+      content_type  = 'Content-Type: text/html; charset="ISO-8859-1";' if @data.map { |l| l.include?('html') }.include?(true)
+      msg = <<END_OF_MESSAGE
 From: #{from_alias} <#{from}>
 To: #{to_alias} <#{@to}>
 Subject: #{subject}
@@ -50,16 +48,15 @@ END_OF_MESSAGE
         end
       end
 
-      return [msg, from, to] 
+      [msg, from, to]
     end
 
-    def << string
+    def <<(string)
       data << string
     end
 
-    def puts string
+    def puts(string)
       data << string
     end
-
   end
-end
+end

data/lib/request_log_analyzer/output.rb

@@ -1,19 +1,17 @@
 # Module for generating output
 module RequestLogAnalyzer::Output
-
   # Loads a Output::Base subclass instance.
   def self.load(file_format, *args)
-    
     klass = nil
-    if file_format.kind_of?(RequestLogAnalyzer::Output::Base)
+    if file_format.is_a?(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)
+    elsif file_format.is_a?(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)
+    elsif file_format.is_a?(String) && File.exist?(file_format)
       # load a format from a ruby file
       require file_format
       const = RequestLogAnalyzer.to_camelcase(File.basename(file_format, '.rb'))
@@ -22,7 +20,7 @@ module RequestLogAnalyzer::Output
       elsif Object.const_defined?(const)
         klass = Object.const_get(const)
       else
-        raise "Cannot load class #{const} from #{file_format}!"
+        fail "Cannot load class #{const} from #{file_format}!"
       end
 
     else
@@ -31,16 +29,15 @@ module RequestLogAnalyzer::Output
     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)
+    fail "Could not load a file format from #{file_format.inspect}" if klass.nil?
+    fail 'Invalid FileFormat class' unless klass.is_a?(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
@@ -49,9 +46,9 @@ module RequestLogAnalyzer::Output
     def initialize(io, options = {})
       @io      = io
       @options = options
-      @style   = options[:style] || { :cell_separator => true, :table_border => false }
+      @style   = options[:style] || { cell_separator: true, table_border: false }
     end
-    
+
     def report_tracker(tracker)
       tracker.report(self)
     end
@@ -74,7 +71,7 @@ module RequestLogAnalyzer::Output
 
     def slice_results(array)
       return array if options[:amount] == :all
-      return array.slice(0, options[:amount]) # otherwise
+      array.slice(0, options[:amount]) # otherwise
     end
 
     # Generate a report table and push it into the output object.
@@ -98,10 +95,11 @@ module RequestLogAnalyzer::Output
     #   end
     # end
     #
-    def table(*columns, &block)
+    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)