vidibus-sysinfo 0.0.10 → 1.0.0

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2011-2013 Andre Pankratz
+Copyright (c) 2011-2014 Andre Pankratz
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -30,11 +30,14 @@ This gem uses various tools to obtain system data. Installing those tools should
 
 ### CPU cores
 
-To get the number of CPU cores, call
+To get general system information, call
 
 ```ruby
-  Vidibus::Sysinfo.core
-  # => 4
+  Vidibus::Sysinfo.system.to_h    # following metrics as hash
+
+  Vidibus::Sysinfo.system.cpus    # number of CPUs
+  Vidibus::Sysinfo.system.cores   # number of cores
+  Vidibus::Sysinfo.system.sockets # number of sockets
 ```
 
 ### CPU utilization
@@ -42,8 +45,20 @@ To get the number of CPU cores, call
 To get CPU utilization in percent, call
 
 ```ruby
-  Vidibus::Sysinfo.cpu
-  # => 18.4 # percent
+  Vidibus::Sysinfo.cpu.to_f   # usage total
+  Vidibus::Sysinfo.cpu.to_i   # rounded usage total
+  Vidibus::Sysinfo.cpu.to_h   # following metrics as hash
+
+  Vidibus::Sysinfo.cpu.used   # usage total
+  Vidibus::Sysinfo.cpu.idle   # idle
+  Vidibus::Sysinfo.cpu.user   # on user level
+  Vidibus::Sysinfo.cpu.nice   # with nice priority
+  Vidibus::Sysinfo.cpu.system # on system level
+  Vidibus::Sysinfo.cpu.iowait # waiting for IO
+  Vidibus::Sysinfo.cpu.irq    # caused by service interrupts
+  Vidibus::Sysinfo.cpu.soft   # caused by software interrupts
+  Vidibus::Sysinfo.cpu.steal  # caused by virtualization hypervisor
+  Vidibus::Sysinfo.cpu.guest  # on virtual processors
 ```
 
 ### System load
@@ -52,8 +67,12 @@ The system load value is divided by the number of CPU cores.
 To get the system load, call
 
 ```ruby
-  Vidibus::Sysinfo.load
-  # => 0.39
+  Vidibus::Sysinfo.load.to_f    # system load over last minute
+  Vidibus::Sysinfo.load.to_h    # following metrics as hash
+
+  Vidibus::Sysinfo.load.one     # system load over last minute
+  Vidibus::Sysinfo.load.five    # system load over five minutes
+  Vidibus::Sysinfo.load.fifteen # system load over fifteen minutes
 ```
 
 ### Monthly traffic
@@ -61,8 +80,13 @@ To get the system load, call
 To get the total traffic of this month in gigabytes, call
 
 ```ruby
-  Vidibus::Sysinfo.traffic
-  # => 7992.15 # gigabytes
+  Vidibus::Sysinfo.traffic.to_f   # traffic total
+  Vidibus::Sysinfo.traffic.to_i   # rounded traffic total
+  Vidibus::Sysinfo.traffic.to_h   # following metrics as hash
+
+  Vidibus::Sysinfo.traffic.total  # traffic total
+  Vidibus::Sysinfo.traffic.input  # input traffic
+  Vidibus::Sysinfo.traffic.output # output traffic
 ```
 
 ### Currently used throughput
@@ -70,8 +94,13 @@ To get the total traffic of this month in gigabytes, call
 To get the currently used throughput in MBit/s, call
 
 ```ruby
-  Vidibus::Sysinfo.throughput
-  # => 38.71 # MBit/s
+  Vidibus::Sysinfo.throughput.to_f   # throughput total
+  Vidibus::Sysinfo.throughput.to_i   # rounded throughput total
+  Vidibus::Sysinfo.throughput.to_h   # following metrics as hash
+
+  Vidibus::Sysinfo.throughput.total  # throughput total
+  Vidibus::Sysinfo.throughput.input  # input throughput
+  Vidibus::Sysinfo.throughput.output # output throughput
 ```
 
 Throughput detection is performed by analyzing the output of /proc/net/dev.
@@ -84,39 +113,53 @@ an optional argument:
 
 ```ruby
   Vidibus::Sysinfo.throughput(10)
-  # => 33.28 # MBit/s
 ```
 
-### Consumed storage
+### Storage
 
-To get the consumed storage of the main device in gigabytes, call
+To get storage information on the main device in gigabytes, call
 
 ```ruby
-  Vidibus::Sysinfo.storage
-  # => 647.89 # gigabytes
+  Vidibus::Sysinfo.storage.to_f   # used storage
+  Vidibus::Sysinfo.storage.to_i   # rounded used storage
+  Vidibus::Sysinfo.storage.to_h   # following metrics as hash
+
+  Vidibus::Sysinfo.storage.used   # used storage
+  Vidibus::Sysinfo.storage.free   # free storage
+  Vidibus::Sysinfo.storage.total  # disk size
 ```
 
-### Used memory
+### Memory
 
 To get the currently used memory in megabytes, call
 
 ```ruby
-  Vidibus::Sysinfo.memory
-  # => 3281.38 # megabytes
+  Vidibus::Sysinfo.memory.to_f   # used memory
+  Vidibus::Sysinfo.memory.to_i   # rounded used memory
+  Vidibus::Sysinfo.memory.to_h   # following metrics as hash
+
+  Vidibus::Sysinfo.memory.used   # used memory
+  Vidibus::Sysinfo.memory.free   # free memory
+  Vidibus::Sysinfo.memory.total  # memory size
 ```
 
 This will ignore memory used for system caching.
 
 
-### Used swap
+### Swap
 
 To get the currently used swap in megabytes, call
 
 ```ruby
-  Vidibus::Sysinfo.swap
-  # => 0.0 # megabytes
+  Vidibus::Sysinfo.swap.to_f   # used swap
+  Vidibus::Sysinfo.swap.to_i   # rounded used swap
+  Vidibus::Sysinfo.swap.to_h   # following metrics as hash
+
+  Vidibus::Sysinfo.swap.used   # used swap
+  Vidibus::Sysinfo.swap.free   # free swap
+  Vidibus::Sysinfo.swap.total  # swap size
 ```
 
 ## Copyright
 
-Copyright (c) 2011-2013 Andre Pankratz. See LICENSE for details.
+Copyright (c) 2011-2014 Andre Pankratz. See LICENSE for details.

data/lib/vidibus/sysinfo/base.rb

@@ -7,6 +7,7 @@ module Vidibus
 
     # Provides common methods.
     module Base
+      include Helper
 
       def call
         output, error = perform(command)
@@ -45,12 +46,6 @@ module Vidibus
         end
       end
 
-      # Rounds float with given precision.
-      def round(float, precision = 2)
-        m = 10**precision
-        (float.to_f*m).round.to_f/m
-      end
-
       # Converts given amount from unit to megabytes.
       # Treats GB and GiB identically because in our context GB == GiB.
       def megabytes(value, unit = "B")

data/lib/vidibus/sysinfo/cpu.rb

@@ -12,14 +12,40 @@ module Vidibus
     module Cpu
       extend Base
 
+      class Result < Vidibus::Sysinfo::Result
+        attrs :user, :nice, :system, :iowait, :irq, :soft, :steal, :guest, :idle, :used
+
+        def to_i
+          round(used, 0).to_i
+        end
+
+        def to_f
+          used
+        end
+      end
+
       class << self
         def command
           "mpstat 1 5 | grep Average:"
         end
 
         def parse(output)
-          if output.match(/([\d\.]+)$/)
-            round(100.0 - $1.to_f)
+          matches = output.scan(/([\d\.]+)/)
+          if matches.any?
+            matches.flatten!
+            data = {
+              user: matches[0].to_f,
+              nice: matches[1].to_f,
+              system: matches[2].to_f,
+              iowait: matches[3].to_f,
+              irq: matches[4].to_f,
+              soft: matches[5].to_f,
+              steal: matches[6].to_f,
+              guest: matches[7].to_f,
+              idle: matches[8].to_f
+            }
+            data[:used] = round(100.0 - data[:idle])
+            Result.new(data)
           end
         end
 

data/lib/vidibus/sysinfo/helper.rb

@@ -0,0 +1,7 @@
+module Helper
+  # Rounds float with given precision.
+  def round(float, precision = 2)
+    m = 10**precision
+    (float.to_f*m).round.to_f/m
+  end
+end

data/lib/vidibus/sysinfo/load.rb

@@ -8,16 +8,31 @@ module Vidibus
     module Load
       extend Base
 
+      class Result < Vidibus::Sysinfo::Result
+        attrs :one, :five, :fifteen
+
+        def to_f
+          one
+        end
+      end
+
       class << self
         def command
           "uptime"
         end
 
         def parse(output)
