request-log-analyzer 1.13.1 → 1.13.3

data/lib/cli/tools.rb

@@ -6,27 +6,24 @@ module CommandLine
     # If it is not possible to to so, it returns the default_width.
     # <tt>default_width</tt> Defaults to 81
     def terminal_width(default_width = 81, out = STDOUT)
-
+      tiocgwinsz = 0x5413
+      data = [0, 0, 0, 0].pack('SSSS')
+      if !RUBY_PLATFORM.include?('java') && out.ioctl(tiocgwinsz, data) >= 0 # JRuby crashes on ioctl
+        _, cols, _, _ = data.unpack('SSSS')
+        fail unless cols > 0
+        cols
+      else
+        fail
+      end
+    rescue
       begin
-        tiocgwinsz = 0x5413
-        data = [0, 0, 0, 0].pack("SSSS")
-        if !RUBY_PLATFORM.include?('java') && out.ioctl(tiocgwinsz, data) >= 0 # JRuby crashes on ioctl
-          _, cols, _, _ = data.unpack("SSSS")
-          raise unless cols > 0
-          cols
-        else
-          raise
+        IO.popen('stty -a 2>&1') do |pipe|
+          column_line = pipe.find { |line| /(\d+) columns/ =~ line }
+          fail unless column_line
+          Regexp.last_match[1].to_i
         end
       rescue
-        begin
-          IO.popen('stty -a 2>&1') do |pipe|
-            column_line = pipe.detect { |line| /(\d+) columns/ =~ line }
-            raise unless column_line
-            $1.to_i
-          end
-        rescue
-          default_width
-        end
+        default_width
       end
     end
 
@@ -40,14 +37,14 @@ module CommandLine
         if File.directory?('./lib/tasks/')
           task_file = File.expand_path('../../tasks/request_log_analyzer.rake', File.dirname(__FILE__))
           FileUtils.copy(task_file, './lib/tasks/request_log_analyze.rake')
-          puts "Installed rake tasks."
-          puts "To use, run: rake rla:report"
+          puts 'Installed rake tasks.'
+          puts 'To use, run: rake rla:report'
         else
-          puts "Cannot find /lib/tasks folder. Are you in your Rails directory?"
-          puts "Installation aborted."
+          puts 'Cannot find /lib/tasks folder. Are you in your Rails directory?'
+          puts 'Installation aborted.'
         end
       else
-        raise "Cannot perform this install type! (#{install_type.to_s})"
+        fail "Cannot perform this install type! (#{install_type})"
       end
     end
   end

data/lib/request_log_analyzer.rb

@@ -1,37 +1,37 @@
 require 'date'
 
 # RequestLogAnalyzer is the base namespace in which all functionality of RequestLogAnalyzer is implemented.
-# This module itselfs contains some functions to help with class and source file loading. The actual 
+# This module itself contains some functions to help with class and source file loading. The actual
 # application startup code resides in the {RequestLogAnalyzer::Controller} class.
 #
 # The {RequestLogAnalyzer::VERSION} constant can be used to determine what version of request-log-analyzer
 # is running.
 module RequestLogAnalyzer
-
-  # Convert a string/symbol in camelcase ({RequestLogAnalyzer::Controller}) to underscores 
-  # (<tt>request_log_analyzer/controller</tt>). This function can be used to load the file (using 
+  # Convert a string/symbol in camel case ({RequestLogAnalyzer::Controller}) to underscores
+  # (<tt>request_log_analyzer/controller</tt>). This function can be used to load the file (using
   # <tt>require</tt>) in which the given constant is defined.
   #
   # @param [#to_s] str The string-like to convert in the following format: <tt>ModuleName::ClassName</tt>.
   # @return [String] The input string converted to underscore form.
   def self.to_underscore(str)
-    str.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr("-", "_").downcase
+    str.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase
   end
 
   # Convert a string/symbol in underscores (<tt>request_log_analyzer/controller</tt>) to camelcase
-  # ({RequestLogAnalyzer::Controller}). This can be used to find the class that is defined in a given 
+  # ({RequestLogAnalyzer::Controller}). This can be used to find the class that is defined in a given
   # filename.
   #
   # @param [#to_s] str The string-like to convert in the f`ollowing format: <tt>module_name/class_name</tt>.
-  # @return [String] The input string converted to camelcase form.  
+  # @return [String] The input string converted to camelcase form.
   def self.to_camelcase(str)
-    str.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    str.to_s.gsub(/\/(.?)/) { '::' + Regexp.last_match[1].upcase }.gsub(/(^|_)(.)/) { Regexp.last_match[2].upcase }
   end
 end
 
 require 'request_log_analyzer/version'
 require 'request_log_analyzer/controller'
 require 'request_log_analyzer/aggregator'
+require 'request_log_analyzer/class_level_inheritable_attributes'
 require 'request_log_analyzer/file_format'
 require 'request_log_analyzer/filter'
 require 'request_log_analyzer/line_definition'

data/lib/request_log_analyzer/aggregator.rb

@@ -1,9 +1,7 @@
 module RequestLogAnalyzer::Aggregator
-
   # The base class of an aggregator. This class provides the interface to which
   # every aggregator should comply (by simply subclassing this class).
   class Base
-
     attr_reader :options, :source
 
     # Intializes a new RequestLogAnalyzer::Aggregator::Base instance
@@ -20,7 +18,7 @@ module RequestLogAnalyzer::Aggregator
 
     # The aggregate function is called for every request.
     # Implement the aggregating functionality in this method
-    def aggregate(request)
+    def aggregate(_request)
     end
 
     # The finalize function is called after all sources are parsed and no more
@@ -29,18 +27,17 @@ module RequestLogAnalyzer::Aggregator
     end
 
     # The warning method is called if the parser eits a warning.
-    def warning(type, message, lineno)
+    def warning(_type, _message, _lineno)
     end
 
     # The report function is called at the end. Implement any result reporting
     # in this function.
-    def report(output)
+    def report(_output)
     end
 
     # The source_change function gets called when handling a source is started or finished.
-    def source_change(change, filename)
+    def source_change(_change, _filename)
     end
-
   end
 end
 

data/lib/request_log_analyzer/aggregator/database_inserter.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer::Aggregator
-
   # The database aggregator will create an SQLite3 database with all parsed request information.
   #
   # The prepare method will create a database schema according to the file format definitions.
@@ -12,14 +11,13 @@ module RequestLogAnalyzer::Aggregator
   # the request record, and a field for every parsed value. Finally, a warnings table will be
   # created to log all parse warnings.
   class DatabaseInserter < Base
-
     attr_reader :request_count, :sources, :database
 
     # Establishes a connection to the database and creates the necessary database schema for the
     # current file format
     def prepare
       require 'request_log_analyzer/database'
-      
+
       @sources = {}
       @database = RequestLogAnalyzer::Database.new(options[:database])
       @database.file_format = source.file_format
@@ -32,14 +30,14 @@ module RequestLogAnalyzer::Aggregator
     # This will create a record in the requests table and create a record for every line that has been parsed,
     # in which the captured values will be stored.
     def aggregate(request)
-      @request_object = RequestLogAnalyzer::Database::Request.new(:first_lineno => request.first_lineno, :last_lineno => request.last_lineno)
+      @request_object = RequestLogAnalyzer::Database::Request.new(first_lineno: request.first_lineno, last_lineno: request.last_lineno)
       request.lines.each do |line|
-        class_columns = database.get_class(line[:line_type]).column_names.reject { |column| ['id', 'source_id', 'request_id'].include?(column) }
-        attributes = Hash[*line.select { |(key, _)| class_columns.include?(key.to_s)}.flatten]
-        
+        class_columns = database.get_class(line[:line_type]).column_names.reject { |column| %w(id source_id request_id).include?(column) }
+        attributes = Hash[*line.select { |(key, _)| class_columns.include?(key.to_s) }.flatten]
+
         # Fix encoding patch for 1.9.2
-        attributes.each do |k,v|
-          attributes[k] = v.force_encoding("UTF-8") if v.is_a?(String)
+        attributes.each do |k, v|
+          attributes[k] = v.force_encoding('UTF-8') if v.is_a?(String)
         end
 
         @request_object.send("#{line[:line_type]}_lines").build(attributes)
@@ -58,7 +56,7 @@ module RequestLogAnalyzer::Aggregator
 
     # Records w warining in the warnings table.
     def warning(type, message, lineno)
-      RequestLogAnalyzer::Database::Warning.create!(:warning_type => type.to_s, :message => message, :lineno => lineno)
+      RequestLogAnalyzer::Database::Warning.create!(warning_type: type.to_s, message: message, lineno: lineno)
     end
 
     # Records source changes in the sources table
@@ -66,9 +64,9 @@ module RequestLogAnalyzer::Aggregator
       if File.exist?(filename)
         case change
         when :started
-          @sources[filename] = RequestLogAnalyzer::Database::Source.create!(:filename => filename)
+          @sources[filename] = RequestLogAnalyzer::Database::Source.create!(filename: filename)
         when :finished
-          @sources[filename].update_attributes!(:filesize => File.size(filename), :mtime => File.mtime(filename))
+          @sources[filename].update_attributes!(filesize: File.size(filename), mtime: File.mtime(filename))
         end
       end
     end
@@ -84,6 +82,5 @@ module RequestLogAnalyzer::Aggregator
       output <<  output.colorize("  $ request-log-analyzer console -d #{options[:database]}\n", :bold)
       output << "\n"
     end
-
   end
 end

data/lib/request_log_analyzer/aggregator/echo.rb

@@ -1,8 +1,6 @@
 module RequestLogAnalyzer::Aggregator
-
   # Echo Aggregator. Writes everything to the screen when it is passed to this aggregator
   class Echo < Base
-
     attr_accessor :warnings
 
     def prepare
@@ -11,8 +9,9 @@ module RequestLogAnalyzer::Aggregator
 
     # Display every parsed line immediately to the terminal
     def aggregate(request)
-      puts "\nRequest: \n" + request.lines.map { |l| 
-        "\t#{l[:lineno]}:#{l[:line_type]}: #{l.reject { |(k,_)| [:lineno, :line_type].include?(k) }.inspect}" }.join("\n")
+      puts "\nRequest: \n" + request.lines.map do |l|
+        "\t#{l[:lineno]}:#{l[:line_type]}: #{l.reject { |(k, _)| [:lineno, :line_type].include?(k) }.inspect}"
+      end.join("\n")
     end
 
     # Capture all warnings during parsing
@@ -22,9 +21,8 @@ module RequestLogAnalyzer::Aggregator
 
     # Display every warning in the report when finished parsing
     def report(output)
-      output.title("Warnings during parsing")
+      output.title('Warnings during parsing')
       @warnings.each { |w| output.puts(w) }
     end
-
   end
-end
+end

data/lib/request_log_analyzer/aggregator/summarizer.rb

@@ -1,9 +1,6 @@
 module RequestLogAnalyzer::Aggregator
-
   class Summarizer < Base
-
     class Definer
-
       attr_reader :trackers
 
       # Initialize tracker array
@@ -31,8 +28,8 @@ module RequestLogAnalyzer::Aggregator
       # <tt>tracker_class</tt> The class to include
       # <tt>optiont</tt> The options to pass to the trackers.
       def track(tracker_klass, value_field = {}, other_options = {})
-        options = value_field.kind_of?(Symbol) ? other_options.merge(:value => value_field) : value_field.merge(other_options)
-        tracker_klass = RequestLogAnalyzer::Tracker.const_get(RequestLogAnalyzer.to_camelcase(tracker_klass)) if tracker_klass.kind_of?(Symbol)
+        options = value_field.is_a?(Symbol) ? other_options.merge(value: value_field) : value_field.merge(other_options)
+        tracker_klass = RequestLogAnalyzer::Tracker.const_get(RequestLogAnalyzer.to_camelcase(tracker_klass)) if tracker_klass.is_a?(Symbol)
         @trackers << tracker_klass.new(options)
       end
     end
@@ -54,7 +51,7 @@ module RequestLogAnalyzer::Aggregator
 
     # Call prepare on all trackers.
     def prepare
-      raise "No trackers set up in Summarizer!" if @trackers.nil? || @trackers.empty?
+      fail 'No trackers set up in Summarizer!' if @trackers.nil? || @trackers.empty?
       @trackers.each { |tracker| tracker.prepare }
     end
 
@@ -82,7 +79,7 @@ module RequestLogAnalyzer::Aggregator
     # for every tracker and combines these into a single YAML export.
     def to_yaml
       require 'yaml'
-      trackers_export = @trackers.inject({}) do |export, tracker|
+      trackers_export = @trackers.reduce({}) do |export, tracker|
         export[tracker.title] = tracker.to_yaml_object; export
       end
       YAML.dump(trackers_export)
@@ -104,10 +101,10 @@ module RequestLogAnalyzer::Aggregator
     # Generate report header.
     # <tt>output</tt> RequestLogAnalyzer::Output object to output to
     def report_header(output)
-      output.title("Request summary")
+      output.title('Request summary')
 
-      output.with_style(:cell_separator => false) do
-        output.table({:width => 20}, {:font => :bold}) do |rows|
+      output.with_style(cell_separator: false) do
+        output.table({ width: 20 }, { font: :bold }) do |rows|
           source.processed_files.each do |f|
             rows << ['Processed File:', f]
           end
@@ -115,7 +112,7 @@ module RequestLogAnalyzer::Aggregator
           rows << ['Skipped lines:',    source.skipped_lines]
           rows << ['Parsed requests:',  source.parsed_requests]
           rows << ['Skipped requests:', source.skipped_requests]
-          rows << ["Warnings:", @warnings_encountered.map { |(key, value)| "#{key}: #{value}" }.join(', ')] if has_warnings?
+          rows << ['Warnings:', @warnings_encountered.map { |(key, value)| "#{key}: #{value}" }.join(', ')] if has_warnings?
         end
       end
       output << "\n"
@@ -125,19 +122,19 @@ module RequestLogAnalyzer::Aggregator
     # <tt>output</tt> RequestLogAnalyzer::Output object to output to
     def report_footer(output)
       if has_log_ordering_warnings?
-        output.title("Parse warnings")
+        output.title('Parse warnings')
 
-        output.puts "Parsable lines were encountered without a header line before it. It"
-        output.puts "could be that logging is not setup correctly for your application."
-        output.puts "Visit this website for logging configuration tips:"
-        output.puts output.link("http://github.com/wvanbergen/request-log-analyzer/wikis/configure-logging")
+        output.puts 'Parsable lines were encountered without a header line before it. It'
+        output.puts 'could be that logging is not setup correctly for your application.'
+        output.puts 'Visit this website for logging configuration tips:'
+        output.puts output.link('http://github.com/wvanbergen/request-log-analyzer/wikis/configure-logging')
         output.puts
       end
     end
 
     # Returns true if there were any warnings generated by the trackers
     def has_warnings?
-      @warnings_encountered.inject(0) { |result, (_, value)| result += value } > 0
+      @warnings_encountered.reduce(0) { |result, (_, value)| result += value } > 0
     end
 
     # Returns true if there were any log ordering warnings
@@ -149,7 +146,7 @@ module RequestLogAnalyzer::Aggregator
     # <tt>type</tt> Type of warning
     # <tt>message</tt> Warning message
     # <tt>lineno</tt> The line on which the error was encountered
-    def warning(type, message, lineno)
+    def warning(type, _message, _lineno)
       @warnings_encountered[type] ||= 0
       @warnings_encountered[type] += 1
     end

data/lib/request_log_analyzer/class_level_inheritable_attributes.rb

@@ -0,0 +1,23 @@
+module RequestLogAnalyzer
+  module ClassLevelInheritableAttributes
+    def inheritable_attributes(*args)
+      @inheritable_attributes ||= [:inheritable_attributes]
+      @inheritable_attributes += args
+      args.each do |arg|
+        class_eval %(
+          class << self; attr_accessor :#{arg} end
+        )
+      end
+      @inheritable_attributes
+    end
+
+    def inherited(subclass)
+      @inheritable_attributes.each do |inheritable_attribute|
+        instance_var = "@#{inheritable_attribute}"
+        subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+      end
+
+      super
+    end
+  end
+end

data/lib/request_log_analyzer/controller.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer
-
   # The RequestLogAnalyzer::Controller class creates a LogParser instance for the
   # requested file format and connect it with sources and aggregators.
   #
@@ -14,13 +13,11 @@ module RequestLogAnalyzer
   # sources are registered in the correct order. This can be helpful to parse requests
   # from several logrotated log files.
   class Controller
-
     attr_reader :source, :filters, :aggregators, :output, :options
 
     # Builds a RequestLogAnalyzer::Controller given parsed command line arguments
     # <tt>arguments<tt> A CommandLine::Arguments hash containing parsed commandline parameters.
     def self.build_from_arguments(arguments)
-
       options = {}
 
       # Copy fields
@@ -51,9 +48,9 @@ module RequestLogAnalyzer
 
       # Apache format workaround
       if arguments[:rails_format]
-        options[:format] = {:rails => arguments[:rails_format]}
+        options[:format] = { rails: arguments[:rails_format] }
       elsif arguments[:apache_format]
-        options[:format] = {:apache => arguments[:apache_format]}
+        options[:format] = { apache: arguments[:apache_format] }
       end
 
       # Handle output format casing
@@ -149,7 +146,7 @@ module RequestLogAnalyzer
 
       # Deprecation warnings
       if options[:dump]
-        warn "[DEPRECATION] `:dump` is deprecated.  Please use `:yaml` instead."
+        warn '[DEPRECATION] `:dump` is deprecated.  Please use `:yaml` instead.'
         options[:yaml]          = options[:dump]
       end
 
@@ -166,21 +163,21 @@ module RequestLogAnalyzer
       output_amount = options[:report_amount] == 'all' ? :all : options[:report_amount].to_i
 
       if options[:file]
-        output_object = %w[File StringIO].include?(options[:file].class.name) ? options[:file] : File.new(options[:file], "w+")
-        output_args   = {:width => 80, :color => false, :characters => :ascii, :sort => output_sort, :amount => output_amount }
+        output_object = %w(        File StringIO        ).include?(options[:file].class.name) ? options[:file] : File.new(options[:file], 'w+')
+        output_args   = { width: 80, color: false, characters: :ascii, sort: output_sort, amount: output_amount }
       elsif options[:mail]
-        output_object = RequestLogAnalyzer::Mailer.new(options[:mail], options[:mailhost], :subject => options[:mailsubject], :from => options[:mailfrom], :from_alias => options[:mailfrom_name])
-        output_args   = {:width => 80, :color => false, :characters => :ascii, :sort => output_sort, :amount => output_amount  }
+        output_object = RequestLogAnalyzer::Mailer.new(options[:mail], options[:mailhost], subject: options[:mailsubject], from: options[:mailfrom], from_alias: options[:mailfrom_name])
+        output_args   = { width: 80, color: false, characters: :ascii, sort: output_sort, amount: output_amount  }
       else
         output_object = STDOUT
-        output_args   = {:width => options[:report_width].to_i, :color => !options[:boring],
-                        :characters => (options[:boring] ? :ascii : :utf), :sort => output_sort, :amount => output_amount }
+        output_args   = { width: options[:report_width].to_i, color: !options[:boring],
+                        characters: (options[:boring] ? :ascii : :utf), sort: output_sort, amount: output_amount }
       end
 
       output_instance = output_class.new(output_object, output_args)
 
       # Create the controller with the correct file format
-      if options[:format].kind_of?(Hash)
+      if options[:format].is_a?(Hash)
         file_format = RequestLogAnalyzer::FileFormat.load(options[:format].keys[0], options[:format].values[0])
       else
         file_format = RequestLogAnalyzer::FileFormat.load(options[:format])
@@ -189,15 +186,15 @@ module RequestLogAnalyzer
       # Kickstart the controller
       controller =
         Controller.new(options[:source].new(file_format,
-                                            :source_files => options[:source_files],
-                                            :parse_strategy => options[:parse_strategy]),
-                       { :output         => output_instance,
-                         :database       => options[:database],                # FUGLY!
-                         :yaml           => options[:yaml],
-                         :reset_database => options[:reset_database],
-                         :no_progress    => options[:no_progress],
-                         :silent         => options[:silent]
-                       })
+                                            source_files: options[:source_files],
+                                            parse_strategy: options[:parse_strategy]),
+                       output: output_instance,
+                       database: options[:database],                # FUGLY!
+                       yaml: options[:yaml],
+                       reset_database: options[:reset_database],
+                       no_progress: options[:no_progress],
+                       silent: options[:silent]
+                       )
 
       # register filters
       if options[:after] || options[:before]
@@ -215,13 +212,13 @@ module RequestLogAnalyzer
 
       if options[:reject]
         options[:reject].each do |(field, value)|
-          controller.add_filter(:field, :mode => :reject, :field => field, :value => value)
+          controller.add_filter(:field, mode: :reject, field: field, value: value)
         end
       end
 
       if options[:select]
         options[:select].each do |(field, value)|
-          controller.add_filter(:field, :mode => :select, :field => field, :value => value)
+          controller.add_filter(:field, mode: :select, field: field, value: value)
         end
       end
 
@@ -232,7 +229,7 @@ module RequestLogAnalyzer
       controller.add_aggregator(:database_inserter)   if options[:database] && !options[:aggregator].include?('database')
 
       file_format.setup_environment(controller)
-      return controller
+      controller
     end
 
     # Builds a new Controller for the given log file format.
@@ -244,7 +241,6 @@ module RequestLogAnalyzer
     # * <tt>:no_progress</tt> No progress bar
     # * <tt>:silent</tt> Minimal output, only error
     def initialize(source, options = {})
-
       @source      = source
       @options     = options
       @aggregators = []
@@ -253,7 +249,7 @@ module RequestLogAnalyzer
       @interrupted = false
 
       # Register the request format for this session after checking its validity
-      raise "Invalid file format!" unless @source.file_format.valid?
+      fail 'Invalid file format!' unless @source.file_format.valid?
 
       # Install event handlers for wrnings, progress updates and source changes
       @source.warning        = lambda { |type, message, lineno|  @aggregators.each { |agg| agg.warning(type, message, lineno) } }
@@ -290,15 +286,15 @@ module RequestLogAnalyzer
     # Adds an aggregator to the controller. The aggregator will be called for every request
     # that is parsed from the provided sources (see add_source)
     def add_aggregator(agg)
-      agg = RequestLogAnalyzer::Aggregator.const_get(RequestLogAnalyzer.to_camelcase(agg)) if agg.kind_of?(String) || agg.kind_of?(Symbol)
+      agg = RequestLogAnalyzer::Aggregator.const_get(RequestLogAnalyzer.to_camelcase(agg)) if agg.is_a?(String) || agg.is_a?(Symbol)
       @aggregators << agg.new(@source, @options)
     end
 
-    alias :>> :add_aggregator
+    alias_method :>>, :add_aggregator
 
     # Adds a request filter to the controller.
     def add_filter(filter, filter_options = {})
-      filter = RequestLogAnalyzer::Filter.const_get(RequestLogAnalyzer.to_camelcase(filter)) if filter.kind_of?(Symbol)
+      filter = RequestLogAnalyzer::Filter.const_get(RequestLogAnalyzer.to_camelcase(filter)) if filter.is_a?(Symbol)
       @filters << filter.new(source.file_format, @options.merge(filter_options))
     end
 
@@ -310,7 +306,7 @@ module RequestLogAnalyzer
         request = filter.filter(request)
         return nil if request.nil?
       end
-      return request
+      request
     end
 
     # Push a request to all the aggregators (@aggregators).
@@ -318,7 +314,7 @@ module RequestLogAnalyzer
     def aggregate_request(request)
       return false unless request
       @aggregators.each { |agg| agg.aggregate(request) }
-      return true
+      true
     end
 
     # Runs RequestLogAnalyzer
@@ -330,7 +326,6 @@ module RequestLogAnalyzer
     # 5. Call report on every aggregator
     # 6. Finalize Source
     def run!
-
       # @aggregators.each{|agg| p agg}
 
       @aggregators.each { |agg| agg.prepare }
@@ -349,27 +344,26 @@ module RequestLogAnalyzer
 
       @source.finalize
 
-      if @output.io.kind_of?(File)
+      if @output.io.is_a?(File)
         unless @options[:silent]
           puts
-          puts "Report written to: " + File.expand_path(@output.io.path)
-          puts "Need an expert to analyze your application?"
-          puts "Mail to contact@railsdoctors.com or visit us at http://railsdoctors.com"
-          puts "Thanks for using request-log-analyzer!"
+          puts 'Report written to: ' + File.expand_path(@output.io.path)
+          puts 'Need an expert to analyze your application?'
+          puts 'Mail to contact@railsdoctors.com or visit us at http://railsdoctors.com'
+          puts 'Thanks for using request-log-analyzer!'
         end
         @output.io.close
-      elsif @output.io.kind_of?(RequestLogAnalyzer::Mailer)
+      elsif @output.io.is_a?(RequestLogAnalyzer::Mailer)
         @output.io.mail
       end
     end
 
     def install_signal_handlers
-      Signal.trap("INT") do
+      Signal.trap('INT') do
         handle_progress(:interrupted)
-        puts "Caught interrupt! Stopping parsing..."
+        puts 'Caught interrupt! Stopping parsing...'
         @interrupted = true
       end
     end
-
   end
 end