server_metrics 0.0.6 → 0.0.8

data/example_processes.rb

@@ -1,9 +1,11 @@
 require "rubygems"
-require File.dirname(__FILE__)+ "/lib/server_metrics"
+
+$LOAD_PATH.unshift(File.expand_path(__FILE__), "lib") # set the loadpath for convenience during development
+require "server_metrics"
+
 require "pry"
 require "awesome_print"
 
-
 p = ServerMetrics::Processes.new(1)
 puts "stating ..."
 p.run

data/lib/server_metrics.rb

@@ -1,5 +1,3 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__))
-
 require 'server_metrics/version'
 require 'server_metrics/collector'
 require 'server_metrics/multi_collector'

data/lib/server_metrics/collectors/processes.rb

@@ -1,13 +1,14 @@
 require 'sys/proctable'
+require 'server_metrics/system_info'
 
 # Collects information on processes. Groups processes running under the same command, and sums up their CPU & memory usage.
-# CPU is calculated **since the last run**
-#
-
+# CPU is calculated **since the last run**, and is a pecentage of overall CPU usage during the timeframe
+# http://www.linuxquestions.org/questions/linux-general-1/per-process-cpu-utilization-557577/
 class ServerMetrics::Processes
 
   def initialize(options={})
     @last_run
+    @last_jiffies
     @last_process_list
   end
 
@@ -51,42 +52,58 @@ class ServerMetrics::Processes
   # and calculates CPU time for each process. Since CPU time has to be calculated relative to the last sample,
   # the collector has to be run twice to get CPU data.
   def calculate_processes
-    ## 1. get a list of all processes grouped by command
-    processes = Sys::ProcTable.ps
-    grouped = Hash.new
+
+    ## 1. get a list of all processes
+    processes = Sys::ProcTable.ps.map{|p| ServerMetrics::Processes::Process.new(p) } # our Process object adds a method and adds some behavior
+
+    ## 2. loop through each process and calculate the CPU time.
+    # The CPU values returned by ProcTable are cumulative for the life of the process, which is not what we want.
+    # So, we rely on @last_process_list to make this calculation. If a process wasn't around last time, we use it's cumulative CPU time so far, which will be accurate enough.
+    now = Time.now
+    current_jiffies = get_jiffies
+    if @last_run && @last_jiffies && @last_process_list
+      elapsed_time = now - @last_run # in seconds
+      elapsed_jiffies = current_jiffies - @last_jiffies
+      if elapsed_time >= 1
+        processes.each do |p|
+          if last_cpu = @last_process_list[p.pid]
+            p.recent_cpu = p.combined_cpu - last_cpu
+          else
+            p.recent_cpu = p.combined_cpu # this process wasn't around last time, so just use the cumulative CPU time for its existence so far
+          end
+          # a) p.recent_cpu / elapsed_jiffies = the amount of CPU time this process has taken divided by the total "time slots" the CPU has available
+          # b) * 100 ... this turns it into a percentage
+          # b) / num_processors ... this normalizes for the the number of processors in the system, so it reflects the amount of CPU power avaiable as a whole
+          p.recent_cpu_percentage = ((p.recent_cpu.to_f / elapsed_jiffies.to_f ) * 100.0) / ServerMetrics::SystemInfo.num_processors.to_f
+        end
+      end
+    end
+
+    ## 3. group by command and aggregate the CPU
+    grouped = {}
     processes.each do |proc|
       grouped[proc.comm] ||= {
-          :count => 0,
-          :raw_cpu => 0,
           :cpu => 0,
           :memory => 0,
-          :uid => 0,
+          :count => 0,
           :cmdlines => []
       }
-      grouped[proc.comm][:count] += 1
-      grouped[proc.comm][:raw_cpu] += proc.cutime + proc.cstime
-      grouped[proc.comm][:memory] += proc.rss.to_f / 1024.0
-      grouped[proc.comm][:uid] = proc.uid
+      grouped[proc.comm][:count]    += 1
+      grouped[proc.comm][:cpu]      += proc.recent_cpu_percentage || 0
+      grouped[proc.comm][:memory]   += proc.rss.to_f / 1024.0
       grouped[proc.comm][:cmdlines] << proc.cmdline if !grouped[proc.comm][:cmdlines].include?(proc.cmdline)
     end # processes.each
 
-    ## 2. loop through each and calculate the CPU time. To do this, you need to compare the current values against the last run
-    now = Time.now
-    if @last_run and @last_process_list
-      elapsed_time = now - @last_run # in seconds
-      if elapsed_time >= 1
-        grouped.each do |name, values|
-          if last_values = @last_process_list[name]
-            cpu_since_last_sample = values[:raw_cpu] - last_values[:raw_cpu]
-            grouped[name][:cpu] = (cpu_since_last_sample/(elapsed_time * ServerMetrics::SystemInfo.num_processors))*100
-          else
-            grouped.reject!(name) # no data from last run. don't report anything.
-          end
-        end
-      end
+    # {pid => cpu_snapshot, pid2 => cpu_snapshot ...}
+    processes_to_store = processes.inject(Hash.new) do |hash, proc|
+      hash[proc.pid] = proc.combined_cpu
+      hash
     end
-    @last_process_list = grouped
+
+    @last_process_list = processes_to_store
+    @last_jiffies = current_jiffies
     @last_run = now
+
     grouped
   end
 
@@ -97,10 +114,17 @@ class ServerMetrics::Processes
     @processes.map { |key, hash| {:cmd => key}.merge(hash) }.sort { |a, b| a[order_by] <=> b[order_by] }.reverse[0...num]
   end
 
+  # Relies on the /proc directory (/proc/timer_list). We need this because the process CPU utilization is measured in jiffies.
+  # In order to calculate the process' % usage of total CPU resources, we need to know how many jiffies have passed.
+  # Unfortunately, jiffies isn't a fixed value (it can vary between 100 and 250 per second), so we need to calculate it ourselves.
+  def get_jiffies
+    `cat /proc/timer_list`.match(/^jiffies: (\d+)$/)[1].to_i
+  end
+
   # for persisting to a file -- conforms to same basic API as the Collectors do.
   # why not just use marshall? This is a lot more manageable written to the Scout agent's history file.
   def to_hash
-    {:last_run=>@last_run, :last_process_list=>@last_process_list}
+    {:last_run=>@last_run, :last_jiffies=>@last_jiffies, :last_process_list=>@last_process_list}
   end
 
   # for reinstantiating from a hash
@@ -108,8 +132,27 @@ class ServerMetrics::Processes
   def self.from_hash(hash)
     p=new(hash[:options])
     p.instance_variable_set('@last_run', hash[:last_run])
+    p.instance_variable_set('@last_jiffies', hash[:last_jiffies])
     p.instance_variable_set('@last_process_list', hash[:last_process_list])
     p
   end
 
+  # a thin wrapper around Sys:ProcTable's ProcTableStruct. We're using it to add some fields and behavior.
+  # Beyond what we're adding, it just passes through to its instance of ProcTableStruct
+  class Process
+    attr_accessor :recent_cpu, :recent_cpu_percentage # used to store the calculation of CPU since last sample
+    def initialize(proctable_struct)
+      @pts=proctable_struct
+      @recent_cpu = 0
+    end
+    def combined_cpu
+      # best thread I've seen on cutime vs utime & cstime vs stime: https://www.ruby-forum.com/topic/93176
+      # trying the metric that doesn't include the consumption of child processes
+      utime + stime
+    end
+    # delegate everything else to ProcTable::Struct
+    def method_missing(sym, *args, &block)
+      @pts.send sym, *args, &block
+    end
+  end
 end

data/lib/server_metrics/version.rb

@@ -1,3 +1,3 @@
 module ServerMetrics
-  VERSION = "0.0.6"
+  VERSION = "0.0.8"
 end

data/test/test_helper.rb

@@ -1,12 +1,12 @@
-$LOAD_PATH << File.expand_path( File.dirname(__FILE__) + '/..' )
-require 'test/unit'
-require 'rubygems'
+$LOAD_PATH << File.expand_path( File.dirname(__FILE__) + '/../lib' ) # needed because when running tests, Rubygems manage $LOAD_PATH like it does in runtime
+require 'rubygems' # so the development-only dependencies below can be loaded
 require 'pry'
 require 'awesome_print'
 require 'timecop'
+require 'test/unit'
 require 'mocha/setup'
+require 'server_metrics'
 
-require 'lib/server_metrics'
 AwesomePrint.defaults = {
     :indent => -2,
     :sort_keys =>true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: server_metrics
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-30 00:00:00.000000000 Z
+date: 2013-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sys-proctable
@@ -171,7 +171,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2520847385531363153
+      hash: -865855317494333286
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -180,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2520847385531363153
+      hash: -865855317494333286
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25