Class: GetProcessMem

Inherits:
Object
  • Object
show all
Includes:
Sys
Defined in:
lib/get_process_mem.rb,
lib/get_process_mem/darwin.rb,
lib/get_process_mem/version.rb

Overview

Cribbed from Unicorn Worker Killer, thanks!

Defined Under Namespace

Classes: Darwin

Constant Summary collapse

KB_TO_BYTE =

2**10 = 1024

number_to_bigdecimal 1024
MB_TO_BYTE =

1024**2 = 1_048_576

number_to_bigdecimal 1_048_576
GB_TO_BYTE =

1024**3 = 1_073_741_824

number_to_bigdecimal 1_073_741_824
CONVERSION = 
{ "kb" => KB_TO_BYTE, "mb" => MB_TO_BYTE, "gb" => GB_TO_BYTE }
ROUND_UP = 
number_to_bigdecimal "0.5"
RUNS_ON_WINDOWS = 
Gem.win_platform?
RUNS_ON_DARWIN = 
Gem.platforms.detect do |p|
  p.is_a?(Gem::Platform) && p.os == 'darwin'
end
VERSION = 
"0.2.7"

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(pid = Process.pid) ⇒ GetProcessMem

Returns a new instance of GetProcessMem.



48
49
50
51
52
53
 
# File 'lib/get_process_mem.rb', line 48

def initialize(pid = Process.pid)
  @status_file  = Pathname.new "/proc/#{pid}/status"
  @process_file = Pathname.new "/proc/#{pid}/smaps"
  @pid          = pid
  @linux        = @status_file.exist?
end

Instance Attribute Details

#pid ⇒ Object (readonly)

Returns the value of attribute pid.



19
20
21
 
# File 'lib/get_process_mem.rb', line 19

def pid
  @pid
end

Instance Method Details

#bytes ⇒ Object 



59
60
61
62
63
 
# File 'lib/get_process_mem.rb', line 59

def bytes
  memory =   linux_status_memory if linux?
  memory ||= darwin_memory if RUNS_ON_DARWIN
  memory ||= ps_memory
end

#darwin_memory ⇒ Object 



121
122
123
124
125
 
# File 'lib/get_process_mem.rb', line 121

def darwin_memory
  Darwin.resident_size(pid)
rescue Errno::EPERM
  nil
end

#gb(b = bytes) ⇒ Object 



73
74
75
 
# File 'lib/get_process_mem.rb', line 73

def gb(b = bytes)
  (b/GB_TO_BYTE).to_f
end

#inspect ⇒ Object 



77
78
79
80
 
# File 'lib/get_process_mem.rb', line 77

def inspect
  b = bytes
  "#<#{self.class}:0x%08x @mb=#{ mb b } @gb=#{ gb b } @kb=#{ kb b } @bytes=#{b}>" % (object_id * 2)
end

#kb(b = bytes) ⇒ Object 



65
66
67
 
# File 'lib/get_process_mem.rb', line 65

def kb(b = bytes)
  (b/KB_TO_BYTE).to_f
end

#linux? ⇒ Boolean

Returns:

  • (Boolean) 


55
56
57
 
# File 'lib/get_process_mem.rb', line 55

def linux?
  @linux
end

#linux_memory(file = @process_file) ⇒ Object

linux stores detailed memory info in a file “/proc/##pid/smaps”



94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/get_process_mem.rb', line 94

def linux_memory(file = @process_file)
  lines = file.each_line.select {|line| line.match(/^Rss/) }
  return if lines.empty?
  lines.reduce(0) do |sum, line|
    line.match(/(?<value>(\d*\.{0,1}\d+))\s+(?<unit>\w\w)/) do |m|
      value = number_to_bigdecimal(m[:value]) + ROUND_UP
      unit  = m[:unit].downcase
      sum  += CONVERSION[unit] * value
    end
    sum
  end
rescue Errno::EACCES
  0
end

#linux_status_memory(file = @status_file) ⇒ Object

linux stores memory info in a file “/proc/##pid/status” If it’s available it uses less resources than shelling out to ps



84
85
86
87
88
89
90
91
 
# File 'lib/get_process_mem.rb', line 84

def linux_status_memory(file = @status_file)
  line = file.each_line.detect {|line| line.start_with? 'VmRSS'.freeze }
  return unless line
  return unless (_name, value, unit = line.split(nil)).length == 3
  CONVERSION[unit.downcase!] * value.to_i
rescue Errno::EACCES, Errno::ENOENT
  0
end

#mb(b = bytes) ⇒ Object 



69
70
71
 
# File 'lib/get_process_mem.rb', line 69

def mb(b = bytes)
  (b/MB_TO_BYTE).to_f
end

#ps_memory ⇒ Object

Pull memory from ‘ps` command, takes more resources and can freeze in low memory situations



111
112
113
114
115
116
117
118
119
 
# File 'lib/get_process_mem.rb', line 111

def ps_memory
  if RUNS_ON_WINDOWS
    size = ProcTable.ps(pid: pid).working_set_size
    number_to_bigdecimal(size)
  else
    mem = `ps -o rss= -p #{pid}`
    KB_TO_BYTE * number_to_bigdecimal(mem == "" ? 0 : mem)
  end
end