get_process_mem 0.2.0 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d66e96644c3f8d171fd8533346150dc2a653badc
-  data.tar.gz: faaa15b6c510b50ced777bc2163042ac2934b9a6
+SHA256:
+  metadata.gz: 1d0fb74ff83b646fc0abdbbad624257304311fa98ea5204cce96d12957572432
+  data.tar.gz: 8a51db8a8638d7d160b6a34d924244d4a28056168f3aea4341abf9d6fe890576
 SHA512:
-  metadata.gz: 03f334783b312689fa9f7adcb28cd692285a2ffe181ebd5753662cb6b8b326249a57391beeea26a0198eddc2c86d8692f20bd70a02d8ab67c1d45be8bd6fc78d
-  data.tar.gz: 865fba383f18073a1bf9d7d9cfa543ad56e57544347aa3e8374899aea1f4144a8ddc7b66dc22f2762e94a55ce04970a5d9c865395577436058791bedaa87673a
+  metadata.gz: e3291519f57f2b44c5d8794098c5b87331bb49599f43ea1d06bc269560759e0e9ef0bb2318a4f1d261a4709634024cd00d0bb73bca559ff23440fb194cb25964
+  data.tar.gz: 4c16b205f3a20b0f1a7a2110bb3ee370918107f2a4e509a044f9ab0dc01cf8285a3042c5cc656c65a6bd50d6e5f5d68c5bd2e980915d42632bf0fbed3faccfa3

data/.github/workflows/check_changelog.yml

