get_process_mem 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5cca1e4bc8403f7fea51433ecdc8471f65fdf823
+  data.tar.gz: 3dfb46b8047e464e46f3bee70826b6ed9114522e
+SHA512:
+  metadata.gz: dbf95661e13258be18215581177f9f7f2beb949dd5f389ba75b18d60af72b877bfcb2668a53ac641c59fc2ab26b34a6e0320a451c1a346c5191b07596d5f6714
+  data.tar.gz: 77cbc7d341d3e8e40e573886f57d8be80801e37d8c55d813ca0853655b1ef9d205bf838cfda59015bfa761a9216a0896c5bbbdd63eb303c98618ae62a0ef78ac

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - ruby-head
+  - jruby-19mode
+  - rbx-19mode
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: rbx-19mode
+    - rvm: jruby-19mode

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    get_process_mem (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.1.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  get_process_mem!
+  rake (~> 10.1)

data/README.md

@@ -0,0 +1,56 @@
+# Get Process Memory
+
+[![Build Status](https://travis-ci.org/schneems/get_process_memory.png?branch=master)](https://travis-ci.org/schneems/get_process_memory)
+
+Do you need to get the memory useage of a process? Great because this library does that.
+
+## Install
+
+In your `Gemfile` add
+
+```ruby
+gem 'get_process_mem'
+```
+
+then run `$ bundle install`
+
+
+## Use It
+
+Get the current process memory usage:
+
+```ruby
+puts mem = GetProcessMem.new.inspect
+#<GetProcessMem @mb=24.28125 @gb=0.023712158203125 @kb=24864.0 @bytes=25460736 >
+mem.bytes # => 25460736
+mem.kb    # => 24864.0
+mem.mb    # => 24.28125
+mem.gb    # => 0.023712158203125
+```
+
+Note: all numeric values returned as a float except bytes which is an integer.
+
+Get memory usage of another process:
+
+```ruby
+`echo 'nothing to see here' > tmplogf`
+pid = Process.spawn('tail -f tmplog')
+mem = GetProcessMem.new(pid)
+puts mem.inspect
+# => #<GetProcessMem @mb=0.48828125 @gb=0.000476837158203125 @kb=500.0 @bytes=512000 >
+
+Process.kill('TERM', pid)
+Process.wait(pid)
+
+mem.inspect
+# => "#<GetProcessMem @mb=0.0 @gb=0.0 @kb=0.0 @bytes=0>"
+`rm tmplog`
+```
+
+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. It's all I needed for the project.
+
+
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+require 'bundler/gem_tasks'
+
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:test]
+
+test_task = Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end

data/get_process_mem.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'get_process_mem/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "get_process_mem"
+  gem.version       = GetProcessMem::VERSION
+  gem.authors       = ["Richard Schneeman"]
+  gem.email         = ["richard.schneeman+rubygems@gmail.com"]
+  gem.description   = %q{ Get memory usage of a process in Ruby }
+  gem.summary       = %q{ Use GetProcessMem to find out the amount of RAM used by any process }
+  gem.homepage      = "https://github.com/schneems/get_process_mem"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rake",  "~> 10.1"
+end

data/lib/get_process_mem.rb

@@ -0,0 +1,87 @@
+require 'pathname'
+
+# 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
+  CONVERSION = { "kb" => KB_TO_BYTE, "mb" => MB_TO_BYTE, "gb" => GB_TO_BYTE}
+  MEM_TYPE   = "rss" # http://en.wikipedia.org/wiki/Resident_set_size
+  attr_reader :pid
+
+  def initialize(pid = Process.pid, mem_type = MEM_TYPE)
+    @process_file = Pathname.new "/proc/#{pid}/status"
+    @pid          = pid
+    @linux        = @process_file.exist?
+    self.mem_type = mem_type
+  end
+
+  def linux?
+    @linux
+  end
+
+  def bytes
+    memory =   linux_memory if linux?
+    memory ||= ps_memory
+  end
+
+  def kb(b = bytes)
+    b.to_f/KB_TO_BYTE
+  end
+
+  def mb(b = bytes)
+    b.to_f/MB_TO_BYTE
+  end
+
+  def gb(b = bytes)
+    b.to_f/GB_TO_BYTE
+  end
+
+  def refresh
+    @bytes = nil
+  end
+
+  def inspect
+    b = bytes
+    "#<#{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
+  end
+
+  private
+
+  # Pull memory from `ps` command, takes more resources and can freeze
+  # in low memory situations
+  def ps_memory
+    KB_TO_BYTE * `ps -o #{mem_type_for_ps}= -p #{pid}`.to_i
+  end
+
+  def mem_type_for_ps
+    mem_type
+  end
+
+  def mem_type_for_linux
+    case mem_type
+    when 'rss'
+      'VmRSS'
+    end
+  end
+
+  # 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_memory
+    line = @process_file.read.each_line.detect {|line| line.include? mem_type_for_linux }
+    return unless line
+    return unless (name, value, unit = line.split(nil)).length == 3
+    multiplier = CONVERSION[unit.downcase]
+    multiplier * value.to_i
+  end
+end
+
+GetProcessMem

data/lib/get_process_mem/version.rb

@@ -0,0 +1,3 @@
+class GetProcessMem
+  VERSION = "0.0.1"
+end

data/test/get_process_mem_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class GetProcessMemTest < Test::Unit::TestCase
+
+  def setup
+    @mem = GetProcessMem.new
+  end
+
+  def test_seems_to_work
+    assert @mem.kb    > 0
+    assert @mem.mb    > 0
+    assert @mem.gb    > 0
+    assert @mem.bytes > 0
+  end
+
+  def test_conversions
+    bytes = 0
+    assert_equal 0.0, @mem.kb(bytes)
+    assert_equal 0.0, @mem.mb(bytes)
+    assert_equal 0.0, @mem.gb(bytes)
+
+    # kb
+    bytes = 1024
+    assert_equal 1.0,                 @mem.kb(bytes)
+    assert_equal 0.0009765625,        @mem.mb(bytes)
+    assert_equal 9.5367431640625e-07, @mem.gb(bytes)
+
+    # mb
+    bytes = 1_048_576
+    assert_equal 1024.0,              @mem.kb(bytes)
+    assert_equal 1.0,                 @mem.mb(bytes)
+    assert_equal 0.0009765625,        @mem.gb(bytes)
+
+    # gb
+    bytes = 1_073_741_824
+    assert_equal 1048576.0,           @mem.kb(bytes)
+    assert_equal 1024.0,              @mem.mb(bytes)
+    assert_equal 1.0,                 @mem.gb(bytes)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+Bundler.require
+
+require 'get_process_mem'
+require 'test/unit'
+

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: get_process_mem
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Richard Schneeman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+description: " Get memory usage of a process in Ruby "
+email:
+- richard.schneeman+rubygems@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- get_process_mem.gemspec
+- lib/get_process_mem.rb
+- lib/get_process_mem/version.rb
+- test/get_process_mem_test.rb
+- test/test_helper.rb
+homepage: https://github.com/schneems/get_process_mem
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Use GetProcessMem to find out the amount of RAM used by any process
+test_files:
+- test/get_process_mem_test.rb
+- test/test_helper.rb
+has_rdoc: