Module: Vmstat::ProcFS

Defined in:
lib/vmstat/procfs.rb

Overview

Implementation of performance metrics gathering for linux and other os with the proc file system.

Constant Summary collapse

CPU_DATA =

Grep from the man procfs about cpu data in stat file:

Examples:

Format

(num) user nice system idle iowait irq softirq steal

manpage

iowait - time waiting for I/O to complete (since 2.5.41)  
irq - time servicing interrupts (since 2.6.0-test4)
softirq - time servicing softirqs (since 2.6.0-test4)
Since Linux 2.6.11:
steal - stolen time, which is the time spent in other operating 
        systems when running in a virtualized environment
Since Linux 2.6.24:
guest - which is the time spent running a virtual CPU for guest
        operating systems under the control of the Linux kernel.
/cpu(\d+)#{'\s+(\d+)' * 4}/.freeze
NET_DATA =

Grep the network stats from the procfs.

Examples:

Format (from /proc/net/dev)

Inter-|   Receive                                                |  Transmit
 face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed

Data

eth0:   33660     227    0    0    0     0          0         0    36584     167    0    0    0     0       0          0
/(\w+):#{'\s*(\d+)' * 16}/

Instance Method Summary collapse

Instance Method Details

#boot_time ⇒ Time

Fetches the boot time of the system.

Examples:

Vmstat.boot_time # => 2012-10-09 18:42:37 +0200

Returns:

  • (Time) —

    the boot time as regular time object.



126
127
128
129
 
# File 'lib/vmstat/procfs.rb', line 126

def boot_time
  raw = procfs_file("uptime") { |file| file.read }
  Time.now - raw.split(/\s/).first.to_f
end

#cpu ⇒ Array<Vmstat::Cpu>

Fetches the cpu statistics (usage counter for user, nice, system and idle)

Examples:

Vmstat.cpu # => [#<struct Vmstat::Cpu ...>, #<struct Vmstat::Cpu ...>]

Returns:



32
33
34
35
36
37
38
39
40
 
# File 'lib/vmstat/procfs.rb', line 32

def cpu
  cpus = []
  procfs_file("stat") do |file|
    file.read.scan(CPU_DATA) do |i, user, nice, system, idle|
      cpus << Cpu.new(i.to_i, user.to_i, system.to_i, nice.to_i, idle.to_i)
    end
  end
  cpus
end

#memory ⇒ Vmstat::Memory

Fetches the memory usage information.

Examples:

Vmstat.memory # => #<struct Vmstat::Memory ...>

Returns:



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/vmstat/procfs.rb', line 46

def memory
  @pagesize ||= Vmstat.pagesize
  has_available = false

  total = free = active = inactive = pageins = pageouts = available = 0
  procfs_file("meminfo") do |file|
    content = file.read(2048) # the requested information is in the first bytes

    content.scan(/(\w+):\s+(\d+) kB/) do |name, kbytes|
      pages = (kbytes.to_i * 1024) / @pagesize

      case name
        when "MemTotal" then total = pages
        when "MemFree" then free = pages
        when "MemAvailable"
            available = pages
            has_available = true
        when "Active" then active = pages
        when "Inactive" then inactive = pages
      end
    end
  end

  procfs_file("vmstat") do |file|
    content = file.read

    if content =~ /pgpgin\s+(\d+)/
      pageins = $1.to_i
    end

    if content =~ /pgpgout\s+(\d+)/
      pageouts = $1.to_i
    end
  end

  mem_klass = has_available ? LinuxMemory : Memory
  mem_klass.new(@pagesize, total-free-active-inactive, active,
                inactive, free, pageins, pageouts).tap do |mem|
    mem.available = available if has_available
  end
end

#network_interfaces ⇒ Array<Vmstat::NetworkInterface>

Fetches the information for all available network devices.

Examples:

Vmstat.network_interfaces # => [#<struct Vmstat::NetworkInterface ...>, ...]

Returns:



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/vmstat/procfs.rb', line 92

def network_interfaces
  netifcs = []
  procfs_file("net", "dev") do |file|
    file.read.scan(NET_DATA) do |columns|
      type = case columns[0]
        when /^eth/ then NetworkInterface::ETHERNET_TYPE
        when /^lo/  then NetworkInterface::LOOPBACK_TYPE
      end

      netifcs << NetworkInterface.new(columns[0].to_sym, columns[1].to_i,
                                      columns[3].to_i,   columns[4].to_i,
                                      columns[9].to_i,   columns[11].to_i,
                                      type)
    end
  end
  netifcs
end

#procfs_file(*names) {|file| ... } ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Opens a proc file system file handle and returns the handle in the passed block. Closes the file handle.

Examples:

procfs_file("net", "dev") { |file| }
procfs_file("stat") { |file| }

Parameters:

  • names (Array<String>) —

    parts of the path to the procfs file

Yield Parameters:

  • file (IO) —

    the file handle

See Also:

  • File#open


148
149
150
151
 
# File 'lib/vmstat/procfs.rb', line 148

def procfs_file(*names, &block)
  path = File.join(procfs_path, *names)
  File.open(path, "r", &block)
end

#procfs_path ⇒ String

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns the path to the proc file system.

Examples:

procfs_path # => "/proc"

Returns:

  • (String) —

    the path to the proc file system



135
136
137
 
# File 'lib/vmstat/procfs.rb', line 135

def procfs_path
  "/proc".freeze
end

#task ⇒ Vmstat::Task

Fetches the current process cpu and memory data.

Returns:



112
113
114
115
116
117
118
119
120
 
# File 'lib/vmstat/procfs.rb', line 112

def task
  @pagesize ||= Vmstat.pagesize

  procfs_file("self", "stat") do |file|
    data = file.read.split(/ /)
    Task.new(data[22].to_i / @pagesize, data[23].to_i,
             data[13].to_i * 1000, data[14].to_i * 1000)
  end
end