-          if output.match(/load average:\s+(\d+(?:\.\d+)?)/)
-            value = $1.to_f
-            cores = Core.call
-            round(value/cores)
+          number = /\s+(\d+(?:\.\d+)?)/
+          if output.match(/load average:#{number},#{number},#{number}/)
+            one = $1.to_f
+            five = $2.to_f
+            fifteen = $3.to_f
+            cpus = System.call[:cpus]
+            Result.new({
+              one: round(one/cpus),
+              five: round(five/cpus),
+              fifteen: round(fifteen/cpus)
+            })
           end
         end
       end

data/lib/vidibus/sysinfo/memory.rb

@@ -8,6 +8,18 @@ module Vidibus
     module Memory
       extend Base
 
+      class Result < Vidibus::Sysinfo::Result
+        attrs :total, :used, :free
+
+        def to_i
+          used
+        end
+
+        def to_f
+          used.to_f
+        end
+      end
+
       class << self
         def command
           "free -m | grep Mem:"
@@ -16,9 +28,15 @@ module Vidibus
         def parse(output)
           if output.match(/^Mem:\s+([\d\s]+)$/)
             numbers = $1.split(/\s+/)
-            used = numbers[1].to_i
+            total = numbers[0].to_i
+            buffers = numbers[4].to_i
             cached = numbers[5].to_i
-            used - cached
+            used = numbers[1].to_i - buffers - cached
+            Result.new({
+              total: total,
+              used: used,
+              free: total - used
+            })
           end
         end
       end

data/lib/vidibus/sysinfo/result.rb

@@ -0,0 +1,34 @@
+module Vidibus
+  module Sysinfo
+    class Result
+      include Helper
+
+      def initialize(options)
+        attrs.each do |attr|
+          instance_variable_set("@#{attr}", options[attr])
+        end
+      end
+
+      def to_h
+        {}.tap do |hash|
+          attrs.each do |attr|
+            hash[attr] = send(attr)
+          end
+        end
+      end
+
+      private
+
+      def attrs
+        self.class.instance_variable_get('@attrs')
+      end
+
+      class << self
+        def attrs(*args)
+          self.send(:attr, *args)
+          @attrs = args
+        end
+      end
+    end
+  end
+end

data/lib/vidibus/sysinfo/storage.rb

@@ -8,6 +8,18 @@ module Vidibus
     module Storage
       extend Base
 
+      class Result < Vidibus::Sysinfo::Result
+        attrs :total, :used, :free
+
+        def to_i
+          round(used, 0).to_i
+        end
+
+        def to_f
+          used.to_f
+        end
+      end
+
       class << self
         def command
           'df -m'
@@ -16,9 +28,15 @@ module Vidibus
         def parse(output)
           device = /(?:[\/a-z0-9]+)/
           size = /\s+(\d+)\i?/
-          if output.match(/#{device}#{size}#{size}/m)
-            amount = $2.to_f
-            gigabytes(amount, 'M')
+          if matches = output.match(/#{device}#{size}#{size}#{size}/m)
+            total = $1.to_f
+            used = $2.to_f
+            free = $3.to_f
+            Result.new({
+              total: gigabytes(total, 'M'),
+              used: gigabytes(used, 'M'),
+              free: gigabytes(free, 'M')
+            })
           end
         end
       end

data/lib/vidibus/sysinfo/swap.rb

@@ -8,6 +8,18 @@ module Vidibus
     module Swap
       extend Base
 
+      class Result < Vidibus::Sysinfo::Result
+        attrs :total, :used, :free
+
+        def to_i
+          round(used, 0).to_i
+        end
+
+        def to_f
+          used.to_f
+        end
+      end
+
       class << self
         def command
           "free -m | grep Swap:"
@@ -16,7 +28,11 @@ module Vidibus
         def parse(output)
           if output.match(/^Swap:\s+([\d\s]+)$/)
             numbers = $1.split(/\s+/)
-            numbers[1].to_i
+            Result.new({
+              total: numbers[0].to_i,
+              used: numbers[1].to_i,
+              free: numbers[2].to_i
+            })
           end
         end
       end

data/lib/vidibus/sysinfo/{core.rb → system.rb}

@@ -5,17 +5,28 @@ module Vidibus
     #
     # Analyzes lscpu
     #
-    module Core
+    module System
       extend Base
 
+      class Result < Vidibus::Sysinfo::Result
+        attrs :cpus, :cores, :sockets
+      end
+
       class << self
         def command()
           'lscpu'
         end
 
         def parse(output)
-          if cpus = output[/CPU\(s\):\s+(\d+)/i, 1]
-            cpus.to_i
+          sockets = output[/Socket\(s\):\s+(\d+)/i, 1]
+          cores = output[/Core\(s\) per socket:\s+(\d+)/i, 1]
+          cpus = output[/CPU\(s\):\s+(\d+)/i, 1]
+          if sockets && cores && cpus
+            Result.new({
+              sockets: sockets.to_i,
+              cores: cores.to_i,
+              cpus: cpus.to_i
+            })
           end
         end
 

data/lib/vidibus/sysinfo/throughput.rb

@@ -8,6 +8,26 @@ module Vidibus
     module Throughput
       extend Base
 
+      class Result < Vidibus::Sysinfo::Result
+        attrs :input, :output
+
+        def to_h
+          super.merge(total: total)
+        end
+
+        def total
+          round(input + output)
+        end
+
+        def to_i
+          round(total, 0).to_i
+        end
+
+        def to_f
+          total.to_f
+        end
+      end
+
       class << self
         def command
           "cat /proc/net/dev | grep eth0:"
@@ -23,18 +43,24 @@ module Vidibus
             values << respond(output, error)
             sleep(seconds) unless values.size > 1
           end
-          megs = values[1] - values[0]
-          mbits = (megs*8)/seconds
-          round(mbits)
+          result = {}
+          [:input, :output].each do |type|
+            megs = values[1][type] - values[0][type]
+            result[type] = round((megs*8)/seconds)
+          end
+          Result.new(result)
         end
 
-        # Returns sum of transmitted and received bytes in megabytes.
+        # Returns received and sent megabytes.
         def parse(output)
           if output.match(/eth0\:\s*([\d\s]+)/)
             numbers = $1.split(/\s+/)
-            received = numbers[0].to_i
-            transmitted = numbers[8].to_i
-            megabytes(received + transmitted)
+            input = numbers[0].to_i
+            output = numbers[8].to_i
+            {
+              input: megabytes(input),
+              output: megabytes(output)
+            }
           end
         end
 

data/lib/vidibus/sysinfo/traffic.rb

@@ -12,6 +12,26 @@ module Vidibus
     module Traffic
       extend Base
 
+      class Result < Vidibus::Sysinfo::Result
+        attrs :input, :output
+
+        def to_h
+          super.merge(total: total)
+        end
+
+        def total
+          round(input + output)
+        end
+
+        def to_i
+          round(total, 0).to_i
+        end
+
+        def to_f
+          total.to_f
+        end
+      end
+
       class << self
         def command
           "vnstat -m"
@@ -21,10 +41,15 @@ module Vidibus
           month = /(\s*\w{3} \'\d{2})/
           traffic = /\s*(\d+(?:\.\d+)?) (ki?B|Mi?B|Gi?B|Ti?B)\s*/i
           last_month = output.split(/\r?\n/)[-3]
-          if last_month and last_month.match(/#{month}#{traffic}\|#{traffic}\|#{traffic}+/m)
-            amount = $6.to_f
-            unit = $7
-            gigabytes(amount, unit)
+          if last_month && last_month.match(/#{month}#{traffic}\|#{traffic}\|#{traffic}+/m)
+            input_amount = $2.to_f
+            input_unit = $3
+            output_amount = $4.to_f
+            output_unit = $5
+            Result.new({
+              input: gigabytes(input_amount, input_unit),
+              output: gigabytes(output_amount, output_unit)
+            })
           elsif output.match("Not enough data available yet")
             0.0
           end

data/lib/vidibus/sysinfo/version.rb

@@ -1,5 +1,5 @@
 module Vidibus
   module Sysinfo
-    VERSION = '0.0.10'
+    VERSION = '1.0.0'
   end
 end

data/lib/vidibus/sysinfo.rb

@@ -1,6 +1,8 @@
 require 'open3'
+require 'vidibus/sysinfo/helper'
 require 'vidibus/sysinfo/base'
-require 'vidibus/sysinfo/core'
+require 'vidibus/sysinfo/result'
+require 'vidibus/sysinfo/system'
 require 'vidibus/sysinfo/cpu'
 require 'vidibus/sysinfo/load'
 require 'vidibus/sysinfo/traffic'
@@ -13,9 +15,9 @@ module Vidibus
   module Sysinfo
     class << self
 
-      # Returns number of cpu cores.
-      def core
-        Core.call
+      # Returns system information like CPUs and cores.
+      def system
+        System.call
       end
 
       # Returns CPU utilization in percent.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vidibus-sysinfo
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-09 00:00:00.000000000 Z
+date: 2014-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -114,12 +114,14 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/vidibus/sysinfo/base.rb
-- lib/vidibus/sysinfo/core.rb
 - lib/vidibus/sysinfo/cpu.rb
+- lib/vidibus/sysinfo/helper.rb
 - lib/vidibus/sysinfo/load.rb
 - lib/vidibus/sysinfo/memory.rb
+- lib/vidibus/sysinfo/result.rb
 - lib/vidibus/sysinfo/storage.rb
 - lib/vidibus/sysinfo/swap.rb
+- lib/vidibus/sysinfo/system.rb
 - lib/vidibus/sysinfo/throughput.rb
 - lib/vidibus/sysinfo/traffic.rb
 - lib/vidibus/sysinfo/version.rb
@@ -143,7 +145,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4266894747005125364
+      hash: 2849344004889068849
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: