server_metrics 0.0.3 → 0.0.5

data/lib/server_metrics/collectors/cpu.rb

@@ -25,9 +25,9 @@ class ServerMetrics::Cpu < ServerMetrics::Collector
     uptime_output = `uptime`
     matches = uptime_output.match(/load averages?: ([\d.]+),? ([\d.]+),? ([\d.]+)\Z/)
 
-    report("Last minute" => matches[1].to_f,
-           "Last five minutes" => matches[2].to_f,
-           "Last fifteen minutes" => matches[3].to_f)
+    report(:last_minute => matches[1].to_f,
+           :last_five_minutes => matches[2].to_f,
+           :last_fifteen_minutes => matches[3].to_f)
   end
 
   # Helper class
@@ -102,22 +102,22 @@ class ServerMetrics::Cpu < ServerMetrics::Collector
       divo2 = div / 2
 
       results = {
-          "User" => (100.0 * diff_user + divo2) / div,
-          "System" => (100.0 * diff_system + divo2) / div,
-          "Idle" => (100.0 * diff_idle + divo2) / div,
-          "IO wait" => (100.0 * diff_iowait + divo2) / div,
-          "Procs running" => self.procs_running,
-          "Procs blocked" => self.procs_blocked
+          :user => (100.0 * diff_user + divo2) / div,
+          :system => (100.0 * diff_system + divo2) / div,
+          :idle => (100.0 * diff_idle + divo2) / div,
+          :io_wait => (100.0 * diff_iowait + divo2) / div,
+          :procs_running => self.procs_running,
+          :procs_blocked => self.procs_blocked
       }
 
       if diff_steal && steal > 0
-        results["Steal"] = (100.0 * diff_steal + divo2) / div
+        results[:steal] = (100.0 * diff_steal + divo2) / div
       end
 
       if self.time && other.time
         diff_in_seconds = self.time.to_f - other.time.to_f
 
-        results["Interrupts"] = (self.interrupts.to_f - other.interrupts.to_f) / diff_in_seconds
+        results[:interrupts] = (self.interrupts.to_f - other.interrupts.to_f) / diff_in_seconds
       end
 
       results

data/lib/server_metrics/collectors/disk.rb

@@ -33,8 +33,8 @@ class ServerMetrics::Disk < ServerMetrics::MultiCollector
     hash = parsed_lines.select{|l| l["Filesystem"] == device}.first
     result = {}
     hash.each_pair do |key,value|
-      #key=normalize_key(key) # downcase, make a symbol, etc
-      value = convert_to_mb(value) if [:avail,:capacity,:size,:used, :usepercent].include?(key)
+      key=normalize_key(key) # downcase, make a symbol, etc
+      value = convert_to_mb(value) if [:avail, :capacity, :size, :used].include?(key)
       result[key]=value
     end
 
@@ -46,14 +46,14 @@ class ServerMetrics::Disk < ServerMetrics::MultiCollector
     stats = iostat(device)
 
     if stats
-      counter(device, "RPS",   stats['rio'],        :per => :second)
-      counter(device, "WPS",   stats['wio'],        :per => :second)
-      counter(device, "Kb RPS", stats['rsect'] / 2,  :per => :second)
-      counter(device, "Kb WPS", stats['wsect'] / 2,  :per => :second)
-      counter(device, "Utilization",  stats['use'] / 10.0, :per => :second)
+      counter(device, :rps,   stats['rio'],        :per => :second)
+      counter(device, :wps,   stats['wio'],        :per => :second)
+      counter(device, :rps_kb, stats['rsect'] / 2,  :per => :second)
+      counter(device, :wps_kb, stats['wsect'] / 2,  :per => :second)
+      counter(device, :utilization,  stats['use'] / 10.0, :per => :second)
       # Not 100% sure that average queue length is present on all distros.
       if stats['aveq']
-        counter(device, "Average queue length",  stats['aveq'], :per => :second)
+        counter(device, :average_queue_length,  stats['aveq'], :per => :second)
       end
 
       if old = memory(device, "stats")
@@ -62,7 +62,7 @@ class ServerMetrics::Disk < ServerMetrics::MultiCollector
         if ios > 0
           await = ((stats['ruse'] - old['ruse']) + (stats['wuse'] - old['wuse'])) / ios.to_f
 
-          report(device, "Await" => await)
+          report(device, :await => await)
         end
       end
 
@@ -103,4 +103,8 @@ class ServerMetrics::Disk < ServerMetrics::MultiCollector
     return found_device || lvm
   end
 
+  def normalize_key(key)
+    key = "Used Percent" if /capacity|use.*%|%.*use/i === key
+    key.downcase.gsub(" ", "_").to_sym
+  end
 end

data/lib/server_metrics/collectors/memory.rb

@@ -49,15 +49,15 @@ class ServerMetrics::Memory < ServerMetrics::Collector
     # will be passed at the end to report to Scout
     report_data = Hash.new
 
-    report_data['Memory total'] = mem_total
-    report_data['Memory used'] = mem_used
-    report_data['Memory available'] = mem_total - mem_used
-    report_data['% Memory used'] = mem_percent_used
+    report_data[:size] = mem_total
+    report_data[:used] = mem_used
+    report_data[:avail] = mem_total - mem_used
+    report_data[:used_percent] = mem_percent_used
 
-    report_data['Swap total'] = swap_total
-    report_data['Swap used'] = swap_used
+    report_data[:swap_size] = swap_total
+    report_data[:swap_used] = swap_used
     unless  swap_total == 0
-      report_data['% Swap used'] = swap_percent_used
+      report_data[:swap_used_percent] = swap_percent_used
     end
     @data = report_data
 
@@ -80,15 +80,15 @@ class ServerMetrics::Memory < ServerMetrics::Collector
     mem.scan(/(\d+|\d+\.\d+)([bkmg])\s+(\w+)/i) do |amount, unit, label|
       case label
         when 'used'
-          report_data["Memory used"] =
+          report_data[:used] =
               (amount.to_f * DARWIN_UNITS[unit.downcase]).round
         when 'free'
-          report_data["Memory available"] =
+          report_data[:avail] =
               (amount.to_f * DARWIN_UNITS[unit.downcase]).round
       end
     end
-    report_data["Memory total"] = report_data["Memory used"]+report_data["Memory available"]
-    report_data['% Memory used'] = ((report_data["Memory used"].to_f/report_data["Memory total"])*100).to_i
+    report_data[:size] = report_data[:used]+report_data[:avail]
+    report_data[:used_percent] = ((report_data[:used].to_f/report_data[:size])*100).to_i
     @data = report_data
   end
 
@@ -102,23 +102,23 @@ class ServerMetrics::Memory < ServerMetrics::Collector
     prstat =~ /(ZONEID[^\n]*)\n(.*)/
     values = $2.split(' ')
 
-    report_data['Memory used'] = convert_to_mb(values[3])
-    report_data['Swap used']   = convert_to_mb(values[2])
+    report_data[:used] = convert_to_mb(values[3])
+    report_data[:swap_used]   = convert_to_mb(values[2])
 
     prtconf = `/usr/sbin/prtconf | grep Memory`
 
     prtconf =~ /\d+/
-    report_data['Memory total'] = $&.to_i
-    report_data['% Memory used'] = (report_data['Memory used'] / report_data['Memory total'].to_f * 100).to_i
+    report_data[:size] = $&.to_i
+    report_data[:used_percent] = (report_data[:used] / report_data[:size].to_f * 100).to_i
 
     swap = `swap -s`
     swap =~ /\d+[a-zA-Z]\sused/
     swap_used = convert_to_mb($&)
     swap =~ /\d+[a-zA-Z]\savailable/
     swap_available = convert_to_mb($&)
-    report_data['Swap total'] = swap_used+swap_available
-    unless report_data['Swap total'] == 0
-      report_data['% Swap used'] = (report_data['Swap used'] / report_data['Swap total'].to_f * 100).to_i
+    report_data[:swap_size] = swap_used+swap_available
+    unless report_data[:swap_size] == 0
+      report_data[:swap_used_percent] = (report_data[:swap_used] / report_data[:swap_size].to_f * 100).to_i
     end
 
     @data = report_data

data/lib/server_metrics/collectors/network.rb

@@ -16,10 +16,10 @@ class ServerMetrics::Network < ServerMetrics::MultiCollector
 
         bytes_in, packets_in, bytes_out, packets_out = cols.values_at(0, 1, 8, 9).collect { |i| i.to_i }
 
-        counter(iface, "Bytes in", bytes_in.to_f / 1024.0, :per => :second, :round => 2)
-        counter(iface, "Packets in", packets_in.to_f, :per => :second, :round => 2)
-        counter(iface, "Bytes out", bytes_out.to_f / 1024.0, :per => :second, :round => 2)
-        counter(iface, "Packets out", packets_out.to_f, :per => :second, :round => 2)
+        counter(iface, :bytes_in, bytes_in.to_f / 1024.0, :per => :second, :round => 2)
+        counter(iface, :packets_in, packets_in.to_f, :per => :second, :round => 2)
+        counter(iface, :bytes_out, bytes_out.to_f / 1024.0, :per => :second, :round => 2)
+        counter(iface, :packets_out, packets_out.to_f, :per => :second, :round => 2)
       end
     end
   end

data/lib/server_metrics/collectors/processes.rb

@@ -11,36 +11,40 @@ class ServerMetrics::Processes
     @last_process_list
   end
 
-  # This is the main method to call. It returns a hash of two arrays.
-  # The arrays have the top 10 memory using processes, and the top 10 CPU using processes, respectively.
-  # The array elements are hashes that look like this:
+
+  # This is the main method to call. It returns a hash of processes, keyed by the executable name.
+  # Processes are returned either because they are a top 10 CPU consumer, or a top 10 memory consumer.
   #
-  # {:top_memory=>
-  #    [
+  # The exact number or processes returned depends on the overlap between the two lists (cpu and memory consumers).
+  # The list will always be between 10 and 20 items long.
+
+  # {'mysqld' =>
   #     {
   #      :cmd => "mysqld",    # the command (without the path of arguments being run)
   #      :count    => 1,      # the number of these processes (grouped by the above command)
-  #      :cpu      => 34,     # the total CPU usag of the processes
-  #      :memory   => 2       # the total memory usage of the processes
-  #     }, ...
-  #   ],
-  # :top_cpu=>
-  #   [
+  #      :cpu      => 34,     # the total CPU usage of the processes
+  #      :memory   => 2,      # the total memory usage of the processes
+  #      :cmd_lines => ["cmd args1", "cmd args2"]
+  #     },
+  #  'apache' =>
   #     {
-  #      :cmd => "mysqld",
-  #      :count    => 1,
-  #      :cpu      => 34,
-  #      :memory   => 2
-  #     }, ...
-  #   ]
-  #  }
+  #      ....
+  #     }
+  # }
+
   def run
     @processes = calculate_processes # returns a hash
+    top_memory = get_top_processes(:memory, 10) # returns an array
+    top_cpu = get_top_processes(:memory, 10) # returns an array
+
+    # combine the two and index by cmd. The indexing process will remove duplicates
+    result = (top_cpu + top_memory).inject(Hash.new) {|temp_hash,process_hash| temp_hash[process_hash[:cmd]] = process_hash; temp_hash }
 
-    {
-        :top_memory => get_top_processes(:memory, 10),
-        :top_cpu => get_top_processes(:cpu, 10)
-    }
+    # An alternate approach is to return an array with two separate arrays. More explicit, but more verbose.
+    #{
+    #    :top_memory => get_top_processes(:memory, 10),
+    #    :top_cpu => get_top_processes(:cpu, 10)
+    #}
   end
 
   # called from run(). This method lists all the processes running on the server, groups them by command,
@@ -90,7 +94,7 @@ class ServerMetrics::Processes
   # Returns an array of hashes:
   # [{:cmd=>"ruby", :cpu=>30.0, :memory=>100, :uid=>1,:cmdlines=>[]}, {:cmd => ...} ]
   def get_top_processes(order_by, num)
-    @processes.map { |key, hash| {:cmd => key}.merge(hash) }.sort { |a, b| a[order_by] <=> b[order_by] }.reverse[0...num-1]
+    @processes.map { |key, hash| {:cmd => key}.merge(hash) }.sort { |a, b| a[order_by] <=> b[order_by] }.reverse[0...num]
   end
 
   # for persisting to a file -- conforms to same basic API as the Collectors do.

data/lib/server_metrics/version.rb

@@ -1,3 +1,3 @@
 module ServerMetrics
-  VERSION = "0.0.3"
+  VERSION = "0.0.5"
 end

data/test/test_helper.rb

@@ -1,10 +1,12 @@
 $LOAD_PATH << File.expand_path( File.dirname(__FILE__) + '/..' )
 require 'test/unit'
-require 'lib/server_metrics'
+require 'rubygems'
 require 'pry'
 require 'awesome_print'
 require 'timecop'
-require 'mocha'
+require 'mocha/setup'
+
+require 'lib/server_metrics'
 AwesomePrint.defaults = {
     :indent => -2,
     :sort_keys =>true
@@ -46,4 +48,4 @@ class FixtureFile
       @sections[key]
     end
   end
-end
+end

data/test/test_with_fixtures.rb

@@ -10,9 +10,9 @@ class TestWithFixtures < Test::Unit::TestCase
     c.expects(:`).with("uptime").returns(fixture.command("uptime")).once
 
     c.run
-    assert c.data["Last minute"]
-    assert c.data["Last five minutes"]
-    assert c.data["Last fifteen minutes"]
+    assert c.data[:last_minute]
+    assert c.data[:last_five_minutes]
+    assert c.data[:last_fifteen_minutes]
     assert_equal 3, c.data.keys.size
     c
   end
@@ -28,8 +28,8 @@ class TestWithFixtures < Test::Unit::TestCase
       c.run
     end
 
-    assert c.data["IO wait"]
-    assert c.data["Idle"]
+    assert c.data[:io_wait]
+    assert c.data[:idle]
   end
 
 
@@ -43,18 +43,54 @@ class TestWithFixtures < Test::Unit::TestCase
     c.run
 
     assert_equal ["/dev/xvda1"], c.data.keys
+    
     res = c.data["/dev/xvda1"]
 
-    assert res["Avail"]
-    assert res["Filesystem"]
-    assert res["Mounted on"]
-    assert res["Size"]
-    assert res["Use%"]
-    assert res["Used"]
+    assert res[:avail]
+    assert res[:filesystem]
+    assert res[:mounted_on]
+    assert res[:size]
+    assert res[:used_percent]
+    assert res[:used]
     assert_equal 6, res.keys.size
     c
   end
 
+  def test_disk_converts_use_percent_and_capacity_to_used_percent
+    response_varieties = []
+    response_varieties << <<-eos
+Filesystem  Capacity
+/dev/xvda1  70%
+none        0%
+none        0%
+eos
+    
+    response_varieties << <<-eos
+Filesystem  Use%
+/dev/xvda1  70%
+none        0%
+none        0%
+eos
+    
+    response_varieties<< <<-eos
+Filesystem  %Use
+/dev/xvda1  70%
+none        0%
+none        0%
+eos
+    
+    fixture = fixtures(:disk)
+    response_varieties.each do |response|
+      c = ServerMetrics::Disk.new()
+      c.expects(:`).with("mount").returns(fixture.command("mount")).once
+      c.expects(:`).with("cat /proc/diskstats").returns(fixture.command("cat /proc/diskstats")).once
+      c.expects(:`).with("df -h").returns(response)
+      c.run
+
+      assert c.data['/dev/xvda1'][:used_percent]
+    end
+  end
+
   # Second run we also get counter data
   def test_disk_second_run
     c=test_disk
@@ -69,8 +105,10 @@ class TestWithFixtures < Test::Unit::TestCase
 
     assert_equal ["/dev/xvda1"], c.data.keys
     res = c.data["/dev/xvda1"]
-    assert res["WPS"]
-    assert res["RPS"]
+    assert res[:wps]
+    assert res[:rps]
+    assert res[:rps_kb]
+    assert res[:wps_kb]
   end
 
   def test_memory
@@ -80,7 +118,14 @@ class TestWithFixtures < Test::Unit::TestCase
     c.expects(:`).with("cat /proc/meminfo").returns(fixture.command("cat /proc/meminfo")).once
     c.run
     assert_equal 7, c.data.keys.size
-    assert c.data['Swap total']
+    # the field names should align with the disk field names
+    assert c.data[:swap_size]
+    assert c.data[:swap_used]
+    assert c.data[:swap_used_percent]
+    assert c.data[:used]
+    assert c.data[:avail]
+    assert c.data[:used_percent]
+    assert c.data[:size]
   end
 
   def test_network
@@ -98,8 +143,8 @@ class TestWithFixtures < Test::Unit::TestCase
     assert c.data.keys.include?("eth1")
     assert_equal 2, c.data.keys.size
 
-    assert c.data["eth0"]["Bytes in"]
-    assert c.data["eth1"]["Bytes in"]
+    assert c.data["eth0"][:bytes_in]
+    assert c.data["eth1"][:bytes_in]
   end
 end
 

metadata

@@ -1,132 +1,135 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: server_metrics
-version: !ruby/object:Gem::Version 
-  hash: 25
+version: !ruby/object:Gem::Version
+  version: 0.0.5
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 3
-  version: 0.0.3
 platform: ruby
-authors: 
+authors:
 - Andre Lewis
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-10-29 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-10-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: sys-proctable
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: bundler
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 9
-        segments: 
-        - 1
-        - 3
-        version: "1.3"
+      - !ruby/object:Gem::Version
+        version: '1.3'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rake
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: awesome_print
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: pry
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: timecop
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id006
-- !ruby/object:Gem::Dependency 
-  name: mocha
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id007
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Collect information about disks, memory, CPU, etc
-email: 
+email:
 - andre@scoutapp.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - LICENSE.txt
@@ -153,41 +156,38 @@ files:
 - test/test_basics.rb
 - test/test_helper.rb
 - test/test_with_fixtures.rb
-has_rdoc: true
 homepage: http://scoutapp.com
-licenses: 
+licenses:
 - MIT
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: 3269620975841777684
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
+      hash: 3269620975841777684
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.4.2
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: For use with the Scout agent
-test_files: 
+test_files:
 - test/fixtures/cpu.txt
 - test/fixtures/disk.txt
 - test/fixtures/memory.txt