request-log-analyzer 1.13.1 → 1.13.3

data/lib/request_log_analyzer/file_format/haproxy.rb

@@ -1,7 +1,5 @@
 module RequestLogAnalyzer::FileFormat
-
   class Haproxy < RequestLogAnalyzer::FileFormat::Base
-
     extend CommonRegularExpressions
 
     # substitute version specific parts of the haproxy entry regexp.
@@ -46,13 +44,13 @@ module RequestLogAnalyzer::FileFormat
       line.capture(:frontend_name).as(:string)
       line.capture(:backend_name).as(:string)
       line.capture(:server_name).as(:string)
-      line.capture(:tq).as(:nillable_duration, :unit => :msec)
-      line.capture(:tw).as(:nillable_duration, :unit => :msec)
-      line.capture(:tc).as(:nillable_duration, :unit => :msec)
-      line.capture(:tr).as(:nillable_duration, :unit => :msec)
-      line.capture(:tt).as(:duration, :unit => :msec)
+      line.capture(:tq).as(:nillable_duration, unit: :msec)
+      line.capture(:tw).as(:nillable_duration, unit: :msec)
+      line.capture(:tc).as(:nillable_duration, unit: :msec)
+      line.capture(:tr).as(:nillable_duration, unit: :msec)
+      line.capture(:tt).as(:duration, unit: :msec)
       line.capture(:status_code).as(:integer)
-      line.capture(:bytes_read).as(:traffic, :unit => :byte)
+      line.capture(:bytes_read).as(:traffic, unit: :byte)
       line.capture(:captured_request_cookie).as(:nillable_string)
       line.capture(:captured_response_cookie).as(:nillable_string)
       line.capture(:termination_event_code).as(:nillable_string)
@@ -89,13 +87,13 @@ module RequestLogAnalyzer::FileFormat
       line.capture(:timestamp).as(:timestamp)
       line.capture(:frontend_name).as(:string)
       line.capture(:server_name).as(:string)
-      line.capture(:tq).as(:nillable_duration, :unit => :msec)
-      line.capture(:tw).as(:nillable_duration, :unit => :msec)
-      line.capture(:tc).as(:nillable_duration, :unit => :msec)
-      line.capture(:tr).as(:nillable_duration, :unit => :msec)
-      line.capture(:tt).as(:duration, :unit => :msec)
+      line.capture(:tq).as(:nillable_duration, unit: :msec)
+      line.capture(:tw).as(:nillable_duration, unit: :msec)
+      line.capture(:tc).as(:nillable_duration, unit: :msec)
+      line.capture(:tr).as(:nillable_duration, unit: :msec)
+      line.capture(:tt).as(:duration, unit: :msec)
       line.capture(:status_code).as(:integer)
-      line.capture(:bytes_read).as(:traffic, :unit => :byte)
+      line.capture(:bytes_read).as(:traffic, unit: :byte)
       line.capture(:captured_request_cookie).as(:nillable_string)
       line.capture(:captured_response_cookie).as(:nillable_string)
       line.capture(:termination_event_code).as(:nillable_string)
@@ -130,12 +128,12 @@ module RequestLogAnalyzer::FileFormat
       line.capture(:timestamp).as(:timestamp)
       line.capture(:frontend_name).as(:string)
       line.capture(:server_name).as(:string)
-      line.capture(:tq).as(:nillable_duration, :unit => :msec)
-      line.capture(:tc).as(:nillable_duration, :unit => :msec)
-      line.capture(:tr).as(:nillable_duration, :unit => :msec)
-      line.capture(:tt).as(:duration, :unit => :msec)
+      line.capture(:tq).as(:nillable_duration, unit: :msec)
+      line.capture(:tc).as(:nillable_duration, unit: :msec)
+      line.capture(:tr).as(:nillable_duration, unit: :msec)
+      line.capture(:tt).as(:duration, unit: :msec)
       line.capture(:status_code).as(:integer)
-      line.capture(:bytes_read).as(:traffic, :unit => :byte)
+      line.capture(:bytes_read).as(:traffic, unit: :byte)
       line.capture(:captured_request_cookie).as(:nillable_string)
       line.capture(:captured_response_cookie).as(:nillable_string)
       line.capture(:termination_event_code).as(:nillable_string)
@@ -153,72 +151,71 @@ module RequestLogAnalyzer::FileFormat
 
     # Define the summary report
     report do |analyze|
-      analyze.hourly_spread :field => :timestamp
+      analyze.hourly_spread field: :timestamp
 
       analyze.frequency :client_ip,
-        :title => "Hits per IP"
+                        title: 'Hits per IP'
 
       analyze.frequency :frontend_name,
-        :title => "Hits per frontend service"
+                        title: 'Hits per frontend service'
 
       analyze.frequency :backend_name,
-        :title => "Hits per backend service"
+                        title: 'Hits per backend service'
 
       analyze.frequency :server_name,
-        :title => "Hits per backend server"
+                        title: 'Hits per backend server'
 
       analyze.frequency :status_code,
-        :title => "HTTP response code frequency"
+                        title: 'HTTP response code frequency'
 
       analyze.frequency :http_request,
-        :title => "Most popular requests"
+                        title: 'Most popular requests'
 
       analyze.frequency :http_request,
-        :title => "Most frequent HTTP 40x errors",
-        :category => lambda { |r| "#{r[:http_request]}"},
-        :if => lambda { |r| r[:status_code] >= 400 and r[:status_code] <= 417 }
+                        title: 'Most frequent HTTP 40x errors',
+                        category: lambda { |r| "#{r[:http_request]}" },
+                        if: lambda { |r| r[:status_code] >= 400 && r[:status_code] <= 417 }
 
       analyze.frequency :http_request,
-        :title => "Most frequent HTTP 50x errors",
-        :category => lambda { |r| "#{r[:http_request]}"},
-        :if => lambda { |r| r[:status_code] >= 500 and r[:status_code] <= 505 }
+                        title: 'Most frequent HTTP 50x errors',
+                        category: lambda { |r| "#{r[:http_request]}" },
+                        if: lambda { |r| r[:status_code] >= 500 && r[:status_code] <= 505 }
 
       analyze.traffic :bytes_read,
-        :title => "Traffic per frontend service",
-        :category => lambda { |r| "#{r[:frontend_name]}"}
+                      title: 'Traffic per frontend service',
+                      category: lambda { |r| "#{r[:frontend_name]}" }
 
       analyze.traffic :bytes_read,
-        :title => "Traffic per backend service",
-        :category => lambda { |r| "#{r[:backend_name]}"}
+                      title: 'Traffic per backend service',
+                      category: lambda { |r| "#{r[:backend_name]}" }
 
       analyze.traffic :bytes_read,
-        :title => "Traffic per backend server",
-        :category => lambda { |r| "#{r[:server_name]}"}
+                      title: 'Traffic per backend server',
+                      category: lambda { |r| "#{r[:server_name]}" }
 
       analyze.duration :tr,
-        :title => "Time waiting for backend response",
-        :category => lambda { |r| "#{r[:http_request]}"}
+                       title: 'Time waiting for backend response',
+                       category: lambda { |r| "#{r[:http_request]}" }
 
       analyze.duration :tt,
-        :title => "Total time spent on request",
-        :category => lambda { |r| "#{r[:http_request]}"}
+                       title: 'Total time spent on request',
+                       category: lambda { |r| "#{r[:http_request]}" }
     end
 
     # Define a custom Request class for the HAProxy file format to speed up
     # timestamp handling. Shamelessly copied from apache.rb
     class Request < RequestLogAnalyzer::Request
-
-      MONTHS = {'Jan' => '01', 'Feb' => '02', 'Mar' => '03', 'Apr' => '04', 'May' => '05', 'Jun' => '06',
+      MONTHS = { 'Jan' => '01', 'Feb' => '02', 'Mar' => '03', 'Apr' => '04', 'May' => '05', 'Jun' => '06',
                 'Jul' => '07', 'Aug' => '08', 'Sep' => '09', 'Oct' => '10', 'Nov' => '11', 'Dec' => '12' }
 
       # Do not use DateTime.parse, but parse the timestamp ourselves to return
       # a integer to speed up parsing.
-      def convert_timestamp(value, definition)
-        "#{value[7,4]}#{MONTHS[value[3,3]]}#{value[0,2]}#{value[12,2]}#{value[15,2]}#{value[18,2]}".to_i
+      def convert_timestamp(value, _definition)
+        "#{value[7, 4]}#{MONTHS[value[3, 3]]}#{value[0, 2]}#{value[12, 2]}#{value[15, 2]}#{value[18, 2]}".to_i
       end
 
       # Make sure that the strings '-' or '{}' or '' are parsed as a nil value.
-      def convert_nillable_string(value, definition)
+      def convert_nillable_string(value, _definition)
         value =~ /-|\{\}|^$/ ? nil : value
       end
 
@@ -226,7 +223,6 @@ module RequestLogAnalyzer::FileFormat
       def convert_nillable_duration(value, definition)
         value == '-1' ? nil : convert_duration(value, definition)
       end
-
     end
   end
 end

data/lib/request_log_analyzer/file_format/merb.rb

@@ -1,10 +1,8 @@
 module RequestLogAnalyzer::FileFormat
-
   # The Merb file format parses the request header with the timestamp, the params line
   # with the most important request information and the durations line which contains
   # the different request durations that can be used for analysis.
   class Merb < Base
-
     extend CommonRegularExpressions
 
     # ~ Started request handling: Fri Aug 29 11:10:23 +0200 2008
@@ -12,7 +10,7 @@ module RequestLogAnalyzer::FileFormat
       line.header = true
       line.teaser = /Started request handling\:/
       line.regexp = /Started request handling\:\ (#{timestamp('%a %b %d %H:%M:%S %z %Y')})/
-      line.captures << { :name => :timestamp, :type => :timestamp }
+      line.captures << { name: :timestamp, type: :timestamp }
     end
 
     # ~ Params: {"action"=>"create", "controller"=>"session"}
@@ -20,8 +18,8 @@ module RequestLogAnalyzer::FileFormat
     line_definition :params do |line|
       line.teaser = /Params\:\ /
       line.regexp = /Params\:\ (\{.+\})/
-      line.captures << { :name => :params, :type => :eval, :provides => {
-            :namespace => :string, :controller => :string, :action => :string, :format => :string, :method => :string } }
+      line.captures << { name: :params, type: :eval, provides: {
+        namespace: :string, controller: :string, action: :string, format: :string, method: :string } }
     end
 
     # ~ {:dispatch_time=>0.006117, :after_filters_time=>6.1e-05, :before_filters_time=>0.000712, :action_time=>0.005833}
@@ -29,12 +27,12 @@ module RequestLogAnalyzer::FileFormat
       line.footer = true
       # line.teaser = Regexp.new(Regexp.quote('~ {:'))
       line.regexp = /(\{.*\:dispatch_time\s*=>\s*\d+\.\d+.*\})/
-      line.captures << { :name => :times_hash, :type => :eval, :provides => {
-            :dispatch_time => :duration, :after_filters_time => :duration,
-            :before_filters_time => :duration, :action_time => :duration } }
+      line.captures << { name: :times_hash, type: :eval, provides: {
+        dispatch_time: :duration, after_filters_time: :duration,
+            before_filters_time: :duration, action_time: :duration } }
     end
 
-    REQUEST_CATEGORIZER = Proc.new do |request|
+    REQUEST_CATEGORIZER = proc do |request|
       category = "#{request[:controller]}##{request[:action]}"
       category = "#{request[:namespace]}::#{category}" if request[:namespace]
       category = "#{category}.#{request[:format]}"     if request[:format]
@@ -46,8 +44,8 @@ module RequestLogAnalyzer::FileFormat
       analyze.timespan
       analyze.hourly_spread
 
-      analyze.frequency :category => REQUEST_CATEGORIZER, :title => "Top 20 by hits"
-      analyze.duration :dispatch_time, :category => REQUEST_CATEGORIZER, :title => 'Request dispatch duration'
+      analyze.frequency category: REQUEST_CATEGORIZER, title: 'Top 20 by hits'
+      analyze.duration :dispatch_time, category: REQUEST_CATEGORIZER, title: 'Request dispatch duration'
 
       # analyze.duration :action_time, :category => REQUEST_CATEGORIZER, :title => 'Request action duration'
       # analyze.duration :after_filters_time, :category => REQUEST_CATEGORIZER, :title => 'Request after_filter duration'
@@ -55,15 +53,13 @@ module RequestLogAnalyzer::FileFormat
     end
 
     class Request < RequestLogAnalyzer::Request
-
-      MONTHS = {'Jan' => '01', 'Feb' => '02', 'Mar' => '03', 'Apr' => '04', 'May' => '05', 'Jun' => '06',
+      MONTHS = { 'Jan' => '01', 'Feb' => '02', 'Mar' => '03', 'Apr' => '04', 'May' => '05', 'Jun' => '06',
                 'Jul' => '07', 'Aug' => '08', 'Sep' => '09', 'Oct' => '10', 'Nov' => '11', 'Dec' => '12' }
 
       # Speed up timestamp conversion
-      def convert_timestamp(value, definition)
-        "#{value[26,4]}#{MONTHS[value[4,3]]}#{value[8,2]}#{value[11,2]}#{value[14,2]}#{value[17,2]}".to_i
+      def convert_timestamp(value, _definition)
+        "#{value[26, 4]}#{MONTHS[value[4, 3]]}#{value[8, 2]}#{value[11, 2]}#{value[14, 2]}#{value[17, 2]}".to_i
       end
     end
   end
-
-end
+end

data/lib/request_log_analyzer/file_format/mysql.rb

@@ -1,14 +1,12 @@
 module RequestLogAnalyzer::FileFormat
-
   class Mysql < Base
-
     extend CommonRegularExpressions
 
     line_definition :time do |line|
       line.header = :alternative
       line.teaser = /\# Time: /
       line.regexp = /\# Time: (#{timestamp('%y%m%d %k:%M:%S')})/
-      
+
       line.capture(:timestamp).as(:timestamp)
     end
 
@@ -16,7 +14,7 @@ module RequestLogAnalyzer::FileFormat
       line.header = :alternative
       line.teaser = /\# User\@Host\: /
       line.regexp = /\# User\@Host\: ([\w-]+)\[[\w-]+\] \@ (#{hostname(true)}) \[(#{ip_address(true)})\]/
-      
+
       line.capture(:user)
       line.capture(:host)
       line.capture(:ip)
@@ -26,9 +24,9 @@ module RequestLogAnalyzer::FileFormat
       line.header = :alternative
       line.teaser = /\# Query_time: /
       line.regexp = /\# Query_time: (\d+(?:\.\d+)?)\s+Lock_time: (\d+(?:\.\d+)?)\s+Rows_sent: (\d+)\s+Rows_examined: (\d+)/
-      
-      line.capture(:query_time).as(:duration, :unit => :sec)
-      line.capture(:lock_time).as(:duration, :unit => :sec)
+
+      line.capture(:query_time).as(:duration, unit: :sec)
+      line.capture(:lock_time).as(:duration, unit: :sec)
       line.capture(:rows_sent).as(:integer)
       line.capture(:rows_examined).as(:integer)
     end
@@ -51,25 +49,23 @@ module RequestLogAnalyzer::FileFormat
 
     PER_USER       = :user
     PER_QUERY      = :query
-    PER_USER_QUERY = Proc.new { |request| "#{request[:user]}@#{request.host}: #{request[:query]}" }
+    PER_USER_QUERY = proc { |request| "#{request[:user]}@#{request.host}: #{request[:query]}" }
 
     report do |analyze|
-      analyze.timespan :line_type => :time
-      analyze.frequency :user, :title => "Users with most queries"
-      analyze.duration :query_time, :category => PER_USER, :title => 'Query time per user'
-      analyze.duration :query_time, :category => PER_USER_QUERY, :title => 'Query time'
-      
-      analyze.duration :lock_time,  :category => PER_USER_QUERY, :title => 'Lock time',
-                       :if => lambda { |request| request[:lock_time] > 0.0 }
-      
-      analyze.numeric_value :rows_examined, :category => PER_USER_QUERY, :title => "Rows examined"
-      analyze.numeric_value :rows_sent,     :category => PER_USER_QUERY, :title => "Rows sent"
-    end
-  
-    class Request < RequestLogAnalyzer::Request
+      analyze.timespan line_type: :time
+      analyze.frequency :user, title: 'Users with most queries'
+      analyze.duration :query_time, category: PER_USER, title: 'Query time per user'
+      analyze.duration :query_time, category: PER_USER_QUERY, title: 'Query time'
 
-      def convert_sql(value, definition)
+      analyze.duration :lock_time,  category: PER_USER_QUERY, title: 'Lock time',
+                       if: lambda { |request| request[:lock_time] > 0.0 }
 
+      analyze.numeric_value :rows_examined, category: PER_USER_QUERY, title: 'Rows examined'
+      analyze.numeric_value :rows_sent,     category: PER_USER_QUERY, title: 'Rows sent'
+    end
+
+    class Request < RequestLogAnalyzer::Request
+      def convert_sql(value, _definition)
         # Recreate the full SQL query by joining all the previous parts and this last line
         sql = every(:query_fragment).join("\n") + value
 
@@ -84,7 +80,7 @@ module RequestLogAnalyzer::FileFormat
         sql.gsub!(/(:int,)+:int/, ':ints')                                # replace multiple ints by a list
         sql.gsub!(/(:string,)+:string/, ':strings')                       # replace multiple strings by a list
 
-        return sql.strip
+        sql.strip
       end
 
       def host
@@ -92,9 +88,9 @@ module RequestLogAnalyzer::FileFormat
       end
 
       # Convert the timestamp to an integer
-      def convert_timestamp(value, definition)
+      def convert_timestamp(value, _definition)
         _, y, m, d, h, i, s = value.split(/(\d\d)(\d\d)(\d\d)\s+(\d?\d):(\d\d):(\d\d)/)
-        ('20%s%s%s%s%s%s' % [y,m,d,h.rjust(2, '0'),i,s]).to_i
+        ('20%s%s%s%s%s%s' % [y, m, d, h.rjust(2, '0'), i, s]).to_i
       end
     end
   end

data/lib/request_log_analyzer/file_format/nginx.rb

@@ -1,7 +1,5 @@
 module RequestLogAnalyzer::FileFormat
-
   class Nginx < Apache
-
     def self.create(*args)
       super(:combined, *args)
     end

data/lib/request_log_analyzer/file_format/oink.rb

@@ -1,26 +1,26 @@
 class RequestLogAnalyzer::FileFormat::Oink < RequestLogAnalyzer::FileFormat::Rails
   # capture the PID
   HODEL3000_PROCESSING = /\[(\d+)\]: Processing ((?:\w+::)*\w+)#(\w+)(?: to (\w+))? \(for (#{ip_address}) at (#{timestamp('%Y-%m-%d %H:%M:%S')})\) \[([A-Z]+)\]/
-  
+
   # TODO: fix me!
   line_definition :processing do |line|
     line.header = true
-    line.regexp = Regexp.union(LINE_DEFINITIONS[:processing].regexp,HODEL3000_PROCESSING)
-    line.captures = [   { :name => :controller, :type  => :string }, # Default Rails Processing
-                        { :name => :action,     :type  => :string },
-                        { :name => :format,     :type  => :string, :default => 'html' },
-                        { :name => :ip,         :type  => :string },
-                        { :name => :timestamp,  :type  => :timestamp },
-                        { :name => :method,     :type  => :string },
-                        { :name => :pid,        :type  => :integer }, # Hodel 3000 Processing w/PID
-                        { :name => :controller, :type  => :string },
-                        { :name => :action,     :type  => :string },
-                        { :name => :format,     :type  => :string, :default => 'html' },
-                        { :name => :ip,         :type  => :string },
-                        { :name => :timestamp,  :type  => :timestamp },
-                        { :name => :method,     :type  => :string }]
+    line.regexp = Regexp.union(LINE_DEFINITIONS[:processing].regexp, HODEL3000_PROCESSING)
+    line.captures = [{ name: :controller, type: :string }, # Default Rails Processing
+                     { name: :action,     type: :string },
+                     { name: :format,     type: :string, default: 'html' },
+                     { name: :ip,         type: :string },
+                     { name: :timestamp,  type: :timestamp },
+                     { name: :method,     type: :string },
+                     { name: :pid,        type: :integer }, # Hodel 3000 Processing w/PID
+                     { name: :controller, type: :string },
+                     { name: :action,     type: :string },
+                     { name: :format,     type: :string, default: 'html' },
+                     { name: :ip,         type: :string },
+                     { name: :timestamp,  type: :timestamp },
+                     { name: :method,     type: :string }]
   end
-  
+
   line_definition :memory_usage do |line|
     line.regexp   = /\[(\d+)\]: Memory usage: (\d+)/
     line.capture(:pid).as(:integer)
@@ -29,14 +29,14 @@ class RequestLogAnalyzer::FileFormat::Oink < RequestLogAnalyzer::FileFormat::Rai
 
   line_definition :instance_type_counter do |line|
     line.regexp = /\[(\d+)\]: Instantiation Breakdown: (.*)$/
-    line.capture(:pid).as(:integer) 
+    line.capture(:pid).as(:integer)
     line.capture(:instance_counts).as(:pipe_separated_counts)
   end
-  
+
   report(:append) do |analyze|
-    analyze.traffic :memory_diff, :category => REQUEST_CATEGORIZER, :title => "Largest Memory Increases", :line_type => :memory_usage
+    analyze.traffic :memory_diff, category: REQUEST_CATEGORIZER, title: 'Largest Memory Increases', line_type: :memory_usage
   end
-  
+
   # Keep a record of PIDs and their memory usage when validating requests.
   def pids
     @pids ||= {}
@@ -48,20 +48,20 @@ class RequestLogAnalyzer::FileFormat::Oink < RequestLogAnalyzer::FileFormat::Rai
       update_pids
       super
     end
-   
+
     # Accessor for memory information associated with the specified request PID. If no memory exists
     # for this request's :pid, the memory tracking is initialized.
     def pid_memory
-      file_format.pids[self[:pid]] ||= { :last_memory_reading => -1, :current_memory_reading => -1 }
+      file_format.pids[self[:pid]] ||= { last_memory_reading: -1, current_memory_reading: -1 }
     end
-    
+
     # Calculates :memory_diff for each request based on the last completed request that was not a failure.
     def update_pids
       # memory isn't recorded with exceptions. need to set #last_memory_reading+ to -1 as
       # the memory used could have changed. for the next request the memory change will not be recorded.
       #
       # NOTE - the failure regex was not matching with a Rails Development log file.
-      if has_line_type?(:failure) and processing = has_line_type?(:processing)
+      if has_line_type?(:failure) && processing = has_line_type?(:processing)
         pid_memory[:last_memory_reading] = -1
       elsif mem_line = has_line_type?(:memory_usage)
         memory_reading = mem_line[:memory]
@@ -69,28 +69,27 @@ class RequestLogAnalyzer::FileFormat::Oink < RequestLogAnalyzer::FileFormat::Rai
         # calcuate the change in memory
         unless pid_memory[:current_memory_reading] == -1 || pid_memory[:last_memory_reading] == -1
           # logged as kB, need to convert to bytes for the :traffic Tracker
-          memory_diff = (pid_memory[:current_memory_reading] - pid_memory[:last_memory_reading])*1024
+          memory_diff = (pid_memory[:current_memory_reading] - pid_memory[:last_memory_reading]) * 1024
           if memory_diff > 0
-            self.attributes[:memory_diff] = memory_diff
+            attributes[:memory_diff] = memory_diff
           end # if memory_diff > 0
         end # unless
-        
+
         pid_memory[:last_memory_reading] = pid_memory[:current_memory_reading]
         pid_memory[:current_memory_reading] = -1
       end # if mem_line
-      return true
+      true
     end
 
-    def convert_pipe_separated_counts(value, capture_definition)
+    def convert_pipe_separated_counts(value, _capture_definition)
       count_strings = value.split(' | ')
       count_arrays = count_strings.map do |count_string|
         if count_string =~ /^(\w+): (\d+)/
-          [$1, $2.to_i]
+          [Regexp.last_match[1], Regexp.last_match[2].to_i]
         end
       end
 
       Hash[count_arrays]
     end
-  
   end # class Request
 end