@@ -0,0 +1,12 @@
+name: Check Changelog
+
+on: [pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v1
+    - name: Check that CHANGELOG is touched
+      run: |
+        cat $GITHUB_EVENT_PATH | jq .pull_request.title |  grep -i '\[\(\(changelog skip\)\|\(ci skip\)\)\]' ||  git diff remotes/origin/${{ github.base_ref }} --name-only | grep CHANGELOG.md

data/.travis.yml

@@ -1,14 +1,20 @@
 language: ruby
+os:
+  - linux
+  - osx
+
+before_install:
+  - gem install bundler -v 1.17.3
+
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
+  - 2.2
+  - 2.6
   - ruby-head
-  - jruby-19mode
-  - rbx-19mode
+  - jruby-head
+  - truffleruby
 
 matrix:
   allow_failures:
     - rvm: ruby-head
-    - rvm: rbx-19mode
-    - rvm: jruby-19mode
+    - rvm: jruby-head
+    - rvm: truffleruby

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## Master - unreleased
+
+## 0.2.5
+
+- Use new sys-proctable interface (https://github.com/schneems/get_process_mem/pull/36)
+
+## 0.2.4
+
+- Use FFI to speed up memory lookup on Mac (darwin) by roughly 12x (#32)
+
+## 0.2.3
+
+- Silence BigDecimal deprecation warning under Ruby 2.5 (#26)
+
+## 0.2.2
+
+- Fix support for Ruby 2.4 (#23)
+
+## 0.2.1
+
+- ???
+
 ## 0.2.0
 
 - Reverting back to RSS for linux until (#7) is resolved
@@ -13,4 +35,4 @@
 
 ## 0.0.1
 
-- Initial
+- Initial

data/Gemfile

@@ -1,3 +1,4 @@
 source "https://rubygems.org"
+gem 'sys-proctable'
 
 gemspec

data/README.md

@@ -1,6 +1,7 @@
 # Get Process Memory
 
-[![Build Status](https://travis-ci.org/schneems/get_process_mem.png?branch=master)](https://travis-ci.org/schneems/get_process_mem)
+[![Build Status](https://travis-ci.org/schneems/get_process_mem.svg?branch=master)](https://travis-ci.org/schneems/get_process_mem)
+[![Help Contribute to Open Source](https://www.codetriage.com/schneems/get_process_mem/badges/users.svg)](https://www.codetriage.com/schneems/get_process_mem)
 
 Do you need to get the memory usage of a process? Great because this library does that.
 
@@ -12,15 +13,17 @@ In your `Gemfile` add
 gem 'get_process_mem'
 ```
 
-then run `$ bundle install`
+then run `$ bundle install`.
 
+If you're using Windows you'll also need to have the `sys-proctable` gem.
 
 ## Use It
 
 Get the current process memory usage:
 
 ```ruby
-puts mem = GetProcessMem.new.inspect
+mem = GetProcessMem.new
+puts mem.inspect
 #<GetProcessMem @mb=24.28125 @gb=0.023712158203125 @kb=24864.0 @bytes=25460736 >
 mem.bytes # => 25460736
 mem.kb    # => 24864.0
@@ -47,14 +50,7 @@ mem.inspect
 `rm tmplog`
 ```
 
-On Linux, which provides `/proc/<pid>/smaps`, the default memory type returned is PSS, or "proportional set size", where shared memory is divided by the number of processes sharing it. On other platforms, the size returned is the RSS or the [Resident Set Size](http://en.wikipedia.org/wiki/Resident_set_size), basically how much memory the program takes up in RAM at the time, including all the shared memory.
-
-The memory type can be specified by passing an options hash:
-
-```ruby
-GetProcessMem.new(Process.pid, mem_type: 'rss')
-```
-
+On Linux, for memory size we return the RSS or the [Resident Set Size](http://en.wikipedia.org/wiki/Resident_set_size), basically how much memory the program takes up in RAM at the time, including all the shared memory.
 
 
 ## License

data/appveyor.yml

@@ -0,0 +1,20 @@
+install:
+  - set PATH=C:\Ruby22\bin;%PATH%
+  - bundle install
+
+build: off
+
+before_test:
+  - ruby -v
+  - gem -v
+  - bundle -v
+
+test_script:
+  - bundle exec rake
+
+environment:
+  matrix:
+    - RUBY_VERSION: 23
+    - RUBY_VERSION: 22
+    - RUBY_VERSION: 21
+    - RUBY_VERSION: 200

data/get_process_mem.gemspec

@@ -18,5 +18,9 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency "rake",  "~> 10.1"
+  gem.add_dependency "ffi", "~> 1.0"
+
+  gem.add_development_dependency "sys-proctable", "~> 1.2"
+  gem.add_development_dependency "rake", "~> 12"
+  gem.add_development_dependency "test-unit", "~> 3"
 end

data/lib/get_process_mem.rb

@@ -1,20 +1,55 @@
 require 'pathname'
 require 'bigdecimal'
 
-
 # Cribbed from Unicorn Worker Killer, thanks!
 class GetProcessMem
-  KB_TO_BYTE = 1024          # 2**10   = 1024
-  MB_TO_BYTE = 1_048_576     # 1024**2 = 1_048_576
-  GB_TO_BYTE = 1_073_741_824 # 1024**3 = 1_073_741_824
+  private_class_method def self.number_to_bigdecimal(value)
+    BigDecimal(value)
+  end
+
+  private def number_to_bigdecimal(value)
+    self.class.send(:number_to_bigdecimal, value)
+  end
+
+  KB_TO_BYTE = number_to_bigdecimal 1024          # 2**10   = 1024
+  MB_TO_BYTE = number_to_bigdecimal 1_048_576     # 1024**2 = 1_048_576
+  GB_TO_BYTE = number_to_bigdecimal 1_073_741_824 # 1024**3 = 1_073_741_824
   CONVERSION = { "kb" => KB_TO_BYTE, "mb" => MB_TO_BYTE, "gb" => GB_TO_BYTE }
-  ROUND_UP   = BigDecimal.new("0.5")
+  ROUND_UP   = number_to_bigdecimal "0.5"
   attr_reader :pid
 
+  RUNS_ON_WINDOWS = Gem.win_platform?
+
+  if RUNS_ON_WINDOWS
+    begin
+      require 'sys/proctable'
+    rescue LoadError => e
+      message = "Please add `sys-proctable` to your Gemfile for windows machines\n"
+      message << e.message
+      raise e, message
+    end
+    include Sys
+  end
+
+  RUNS_ON_DARWIN =  Gem.platforms.detect do |p|
+                      p.is_a?(Gem::Platform) && p.os == 'darwin'
+                    end
+
+  if RUNS_ON_DARWIN
+    begin
+      require 'get_process_mem/darwin'
+    rescue LoadError => e
+      message = "Please add `ffi` to your Gemfile for darwin (macos) machines\n"
+      message << e.message
+      raise e, message
+    end
+  end
+
   def initialize(pid = Process.pid)
+    @status_file  = Pathname.new "/proc/#{pid}/status"
     @process_file = Pathname.new "/proc/#{pid}/smaps"
     @pid          = pid
-    @linux        = @process_file.exist?
+    @linux        = @status_file.exist?
   end
 
   def linux?
@@ -22,20 +57,21 @@ class GetProcessMem
   end
 
   def bytes
-    memory =   linux_memory if linux?
+    memory =   linux_status_memory if linux?
+    memory ||= darwin_memory if RUNS_ON_DARWIN
     memory ||= ps_memory
   end
 
   def kb(b = bytes)
-    (b/BigDecimal.new(KB_TO_BYTE)).to_f
+    (b/KB_TO_BYTE).to_f
   end
 
   def mb(b = bytes)
-    (b/BigDecimal.new(MB_TO_BYTE)).to_f
+    (b/MB_TO_BYTE).to_f
   end
 
   def gb(b = bytes)
-    (b/BigDecimal.new(GB_TO_BYTE)).to_f
+    (b/GB_TO_BYTE).to_f
   end
 
   def inspect
@@ -43,22 +79,24 @@ class GetProcessMem
     "#<#{self.class}:0x%08x @mb=#{ mb b } @gb=#{ gb b } @kb=#{ kb b } @bytes=#{b}>" % (object_id * 2)
   end
 
-  def mem_type
-    @mem_type
-  end
-
-  def mem_type=(mem_type)
-    @mem_type = mem_type.downcase
+  # linux stores memory info in a file "/proc/#{pid}/status"
+  # If it's available it uses less resources than shelling out to ps
+  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
 
-  # linux stores memory info in a file "/proc/#{pid}/smaps"
-  # If it's available it uses less resources than shelling out to ps
+  # linux stores detailed memory info in a file "/proc/#{pid}/smaps"
   def linux_memory(file = @process_file)
-    lines = file.each_line.select {|line| line.match /^Rss/ }
+    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 = BigDecimal.new(m[:value]) + ROUND_UP
+        value = number_to_bigdecimal(m[:value]) + ROUND_UP
         unit  = m[:unit].downcase
         sum  += CONVERSION[unit] * value
       end
@@ -68,11 +106,19 @@ class GetProcessMem
     0
   end
 
-  private
-
   # Pull memory from `ps` command, takes more resources and can freeze
   # in low memory situations
   def ps_memory
-    KB_TO_BYTE * BigDecimal.new(`ps -o rss= -p #{pid}`)
+    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
+
+  def darwin_memory
+    Darwin.resident_size
   end
 end

data/lib/get_process_mem/darwin.rb

@@ -0,0 +1,53 @@
+require 'ffi'
+
+class GetProcessMem
+  class Darwin
+    extend FFI::Library
+    ffi_lib 'c'
+    attach_function :mach_task_self, [], :__darwin_mach_port_t
+    attach_function :task_info,
+                    [
+                      :__darwin_mach_port_t,
+                      :int,     # return selector
+                      :pointer, #pointer to task info
+                      :pointer, #pointer to int (size of structure / bytes filled out)
+                    ],
+                    :int
+
+    class IntPtr < FFI::Struct
+      layout :value, :int
+    end
+
+    class TaskInfo < FFI::Struct
+      layout  :suspend_count, :int32,
+              :virtual_size, :uint64,
+              :resident_size, :uint64,
+              :user_time, :uint64,
+              :system_time, :uint64,
+              :policy, :int32
+    end
+
+    MACH_TASK_BASIC_INFO = 20
+    MACH_TASK_BASIC_INFO_COUNT = TaskInfo.size / FFI.type_size(:uint)
+
+    class << self
+      def resident_size
+        mach_task_info[:resident_size]
+      end
+
+      private
+
+      def mach_task_info
+        data = TaskInfo.new
+        out_count = IntPtr.new
+        out_count[:value] = MACH_TASK_BASIC_INFO_COUNT
+        result = task_info(mach_task_self, MACH_TASK_BASIC_INFO, data, out_count)
+        if result == 0
+          data
+        else
+          raise "task_info returned #{result}"
+        end
+      end
+    end
+  end
+end

data/lib/get_process_mem/version.rb

@@ -1,3 +1,3 @@
 class GetProcessMem
-  VERSION = "0.2.0"
-end
+  VERSION = "0.2.5"
+end

data/test/fixtures/heroku-bash-status

@@ -0,0 +1,41 @@
+Name:	bash
+State:	S (sleeping)
+Tgid:	3
+Ngid:	0
+Pid:	3
+PPid:	1
+TracerPid:	0
+Uid:	58790	58790	58790	58790
+Gid:	58790	58790	58790	58790
+FDSize:	256
+Groups:	
+VmPeak:	  109120 kB
+VmSize:	  109120 kB
+VmLck:	       0 kB
+VmPin:	       0 kB
+VmHWM:	    2032 kB
+VmRSS:	    2032 kB
+VmData:	     356 kB
+VmStk:	     136 kB
+VmExe:	     956 kB
+VmLib:	    2288 kB
+VmPTE:	      64 kB
+VmSwap:	       0 kB
+Threads:	1
+SigQ:	0/274188
+SigPnd:	0000000000000000
+ShdPnd:	0000000000000000
+SigBlk:	0000000000010000
+SigIgn:	0000000000380004
+SigCgt:	000000004b817efb
+CapInh:	0000000000000000
+CapPrm:	0000000000000000
+CapEff:	0000000000000000
+CapBnd:	0000001ff598cffe
+Seccomp:	2
+Cpus_allowed:	f
+Cpus_allowed_list:	0-3
+Mems_allowed:	00000000,00000001
+Mems_allowed_list:	0
+voluntary_ctxt_switches:	34
+nonvoluntary_ctxt_switches:	35

data/test/get_process_mem_test.rb

@@ -16,12 +16,17 @@ class GetProcessMemTest < Test::Unit::TestCase
   def test_linux_smap
     delta = 1
     bytes = @mem.linux_memory(fixture_path("heroku-bash-smap"))
-    assert_in_delta BigDecimal.new("2122240.0"), bytes, delta
+    assert_in_delta BigDecimal("2122240.0"), bytes, delta
+  end
+
+  def test_linux_status
+    bytes = @mem.linux_status_memory(fixture_path("heroku-bash-status"))
+    assert_equal bytes, 2080768
   end
 
   def test_conversions
     bytes = 0
-    delta = BigDecimal.new("0.0000001")
+    delta = BigDecimal("0.0000001")
     assert_in_delta  0.0, @mem.kb(bytes), delta
     assert_in_delta  0.0, @mem.mb(bytes), delta
     assert_in_delta  0.0, @mem.gb(bytes), delta

metadata

@@ -1,29 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: get_process_mem
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.5
 platform: ruby
 authors:
 - Richard Schneeman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-16 00:00:00.000000000 Z
+date: 2019-11-05 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: sys-proctable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '3'
 description: " Get memory usage of a process in Ruby "
 email:
 - richard.schneeman+rubygems@gmail.com
@@ -31,16 +73,20 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/check_changelog.yml"
 - ".gitignore"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - README.md
 - Rakefile
+- appveyor.yml
 - get_process_mem.gemspec
 - lib/get_process_mem.rb
+- lib/get_process_mem/darwin.rb
 - lib/get_process_mem/version.rb
 - test/fixtures/heroku-bash-smap
+- test/fixtures/heroku-bash-status
 - test/get_process_mem_test.rb
 - test/test_helper.rb
 homepage: https://github.com/schneems/get_process_mem
@@ -62,13 +108,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Use GetProcessMem to find out the amount of RAM used by any process
 test_files:
 - test/fixtures/heroku-bash-smap
+- test/fixtures/heroku-bash-status
 - test/get_process_mem_test.rb
 - test/test_helper.rb
-has_rdoc: