request-log-analyzer 1.13.1 → 1.13.3

data/lib/request_log_analyzer/tracker.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer::Tracker
-
   # Base Tracker class. All other trackers inherit from this class
   #
   # Accepts the following options:
@@ -10,7 +9,6 @@ module RequestLogAnalyzer::Tracker
   #
   # For example :if => lambda { |request| request[:duration] && request[:duration] > 1.0 }
   class Base
-
     attr_reader :options
 
     # Initialize the class
@@ -21,7 +19,7 @@ module RequestLogAnalyzer::Tracker
     # * <tt>:if</tt> Handle request if this proc is true for the handled request.
     # * <tt>:unless</tt> Handle request if this proc is false for the handled request.
     # * <tt>:line_type</tt> Line type this tracker will accept.
-    def initialize(options ={})
+    def initialize(options = {})
       @options = options
       setup_should_update_checks!
     end
@@ -29,20 +27,20 @@ module RequestLogAnalyzer::Tracker
     # Sets up the tracker's should_update? checks.
     def setup_should_update_checks!
       @should_update_checks = []
-      @should_update_checks.push( lambda { |request| request.has_line_type?(options[:line_type]) } ) if options[:line_type]
+      @should_update_checks.push(lambda { |request| request.has_line_type?(options[:line_type]) }) if options[:line_type]
       @should_update_checks.push(options[:if]) if options[:if].respond_to?(:call)
-      @should_update_checks.push( lambda { |request| request[options[:if]] }) if options[:if].kind_of?(Symbol)
-      @should_update_checks.push( lambda { |request| !options[:unless].call(request) }) if options[:unless].respond_to?(:call)
-      @should_update_checks.push( lambda { |request| !request[options[:unless]] }) if options[:unless].kind_of?(Symbol)
+      @should_update_checks.push(lambda { |request| request[options[:if]] }) if options[:if].is_a?(Symbol)
+      @should_update_checks.push(lambda { |request| !options[:unless].call(request) }) if options[:unless].respond_to?(:call)
+      @should_update_checks.push(lambda { |request| !request[options[:unless]] }) if options[:unless].is_a?(Symbol)
     end
-    
-    # Creates a lambda expression to return a static field from a request. If the 
+
+    # Creates a lambda expression to return a static field from a request. If the
     # argument already is a lambda exprssion, it will simply return the argument.
     def create_lambda(arg)
       case arg
       when Proc   then arg
       when Symbol then lambda { |request| request[arg] }
-      else raise "Canot create a lambda expression from this argument: #{arg.inspect}!"
+      else fail "Canot create a lambda expression from this argument: #{arg.inspect}!"
       end
     end
 
@@ -52,7 +50,7 @@ module RequestLogAnalyzer::Tracker
 
     # Will be called with each request.
     # <tt>request</tt> The request to track data in.
-    def update(request)
+    def update(_request)
     end
 
     # Hook things that need to be done after running here.
@@ -77,7 +75,7 @@ module RequestLogAnalyzer::Tracker
     # Defaults to self.inspect
     # <tt>output</tt> The output object the report will be passed to.
     def report(output)
-      output << self.inspect
+      output << inspect
       output << "\n"
     end
 

data/lib/request_log_analyzer/tracker/duration.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer::Tracker
-
   # Analyze the duration of a specific attribute
   #
   # === Options
@@ -20,7 +19,6 @@ module RequestLogAnalyzer::Tracker
   #  EmployeeController#index.html [GET]            |    5802 |  1477.32s |     0.25s
   #  .............
   class Duration < NumericValue
-
     # Check if duration and catagory option have been received,
     def prepare
       options[:value] = options[:duration] if options[:duration]
@@ -38,10 +36,10 @@ module RequestLogAnalyzer::Tracker
     def display_value(time)
       case time
       when nil       then '-'
-      when 0...1     then "%0ims" % (time*1000)
-      when 1...60    then "%0.02fs" % time
-      when 60...3600 then "%dm%02ds" % [time / 60, (time % 60).round]
-      else                "%dh%02dm%02ds" % [time / 3600, (time % 3600) / 60, (time % 60).round]
+      when 0...1     then '%0ims' % (time * 1000)
+      when 1...60    then '%0.02fs' % time
+      when 60...3600 then '%dm%02ds' % [time / 60, (time % 60).round]
+      else                '%dh%02dm%02ds' % [time / 3600, (time % 3600) / 60, (time % 60).round]
       end
     end
 

data/lib/request_log_analyzer/tracker/frequency.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer::Tracker
-
   # Catagorize requests by frequency.
   # Count and analyze requests for a specific attribute
   #
@@ -21,19 +20,18 @@ module RequestLogAnalyzer::Tracker
   #  POST   |  11662 hits (24.2%) |=========
   #  DELETE |    512 hits (1.1%)  |
   class Frequency < Base
-
     attr_reader :categories
 
     # Check if categories are set up
     def prepare
       options[:category] = options[:value] if options[:value] && !options[:category]
-      raise "No categorizer set up for category tracker #{self.inspect}" unless options[:category]
-      
+      fail "No categorizer set up for category tracker #{inspect}" unless options[:category]
+
       @categorizer = create_lambda(options[:category]) unless options[:multiple]
-      
-      # Initialize the categories. Use the list of category names to 
+
+      # Initialize the categories. Use the list of category names to
       @categories = {}
-      options[:all_categories].each { |cat| @categories[cat] = 0 } if options[:all_categories].kind_of?(Enumerable)
+      options[:all_categories].each { |cat| @categories[cat] = 0 } if options[:all_categories].is_a?(Enumerable)
     end
 
     # Check HTTP method of a request and store that in the categories hash.
@@ -45,9 +43,9 @@ module RequestLogAnalyzer::Tracker
           if cat || options[:nils]
             @categories[cat] ||= 0
             @categories[cat] += 1
-          end          
+          end
         end
-        
+
       else
         cat = @categorizer.call(request)
         if cat || options[:nils]
@@ -65,7 +63,7 @@ module RequestLogAnalyzer::Tracker
 
     # Return the overall frequency
     def overall_frequency
-      categories.inject(0) { |carry, item| carry + item[1] }
+      categories.reduce(0) { |carry, item| carry + item[1] }
     end
 
     # Return the methods sorted by frequency
@@ -85,7 +83,7 @@ module RequestLogAnalyzer::Tracker
         sorted_categories = output.slice_results(sorted_by_frequency)
         total_hits        = overall_frequency
 
-        output.table({:align => :left}, {:align => :right }, {:align => :right}, {:type => :ratio, :width => :rest}) do |rows|
+        output.table({ align: :left }, { align: :right }, { align: :right }, { type: :ratio, width: :rest }) do |rows|
           sorted_categories.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

data/lib/request_log_analyzer/tracker/hourly_spread.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer::Tracker
-
   # Determines the average hourly spread of the parsed requests.
   # This spread is shown in a graph form.
   #
@@ -29,31 +28,29 @@ module RequestLogAnalyzer::Tracker
   #   18:00 - 107 hits        : ==
   #   ................
   class HourlySpread < Base
-
     attr_reader :hour_frequencies, :first, :last
 
     # Check if timestamp field is set in the options and prepare the result time graph.
     def prepare
       options[:field] ||= :timestamp
       @hour_frequencies = (0...24).map { 0 }
-      @first, @last = 99999999999999, 0
+      @first, @last = 99_999_999_999_999, 0
     end
 
     # Check if the timestamp in the request and store it.
     # <tt>request</tt> The request.
     def update(request)
       timestamp = request.first(options[:field])
-      @hour_frequencies[timestamp.to_s[8..9].to_i] +=1
+      @hour_frequencies[timestamp.to_s[8..9].to_i] += 1
       @first = timestamp if timestamp < @first
       @last  = timestamp if timestamp > @last
     end
 
     # Total amount of requests tracked
     def total_requests
-      @hour_frequencies.inject(0) { |sum, value| sum + value }
+      @hour_frequencies.reduce(0) { |sum, value| sum + value }
     end
 
-
     # First timestamp encountered
     def first_timestamp
       DateTime.parse(@first.to_s, '%Y%m%d%H%M%S') rescue nil
@@ -68,7 +65,7 @@ module RequestLogAnalyzer::Tracker
     def timespan
       last_timestamp - first_timestamp
     end
-    
+
     # Generate an hourly spread report to the given output object.
     # Any options for the report should have been set during initialize.
     # <tt>output</tt> The output object
@@ -81,25 +78,25 @@ module RequestLogAnalyzer::Tracker
       end
 
       days = [1, timespan].max
-      output.table({}, {:align => :right}, {:type => :ratio, :width => :rest, :treshold => 0.15}) do |rows|
+      output.table({}, { align: :right }, { type: :ratio, width: :rest, treshold: 0.15 }) do |rows|
         @hour_frequencies.each_with_index do |requests, index|
           ratio            = requests.to_f / total_requests.to_f
           requests_per_day = (requests / days).ceil
-          rows << ["#{index.to_s.rjust(3)}:00", "%d hits/day" % requests_per_day, ratio]
+          rows << ["#{index.to_s.rjust(3)}:00", '%d hits/day' % requests_per_day, ratio]
         end
       end
     end
 
     # Returns the title of this tracker for reports
     def title
-      options[:title] || "Request distribution per hour"
+      options[:title] || 'Request distribution per hour'
     end
 
     # Returns the found frequencies per hour as a hash for YAML exporting
     def to_yaml_object
       yaml_object = {}
       @hour_frequencies.each_with_index do |freq, hour|
-        yaml_object["#{hour}:00 - #{hour+1}:00"] = freq
+        yaml_object["#{hour}:00 - #{hour + 1}:00"] = freq
       end
       yaml_object
     end

data/lib/request_log_analyzer/tracker/numeric_value.rb

@@ -1,22 +1,19 @@
 module RequestLogAnalyzer::Tracker
-
   class NumericValue < Base
-
     attr_reader :categories
 
     # Sets up the numeric value tracker. It will check whether the value and category
     # options are set that are used to extract and categorize the values during
     # parsing. Two lambda procedures are created for these tasks
     def prepare
-
-      raise "No value field set up for numeric tracker #{self.inspect}" unless options[:value]
-      raise "No categorizer set up for numeric tracker #{self.inspect}" unless options[:category]
+      fail "No value field set up for numeric tracker #{inspect}" unless options[:value]
+      fail "No categorizer set up for numeric tracker #{inspect}" unless options[:category]
 
       unless options[:multiple]
         @categorizer = create_lambda(options[:category])
         @valueizer   = create_lambda(options[:value])
       end
-      
+
       @number_of_buckets = options[:number_of_buckets] || 1000
       @min_bucket_value  = options[:min_bucket_value] ? options[:min_bucket_value].to_f : 0.000001
       @max_bucket_value  = options[:max_bucket_value] ? options[:max_bucket_value].to_f : 1_000_000_000
@@ -44,15 +41,15 @@ module RequestLogAnalyzer::Tracker
       if options[:multiple]
         found_categories = request.every(options[:category])
         found_values     = request.every(options[:value])
-        raise "Capture mismatch for multiple values in a request" unless found_categories.length == found_values.length
+        fail 'Capture mismatch for multiple values in a request' unless found_categories.length == found_values.length
 
         found_categories.each_with_index do |cat, index|
-          update_statistics(cat, found_values[index]) if cat && found_values[index].kind_of?(Numeric)
+          update_statistics(cat, found_values[index]) if cat && found_values[index].is_a?(Numeric)
         end
       else
         category = @categorizer.call(request)
         value    = @valueizer.call(request)
-        update_statistics(category, value) if (value.kind_of?(Numeric) || value.kind_of?(Array)) && category
+        update_statistics(category, value) if (value.is_a?(Numeric) || value.is_a?(Array)) && category
       end
     end
 
@@ -62,11 +59,11 @@ module RequestLogAnalyzer::Tracker
     # === Options
     #  * </tt>:title</tt> The title of the table
     #  * </tt>:sort</tt> The key to sort on (:hits, :cumulative, :average, :min or :max)
-    def report_table(output, sort, options = {}, &block)
+    def report_table(output, sort, options = {}, &_block)
       output.puts
       top_categories = output.slice_results(sorted_by(sort))
-      output.with_style(:top_line => true) do
-        output.table(*statistics_header(:title => options[:title], :highlight => sort)) do |rows|
+      output.with_style(top_line: true) do
+        output.table(*statistics_header(title: options[:title], highlight: sort)) do |rows|
           top_categories.each { |(category, _)| rows << statistics_row(category) }
         end
       end
@@ -74,16 +71,16 @@ module RequestLogAnalyzer::Tracker
 
     # Display a value
     def display_value(value)
-      return "- " if value.nil?
-      return "0 " if value.zero?
+      return '- ' if value.nil?
+      return '0 ' if value.zero?
 
       case [Math.log10(value.abs).floor, 0].max
         when  0...4  then '%d ' % value
         when  4...7  then '%dk' % (value / 1000)
-        when  7...10 then '%dM' % (value / 1000_000)
-        when 10...13 then '%dG' % (value / 1000_000_000)
-        when 13...16 then '%dT' % (value / 1000_000_000_000)
-        else              '%dP' % (value / 1000_000_000_000_000)
+        when  7...10 then '%dM' % (value / 1_000_000)
+        when 10...13 then '%dG' % (value / 1_000_000_000)
+        when 13...16 then '%dT' % (value / 1_000_000_000_000)
+        else              '%dP' % (value / 1_000_000_000_000_000)
       end
     end
 
@@ -94,7 +91,7 @@ module RequestLogAnalyzer::Tracker
     def report(output)
       sortings = output.options[:sort] || [:sum, :mean]
       sortings.each do |sorting|
-        report_table(output, sorting, :title => "#{title} - by #{sorting}")
+        report_table(output, sorting, title: "#{title} - by #{sorting}")
       end
 
       if options[:total]
@@ -109,9 +106,9 @@ module RequestLogAnalyzer::Tracker
         if options[:title]
           options[:title]
         else
-          title_builder = ""
-          title_builder << "#{options[:value]} " if options[:value].kind_of?(Symbol)
-          title_builder << (options[:category].kind_of?(Symbol) ? "per #{options[:category]}" : "per request")
+          title_builder = ''
+          title_builder << "#{options[:value]} " if options[:value].is_a?(Symbol)
+          title_builder << (options[:category].is_a?(Symbol) ? "per #{options[:category]}" : 'per request')
           title_builder
         end
       end
@@ -154,8 +151,8 @@ module RequestLogAnalyzer::Tracker
     # Returns a single value representing a bucket.
     def bucket_value(index, type = nil)
       case type
-      when :begin, :start, :lower, :lower_bound; bucket_lower_bound(index)
-      when :end, :finish, :upper, :upper_bound;  bucket_upper_bound(index)
+      when :begin, :start, :lower, :lower_bound then bucket_lower_bound(index)
+      when :end, :finish, :upper, :upper_bound then  bucket_upper_bound(index)
       else bucket_average_value(index)
       end
     end
@@ -198,8 +195,7 @@ module RequestLogAnalyzer::Tracker
     def percentile(category, x, type = nil)
       bucket_value(percentile_index(category, x, type == :upper), type)
     end
-    
-    
+
     def median(category)
       percentile(category, 50, :average)
     end
@@ -217,8 +213,8 @@ module RequestLogAnalyzer::Tracker
         Range.new(bucket_lower_bound(lower), bucket_upper_bound(upper))
       when Numeric
         percentile_interval(category, Range.new((100 - x) / 2, (100 - (100 - x) / 2)))
-      else 
-        raise 'What does it mean?'
+      else
+        fail 'What does it mean?'
       end
     end
 
@@ -226,11 +222,11 @@ module RequestLogAnalyzer::Tracker
     # <tt>category</tt>:: The category for which to update the running statistics calculations
     # <tt>number</tt>:: The numeric value to update the calculations with.
     def update_statistics(category, number)
-      return number.map {|n| update_statistics(category, n)} if number.is_a?(Array)
+      return number.map { |n| update_statistics(category, n) } if number.is_a?(Array)
+
+      @categories[category] ||= { hits: 0, sum: 0, mean: 0.0, sum_of_squares: 0.0, min: number, max: number,
+                                  buckets: Array.new(@number_of_buckets, 0) }
 
-      @categories[category] ||= { :hits => 0, :sum => 0, :mean => 0.0, :sum_of_squares => 0.0, :min => number, :max => number, 
-                                  :buckets => Array.new(@number_of_buckets, 0) }
-      
       delta = number - @categories[category][:mean]
 
       @categories[category][:hits]           += 1
@@ -293,12 +289,12 @@ module RequestLogAnalyzer::Tracker
 
     # Get the cumlative duration of a all categories.
     def sum_overall
-      @categories.inject(0.0) { |sum, (_, cat)| sum + cat[:sum] }
+      @categories.reduce(0.0) { |sum, (_, cat)| sum + cat[:sum] }
     end
 
     # Get the total hits of a all categories.
     def hits_overall
-      @categories.inject(0) { |sum, (_, cat)| sum + cat[:hits] }
+      @categories.reduce(0) { |sum, (_, cat)| sum + cat[:hits] }
     end
 
     # Return categories sorted by a given key.
@@ -314,22 +310,22 @@ module RequestLogAnalyzer::Tracker
     # Returns the column header for a statistics table to report on the statistics result
     def statistics_header(options)
       [
-        {:title => options[:title], :width => :rest},
-        {:title => 'Hits',   :align => :right, :highlight => (options[:highlight] == :hits),   :min_width => 4},
-        {:title => 'Sum',    :align => :right, :highlight => (options[:highlight] == :sum),    :min_width => 6},
-        {:title => 'Mean',   :align => :right, :highlight => (options[:highlight] == :mean),   :min_width => 6},
-        {:title => 'StdDev', :align => :right, :highlight => (options[:highlight] == :stddev), :min_width => 6},
-        {:title => 'Min',    :align => :right, :highlight => (options[:highlight] == :min),    :min_width => 6},
-        {:title => 'Max',    :align => :right, :highlight => (options[:highlight] == :max),    :min_width => 6},
-        {:title => '95 %tile',    :align => :right, :highlight => (options[:highlight] == :percentile_interval),  :min_width => 11}
+        { title: options[:title], width: :rest },
+        { title: 'Hits',   align: :right, highlight: (options[:highlight] == :hits),   min_width: 4 },
+        { title: 'Sum',    align: :right, highlight: (options[:highlight] == :sum),    min_width: 6 },
+        { title: 'Mean',   align: :right, highlight: (options[:highlight] == :mean),   min_width: 6 },
+        { title: 'StdDev', align: :right, highlight: (options[:highlight] == :stddev), min_width: 6 },
+        { title: 'Min',    align: :right, highlight: (options[:highlight] == :min),    min_width: 6 },
+        { title: 'Max',    align: :right, highlight: (options[:highlight] == :max),    min_width: 6 },
+        { title: '95 %tile',    align: :right, highlight: (options[:highlight] == :percentile_interval),  min_width: 11 }
       ]
     end
 
     # Returns a row of statistics information for a report table, given a category
     def statistics_row(cat)
       [cat, hits(cat), display_value(sum(cat)), display_value(mean(cat)), display_value(stddev(cat)),
-                display_value(min(cat)), display_value(max(cat)), 
-                display_value(percentile_interval(cat, 95).begin) + '-' + display_value(percentile_interval(cat, 95).end) ]
+       display_value(min(cat)), display_value(max(cat)),
+       display_value(percentile_interval(cat, 95).begin) + '-' + display_value(percentile_interval(cat, 95).end)]
     end
   end
 end

data/lib/request_log_analyzer/tracker/timespan.rb

@@ -1,5 +1,4 @@
 module RequestLogAnalyzer::Tracker
-
   # Determines the datetime of the first request and the last request
   # Also determines the amount of days inbetween these.
   #
@@ -18,13 +17,12 @@ module RequestLogAnalyzer::Tracker
   #  Last request:         2008-07-20 06:18:06
   #  Total time analyzed:  7 days
   class Timespan < Base
-
     attr_reader :first, :last
 
     # Check if timestamp field is set in the options.
     def prepare
       options[:field] ||= :timestamp
-      @first, @last = 99999999999999, 0
+      @first, @last = 99_999_999_999_999, 0
     end
 
     # Check if the timestamp in the request and store it.
@@ -56,9 +54,9 @@ module RequestLogAnalyzer::Tracker
     def report(output)
       output.title(options[:title]) if options[:title]
 
-      if @last > 0 && @first < 99999999999999
-        output.with_style(:cell_separator => false) do
-          output.table({:width => 20}, {}) do |rows|
+      if @last > 0 && @first < 99_999_999_999_999
+        output.with_style(cell_separator: false) do
+          output.table({ width: 20 }, {}) do |rows|
             rows << ['First request:', first_timestamp.strftime('%Y-%m-%d %H:%M:%I')]
             rows << ['Last request:',  last_timestamp.strftime('%Y-%m-%d %H:%M:%I')]
             rows << ['Total time analyzed:', "#{timespan.ceil} days"]
@@ -74,8 +72,7 @@ module RequestLogAnalyzer::Tracker
 
     # A hash that can be exported to YAML with the first and last timestamp encountered.
     def to_yaml_object
-      { :first => first_timestamp, :last  =>last_timestamp }
+      { first: first_timestamp, last: last_timestamp }
     end
-
   end
 end