vmstator 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa6c931304074e4c5c866858e3375f027dd5f0f3
-  data.tar.gz: de2d4a841bee588b785a95f4ef1319a3cd830e39
+  metadata.gz: e9f01ed118a36cdc3d161ab2b7cf1c30693661da
+  data.tar.gz: c4a608ff0ec342043e2ce7afde48b5a87d797f28
 SHA512:
-  metadata.gz: 35f05ee3a7786b3383d0a6518f4bd3ec74b9de987e73f1392a344cd42edbf6d43c09b9ca1c6d29d9e04394e879ee6c6d991ddc7d54326d69936f022ba6237a90
-  data.tar.gz: 8a1a67389fbf481222a3111a9be3a16cea5432b4c292e4f3a5c06286cde667858aaf59f11831d7c9133c4d8faacb22b9ff63a8ffebedcaf423f91b5e007880c6
+  metadata.gz: 2c6ad37064f53314407b1372695dc4fd00b648bd27c93037b0bed4ee11878324703432ca06c53abec5ac2e9defb5898dc48b17adab05d384deb8e6822d7fadc1
+  data.tar.gz: 1f5526ebed499e79496a8de503753f53619b7ee44f59dd876621e20df97fdc064ea9a04d519acde1cf01844811d96264c94dfb158ef92f8256627217f4da8391

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    vmstator (1.0.1)
+    vmstator (2.0.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -8,6 +8,8 @@ This gem is still in development, but has more or less working code! :)
 
 ![screenshot](http://i.imgur.com/spjIhpy.png "Screen Shot")
 
+![screenshot2](http://i.imgur.com/D9TNIpY.png "Screen Shot2")
+
 ## Installation
 
 ### Gemfile

data/examples/basic_example.rb

@@ -1,6 +1,32 @@
 # Path setting slight of hand:
 $: << File.expand_path("../../lib", __FILE__)
 require 'vmstator'
-require 'pry'
 
-binding.pry
+parser = Vmstator::Parser.new
+
+parser.active  
+# => Vmstator::DiskSummary
+
+parser.average  
+# => Vmstator::DiskSummary
+
+parser.disk_statistics  
+# => Vmstator::DiskStatistics
+ 
+parser.disk_summary  
+# => Vmstator::DiskSummary
+
+parser.event_counter_statistics  
+# => Vmstator::EventCounterStatistics
+
+parser.slab_info  
+# => Vmstator::SlabInfo
+
+parser.forks  
+# => Integer
+
+parser.parse("-a -S m")
+# => Whatever the flags were will determine output.
+
+parser.version
+# => String containing vmstat's version number.

data/lib/vmstator/active.rb

@@ -0,0 +1,8 @@
+module Vmstator
+
+  class ActiveMemory < Memory
+    # Basically the same thing as active,
+    # just not active. 
+  end
+
+end

data/lib/vmstator/average.rb

@@ -0,0 +1,8 @@
+module Vmstator
+
+  class AverageMemory < Memory
+    # Basically the same thing as active,
+    # just not active.
+  end
+
+end

data/lib/vmstator/cache.rb

@@ -0,0 +1,31 @@
+module Vmstator
+
+  class Cache
+    attr_reader :num
+    attr_reader :name
+    attr_reader :size
+    attr_reader :total
+    attr_reader :pages
+
+    def initialize(data=false)
+      if data
+        update(data)
+      end
+      true
+    end
+
+    def update(data)
+      if data
+        @num   = data[:num].to_i
+        @name  = data[:name]
+        @sec   = data[:size].to_i 
+        @total = data[:total].to_i
+        @pages = data[:pages].to_i
+      else
+        return false
+      end
+      true
+    end
+
+  end
+end

data/lib/vmstator/disk.rb

@@ -0,0 +1,35 @@
+module Vmstator
+
+  class Disk
+    attr_reader :ms
+    attr_reader :cur
+    attr_reader :sec
+    attr_reader :name
+    attr_reader :total
+    attr_reader :merged  
+    attr_reader :sectors
+
+    def initialize(data=false)
+      if data
+        update(data)
+      end
+      true
+    end
+
+    def update(data)
+      if data
+        @ms      = data[:ms]      if data[:ms]
+        @cur     = data[:cur]     if data[:cur]
+        @sec     = data[:sec]     if data[:sec]
+        @name    = data[:name]    if data[:name]
+        @total   = data[:total]   if data[:total]
+        @merged  = data[:merged]  if data[:merged]
+        @sectors = data[:sectors] if data[:sectors]
+      else
+        return false
+      end
+      true
+    end
+
+  end
+end

data/lib/vmstator/disk_statistics.rb

@@ -0,0 +1,25 @@
+module Vmstator
+
+  class DiskStatistics
+    # attrs for each attribute
+    attr_reader :disks
+
+    def initialize(data=false)
+      @disks = []
+      if data
+        update(data)
+      end
+      true
+    end
+
+    def update(data)
+      if data
+        @disks << Disk.new(data)
+      else
+        return false
+      end
+      true
+    end
+
+  end
+end

data/lib/vmstator/disk_summary.rb

@@ -0,0 +1,45 @@
+module Vmstator
+
+  class DiskSummary
+    attr_reader :disks
+    attr_reader :partitions
+    attr_reader :total_reads
+    attr_reader :merged_reads
+    attr_reader :read_sectors
+    attr_reader :milli_reading
+    attr_reader :writes
+    attr_reader :merged_writes
+    attr_reader :written_sectors
+    attr_reader :milli_writing
+    attr_reader :inprogress_io
+    attr_reader :milli_spent_io
+   
+    def initialize(data=false)
+      if data
+        update(data)
+      end
+      true
+    end
+
+    def update(data)
+      if data
+        @disks           = data[:disks]
+        @partitions      = data[:partitions]
+        @total_reads     = data[:total_reads]
+        @merged_reads    = data[:merged_reads] 
+        @read_sectors    = data[:read_sectors]
+        @milli_reading   = data[:milli_reading]
+        @writes          = data[:writes]
+        @merged_writes   = data[:merged_writes]
+        @written_sectors = data[:written_sectors]
+        @milli_writing   = data[:milli_writing]
+        @inprogress_io   = data[:inprogress_io]
+        @milli_spent_io  = data[:milli_spent_io]
+      else
+        return false
+      end
+      true
+    end
+    
+  end
+end

data/lib/vmstator/event_counter_statistics.rb

@@ -0,0 +1,73 @@
+module Vmstator
+
+  class EventCounterStatistics
+    attr_reader :total_memory
+    attr_reader :used_memory
+    attr_reader :active_memory
+    attr_reader :inactive_memory
+    attr_reader :free_memory
+    attr_reader :buffer_memory
+    attr_reader :swap_cache
+    attr_reader :total_swap
+    attr_reader :used_swap
+    attr_reader :free_swap
+    attr_reader :non_nice_user_cpu_ticks
+    attr_reader :nice_user_cpu_ticks
+    attr_reader :system_cpu_ticks
+    attr_reader :idle_cpu_ticks
+    attr_reader :io_wait_cpu_ticks
+    attr_reader :irq_cpu_ticks
+    attr_reader :softirq_cpu_ticks
+    attr_reader :stolen_cpu_ticks
+    attr_reader :pages_paged_in
+    attr_reader :pages_paged_out
+    attr_reader :pages_swapped_in
+    attr_reader :pages_swapped_out
+    attr_reader :interrupts
+    attr_reader :cpu_context_switches
+    attr_reader :boot_time
+    attr_reader :forks
+
+    def initialize(data=false)
+      if data
+        update(data)
+      end
+      true
+    end
+
+    def update(data)
+      if data
+        @total_memory            = data[:total_memory]
+        @used_memory             = data[:used_memory]
+        @active_memory           = data[:active_memory]
+        @inactive_memory         = data[:inactive_memory]
+        @free_memory             = data[:free_memory]
+        @buffer_memory           = data[:buffer_memory]
+        @swap_cache              = data[:swap_cache]
+        @total_swap              = data[:total_swap]
+        @used_swap               = data[:used_swap]
+        @free_swap               = data[:free_swap]
+        @non_nice_user_cpu_ticks = data[:non_nice_user_cpu_ticks]
+        @nice_user_cpu_ticks     = data[:nice_user_cpu_ticks]
+        @system_cpu_ticks        = data[:system_cpu_ticks]
+        @idle_cpu_ticks          = data[:idle_cpu_ticks]
+        @io_wait_cpu_ticks       = data[:io_wait_cpu_ticks]
+        @irq_cpu_ticks           = data[:irq_cpu_ticks]
+        @softirq_cpu_ticks       = data[:softirq_cpu_ticks]
+        @stolen_cpu_ticks        = data[:stolen_cpu_ticks]
+        @pages_paged_in          = data[:pages_paged_in]
+        @pages_paged_out         = data[:pages_paged_out]
+        @pages_swapped_in        = data[:pages_swapped_in]
+        @pages_swapped_out       = data[:pages_swapped_out]
+        @interrupts              = data[:interrupts]
+        @cpu_context_switches    = data[:cpu_context_switches]
+        @boot_time               = data[:boot_time]
+        @forks                   = data[:forks]
+      else
+        return false
+      end
+      true
+    end
+
+  end
+end

data/lib/vmstator/forks.rb

@@ -0,0 +1,9 @@
+module Vmstator
+
+  class Forks
+    def initialize
+      puts "forks"  
+    end
+  end
+
+end

data/lib/vmstator/memory.rb

@@ -0,0 +1,53 @@
+module Vmstator
+
+  class Memory < Stats
+    attr_reader :runnable     # number of runnable processes
+    attr_reader :uninter      # number of processes in uninterruptible sleep
+    attr_reader :used         # amount of virtual memory used
+    attr_reader :free         # amount of idle memory
+    attr_reader :buffer       # amount of memory used as buffers
+    attr_reader :cache        # amount of memory used as cache
+    attr_reader :swapped_in   # amount of memory swapped in from disk (/s)
+    attr_reader :swapped_to   # amount memory swapped to disk (/s)
+    attr_reader :blocks_recv  # blocks received from a device (blocks/s)
+    attr_reader :blocks_sent  # blocks sent to a block device (blocks/s)
+    attr_reader :interrupts   # number of interrupts (/s)
+    attr_reader :cntxt_swtchs # number of context switches (/s)
+    attr_reader :non_kernel   # time spent running non-kernel code
+    attr_reader :kernel       # time spent running kernel code
+    attr_reader :idle_time    # time spent idle
+    attr_reader :waiting      # time spent waiting for IO
+    attr_reader :stolen       # time stolen from a virtual machine
+
+    def update(data)
+      if data
+        @runnable     = data[:r]
+        @uninter      = data[:b]
+        @swapped_in   = data[:si] 
+        @swapped_to   = data[:so] 
+        @blocks_recv  = data[:bi] 
+        @blocks_sent  = data[:bo] 
+        @interrupts   = data[:in] 
+        @cntxt_swtchs = data[:cs] 
+        @non_kernel   = data[:us] 
+        @kernel       = data[:sy] 
+        @idle_time    = data[:id] 
+        @waiting      = data[:wa] 
+        @stolen       = data[:st] 
+        @used         = data[:swpd] 
+        @free         = data[:free] 
+        if self.is_a? AverageMemory
+          @cache  = data[:cache]
+          @buffer = data[:buff]
+        else
+          @cache  = false    
+          @buffer = false    
+        end
+      else
+        return false
+      end
+      true
+    end
+
+  end
+end

data/lib/vmstator/parser.rb

@@ -0,0 +1,121 @@
+module Vmstator
+
+ class Parser
+    # parse() parses the the vmstat command 
+    # with optional vmstat command-line flags
+    # which is passed in as a string
+    def parse(flags=false)
+      if flags 
+        if flags =~ /(-d|--disk)/
+          # parse instances of disk_statistics
+          return disk_statistics(flags)
+        elsif flags =~ /(-D|--disk-sum)/
+          # parse instances of disk summary
+          return disk_summary(flags)
+        elsif flags =~ /(-a|--active)/
+          # parse instances of active memory
+          return active(flags)
+        elsif flags =~ /(-m|--slabs)/
+          # parse instances of slab info
+          return slab_info(flags)
+        elsif flags =~ /(-f|--forks)/
+          # parse instances of forks
+          return forks
+        elsif flags =~ /(-s|--stats)/
+          # parse instances of event counter statistics
+          return event_counter_statistics(flags)
+        elsif flags =~ /(-V|--version)/
+          # parse instances of version
+          return version
+        else
+          # parse instances of the typical, average things
+          return average(flags)
+        end
+      else
+        return average
+      end
+    end
+
+    def version
+      `vmstat -V`.split.last
+    end
+
+    # slab_info() will run the -m flag and return that data
+    def average(flags="")
+      output = `vmstat #{flags}`.split("\n")
+      labels = output[1]
+      stats  = output[2]
+      data   = Hash[labels.split.map(&:to_sym).zip stats.split]
+      Vmstator::AverageMemory.new(data)
+    end
+
+    # active() will run the -a flag and return the data
+    def active(flag="")
+      output = `vmstat #{flags}`.split("\n")
+      labels = output[1]
+      stats  = output[2]
+      data   = Hash[labels.split.map(&:to_sym).zip stats.split]
+      Vmstator::ActiveMemory.new(data)
+    end
+
+    # event_counter_statistics() will run the -s flag and return the data 
+    def event_counter_statistics(flags="")
+      output = `vmstat #{flags}` 
+      keys   = output.split(/\d/).compact.join.split("\n").map(&:strip)
+      # this looks silly. but I kind'a like it
+      keys.map(&:downcase).map {|s| 
+         s.gsub(" ", "_")}.map {|s| 
+         s.gsub("-", "_")}.map {|s| 
+         s.gsub(/\b(\w){1}_{1}/, "") }.map(&:to_sym)
+      values = output.split(/[A-z]/).compact.join.split("\n").map(&:strip)
+      data   = Hash[keys.zip values]
+      Vmstator::DiskSummary.new(data)
+    end
+
+    # disk_summary() will run the -D flag and return the data
+    def disk_summary(flags="")
+      output = `vmstat #{flags}` 
+      keys   = output.split(/\d/).compact.join.split("\n").map(&:strip) 
+      keys.map(&:downcase).map {|s| 
+         s.gsub(" ", "_")}.map {|s| 
+         s.gsub("-", "_")}.map {|s|}.map(&:to_sym)
+    end 
+
+    # forks() will run the -f flag and return that data.
+    def forks
+      `vmstat -f`.split.first
+    end
+
+    # disk_statistics() will run the -d flag and return that data.
+    def disk_statistics(flags="")
+      disk_stats = Vmstator::DiskStatistics.new
+      output = `vmstat #{flags}`.split("\n")
+      # remove first line of the output
+      output.shift
+      output.shift
+      output.each do |line|
+        name, total, merged, sectors, ms, total, merged, sectors, ms, cur, sec = line.split
+        data = {:name => name, :totoal => total, :merged => merged, :sectors => sectors,
+                :ms => ms,     :cur => cur,      :sec => sec }
+        disk_stats.update(data)
+      end
+      disk_stats
+    end
+
+    # slab_info() will run the -m flag and return that data
+    def slab_info(flags="")
+      # TODO : may go back, make this an option to use sudo or not.
+      # You need sudo permission to run this flag.
+      slab_info = Vstator::SlabInfo.new 
+      `sudo vmstat #{flags}`.split("\n").each do |info|
+        next if info == "Cache                       Num  Total   Size  Pages"
+        name, num, total, size, pages = info.split
+        data = { :name => name, :num => num, :total => total,
+                 :size => size,  :pages => pages }
+        slab_info.update(data)
+      end
+      slab_info
+    end
+
+  end
+end

data/lib/vmstator/slab_info.rb

@@ -0,0 +1,25 @@
+module Vmstator
+
+  class SlabInfo
+    # attrs for each attribute
+    attr_reader :caches
+
+    def initialize(data=false)
+      @caches = []
+      if data
+        update(data)
+      end
+      true
+    end
+
+    def update(data)
+      if data
+        @caches << Cache.new(data)
+      else
+        return false
+      end
+      true
+    end
+
+  end
+end

data/lib/vmstator/stats.rb

@@ -0,0 +1,12 @@
+module Vmstator
+  class Stats
+    attr_reader :data
+
+    def initialize(data=false)
+      if data
+        update(data)
+      end
+      true
+    end
+  end
+end

data/lib/vmstator/version.rb

@@ -1,3 +1,3 @@
 module Vmstator
-  VERSION = "1.0.1"
+  VERSION = "2.0.0"
 end

data/lib/vmstator.rb

@@ -1,194 +1,143 @@
 require "vmstator/errors"
 require "vmstator/version"
+require "vmstator/stats"
+require "vmstator/memory"
+require "vmstator/active"
+require "vmstator/average"
+require "vmstator/cache"
+require "vmstator/disk"
+require "vmstator/disk_statistics"
+require "vmstator/disk_summary"
+require "vmstator/errors"
+require "vmstator/event_counter_statistics"
+require "vmstator/forks"
+require "vmstator/slab_info"
+require "vmstator/version"
 
 module Vmstator
 
-  # The Stats class does most of the work for this gem
-  # by providing an interface to parse vmstat, process
-  # flags for the vmstat command, and a way to access the
-  # result of that data.
-  class Stats
-    # Comand-line Flags
-    attr_accessor :flags
-    # Output of command and all parsed data
-    attr_reader :output, :data
-    # Parsed Data
-    attr_reader :r,    :runnable     # number of runnable processes
-    attr_reader :b,    :uninter      # number of processes in uninterruptible sleep
-    attr_reader :swpd, :used         # amount of virtual memory used
-    attr_reader :free, :free         # amount of idle memory
-    attr_reader :buff, :buffer       # amount of memory used as buffers
-    attr_reader :c,    :cache        # amount of memory used as cache
-    attr_reader :si,   :swapped_in   # amount of memory swapped in from disk (/s)
-    attr_reader :so,   :swapped_to   # amount memory swapped to disk (/s)
-    attr_reader :bi,   :blocs_recv   # blocks received from a block device (blocks/s)
-    attr_reader :bo,   :blocks_sent  # blocks sent to a block device (blocks/s)
-    attr_reader :in,   :interrupts   # number of interrupts (/s)
-    attr_reader :cs,   :cntxt_swtchs # number of context switches (/s)
-    attr_reader :us,   :non_kernel   # time spent running non-kernel code
-    attr_reader :sy,   :kernel       # time spent running kernel code
-    attr_reader :id,   :idle_time    # time spent idle
-    attr_reader :wa,   :waiting      # time spent waiting for IO
-    attr_reader :st,   :stolen       # time stolen from a virtual machine
-
-    # initialize() handles the initialization of a new
-    # Vmstator::Stats object which takes in an optional
-    # set of arguments that can be passed in as a hash.
-    #
-    # == Example
-    #
-    #  # Typical use case:
-    #  vmstats = Vmstator::Stats.new(:flags => "-S m", :parse => true )
-    #  # => true
-    #
-    def initialize(args=false)
-      unless vmstat_exists?
-        Vmstator::VmstatError.new("Vmstat was not found on this system!")
-      end
-      if args
-        process_flags(args[:flags]) if args[:flags]
-        parse if args[:parse]
+  class Parser
+    # parse() parses the the vmstat command 
+    # with optional vmstat command-line flags
+    # which is passed in as a string
+    def parse(flags=false)
+      if flags 
+        if flags =~ /(-d|--disk)/
+          # parse instances of disk_statistics
+          return disk_statistics(flags)
+        elsif flags =~ /(-D|--disk-sum)/
+          # parse instances of disk summary
+          return disk_summary(flags)
+        elsif flags =~ /(-a|--active)/
+          # parse instances of active memory
+          return active(flags)
+        elsif flags =~ /(-m|--slabs)/
+          # parse instances of slab info
+          return slab_info(flags)
+        elsif flags =~ /(-f|--forks)/
+          # parse instances of forks
+          return forks
+        elsif flags =~ /(-s|--stats)/
+          # parse instances of event counter statistics
+          return event_counter_statistics(flags)
+        elsif flags =~ /(-V|--version)/
+          # parse instances of version
+          return version
+        else
+          # parse instances of the typical, average things
+          return average(flags)
+        end
+      else
+        return average
       end
-      true
     end
 
-    # dry_run() runs the vmstat command with the available flags or
-    # will raise a custom Vmstator::VmstatError
-    def dry_run
-      unless system("vmstat #{@flags} > /dev/null 2>&1")
-        raise Vmstator::VmstatError.new("Vmstat ran into a problem with the flag(s): #{@flags}")
-      end
+    def version
+      `vmstat -V`.split.last
     end
 
-    # forks() will run the -f flag and return that data.
-    def forks
-      `vmstat -f`.split.first
+    # average() will run the command normally and return the data
+    def average(flags="")
+      output = `vmstat #{flags}`.split("\n")
+      labels = output[1]
+      stats  = output[2]
+      data   = Hash[labels.split.map(&:to_sym).zip stats.split.map(&:to_i)]
+      Vmstator::AverageMemory.new(data)
     end
-    
-    # active() will parse the results of active
-    #  and inactive memory information.
-    def active
-      parse("-a") 
+
+    # active() will run the -a flag and return the data
+    def active(flags=false)
+      flags = "-a" unless flags
+      output = `vmstat #{flags}`.split("\n")
+      labels = output[1]
+      stats  = output[2]
+      data   = Hash[labels.split.map(&:to_sym).zip stats.split.map(&:to_i)]
+      Vmstator::ActiveMemory.new(data)
     end
 
-    # version() will run the -V flag and return the version
-    # number from that information.
-    def vmstat_version
-      `vmstat -V`.split.last
+    # event_counter_statistics() will run the -s flag and return the data 
+    def event_counter_statistics(flags=false)
+      flags  = "-s" unless flags
+      output = `vmstat #{flags}` 
+      values = output.split(/[A-z]/).compact.join.split("\n").map(&:strip).map(&:to_i)
+      keys   = output.split(/\d/).compact.join.split("\n").map(&:strip)
+      keys   = keys.map(&:downcase).map { |s| 
+                  s.gsub(" ", "_")}.map { |s| 
+                  s.gsub("-", "_")}.map { |s| 
+                  s.gsub(/\b(\w){1}_{1}/, "") }.map(&:to_sym)
+      data = Hash[keys.zip values]
+      Vmstator::EventCounterStatistics.new(data)
     end
 
-    # version() will run the -d flag and return the parsed
-    # informatio from that command.
-    def disk_info
-      @disk_info = {}
-      @disk_info[:disks] = {}
-      output = `vmstat -d`.split("\n")
-      # remove first two lines of the output
+    # disk_summary() will run the -D flag and return the data
+    def disk_summary(flags=false)
+      flags  = "-D" unless flags
+      output = `vmstat #{flags}` 
+      values = output.split(/[A-z]/).compact.join.split("\n").map(&:strip).map(&:to_i)
+      keys   = output.split(/\d/).compact.join.split("\n").map(&:strip) 
+      keys   = keys.map(&:downcase).map {|s| s.gsub(" ", "_")}.map(&:to_sym)
+      data   = Hash[keys.zip values]
+      Vmstator::DiskSummary.new(data)
+    end 
+
+    # forks() will run the -f flag and return that data.
+    def forks
+      `vmstat -f`.split.first.to_i
+    end
+
+    # disk_statistics() will run the -d flag and return that data.
+    def disk_statistics(flags="")
+      flags      = "-d" unless flags
+      disk_stats = Vmstator::DiskStatistics.new
+      output     = `vmstat #{flags}`.split("\n")
+      # remove first line of the output
       output.shift
       output.shift
-      @disk_info[:disk_count] = output.count
       output.each do |line|
-        disk, total, merged, sectors, ms, total, merged, sectors, ms, cur, sec = line.split
-        @disk_info[:disks][disk] = { :totoal => total, :merged => merged, :sectors => sectors,
-                                     :ms => ms,        :cur => cur,       :sec => sec }
+        name, total, merged, sectors, ms, total, merged, sectors, ms, cur, sec = line.split
+        data = {:name => name, :totoal => total, :merged => merged, :sectors => sectors,
+                :ms => ms,     :cur => cur,      :sec => sec }
+        disk_stats.update(data)
       end
-      @disk_info
-    end 
-
-    # event_counter_statistics() will return the event
-    # count statistics in the form of a hash
-    def event_counter_statistics(flags=@flags)
-      output = `vmstat #{flags}` 
-      keys   = output.split(/\d/).compact.join.split("\n").map(&:strip)
-      values = output.split(/[A-z]/).compact.join.split("\n").map(&:strip)
-      Hash[keys.zip values]
+      disk_stats
     end
 
     # slab_info() will run the -m flag and return that data
-    def slab_info
+    def slab_info(flags="")
+      flags = "-m" unless flags
       # TODO : may go back, make this an option to use sudo or not.
       # You need sudo permission to run this flag.
-      @slab_info = {}
-      `sudo vmstat -m`.split("\n").each do |info|
+      flags = "-m" if flags.empty?
+      slab_info = Vmstator::SlabInfo.new 
+      `sudo vmstat #{flags}`.split("\n").each do |info|
         next if info == "Cache                       Num  Total   Size  Pages"
-        cache, num, total, size, pages = info.split
-        @slab_info[cache] = {}
-        @slab_info[cache][:num]   = num
-        @slab_info[cache][:total] = total
-        @slab_info[cache][:size]  = size
-        @slab_info[cache][:pages] = pages
-      end
-      @slab_info
-    end
-
-    # parse() is probably the main work horse of this class. It parses the
-    # the vmstat command after a dry run is done to check the command. It
-    # does quite few things: including parsing all of the vmstat information
-    # into a hash stored in @data; and will then store the relevant information
-    # into the appropriate attr_reader
-    #
-    # == Example
-    #
-    #  # Typical use case to parse a vmstat command.
-    #  vmstats = Vmstator::Stats.new(:flags => "-S m")
-    #  vmstats.parse
-    #  # => true
-    #
-    def parse(flags=@flags)
-      if flags =~ /(-d|--disk)/
-        return disk_statistics
-      elsif flags =~ /(-f|--forks)/
-        return forks
-      elsif flags =~ /(-s|--stats)/
-        return event_counter_statistics
-      end
-      dry_run
-      @output = `vmstat #{flags}`.split("\n")
-      labels  = @output[1]
-      stats   = @output[2]
-      @data = Hash[labels.split.map(&:to_sym).zip stats.split]
-      @swpd, @used         = @data[:swpd],  @data[:swpd]
-      @buff, @buffer       = @data[:buff],  @data[:buff]
-      @r,    @runnable     = @data[:r],     @data[:r]
-      @b,    @uninter      = @data[:b],     @data[:b]
-      @si,   @swapped_in   = @data[:si],    @data[:si]
-      @so,   @swapped_to   = @data[:so],    @data[:so]
-      @bi,   @blocs_recv   = @data[:bi],    @data[:bi]
-      @bo,   @blocks_sent  = @data[:bo],    @data[:bo]
-      @in,   @interrupts   = @data[:in],    @data[:in]
-      @cs,   @cntxt_swtchs = @data[:cs],    @data[:cs]
-      @us,   @non_kernel   = @data[:us],    @data[:us]
-      @sy,   @kernel       = @data[:sy],    @data[:sy]
-      @id,   @idle_time    = @data[:id],    @data[:id]
-      @wa,   @waiting      = @data[:wa],    @data[:wa]
-      @st,   @stolen       = @data[:st],    @data[:st]
-      @cache               = @data[:cache]
-      @free                = @data[:free]
-      true
-    end
-
-    private
-
-    # vmstat_exists?() checks if vmstat exists
-    # or not returning true or false for the command.
-    def vmstat_exists?
-      system("which vmstat > /dev/null 2>&1")
-    end
-
-    # process_flags() allows the flags argument that is passed
-    # in to be either an array or a string. That way the flags
-    # argument can be processed intuitively as either a string
-    # of flags or simple an array of those flags.
-    def process_flags(flags)
-      if flags.is_a? String
-        @flags = flags
-      elsif flags.is_a? Array
-        @flags = flags.join(" ")
-      else
-        false
+        name, num, total, size, pages = info.split
+        data = { :name => name, :num => num, :total => total,
+                 :size => size,  :pages => pages }
+        slab_info.update(data)
       end
+      slab_info
     end
 
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vmstator
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Kent 'picat' Gruber
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-07 00:00:00.000000000 Z
+date: 2016-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,10 +71,23 @@ files:
 - bin/setup
 - examples/basic_example.rb
 - lib/vmstator.rb
+- lib/vmstator/active.rb
+- lib/vmstator/average.rb
+- lib/vmstator/cache.rb
+- lib/vmstator/disk.rb
+- lib/vmstator/disk_statistics.rb
+- lib/vmstator/disk_summary.rb
 - lib/vmstator/errors.rb
+- lib/vmstator/event_counter_statistics.rb
+- lib/vmstator/forks.rb
+- lib/vmstator/memory.rb
+- lib/vmstator/parser.rb
+- lib/vmstator/slab_info.rb
+- lib/vmstator/stats.rb
 - lib/vmstator/version.rb
 - pkg/vmstator-0.1.0.gem
 - pkg/vmstator-1.0.0.gem
+- pkg/vmstator-1.0.1.gem
 - vmstator.gemspec
 homepage: https://github.com/picatz/Vmstator
 licenses: