puma_worker_killer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce372755dae3f6e9abb64192488e0709ecf7af12
+  data.tar.gz: 8c51e18768753c3716487379f217a431f4ae6f1e
+SHA512:
+  metadata.gz: 535cc32a6414aae221b2842a85bc5205d7043cc37699a3b1d488af5922b89688aebacce10276e025a9af9c0190f98c19f3ed55521ffc49c14fafcd532ac9b12e
+  data.tar.gz: 0c025d47e64ddfe8589ee3145178cb9205adcc1248d2b494631e15b1fd5186178662c716cec2f8a2a126ae86addc757fc598b8e6c415a8cb0bfa795d14a6f4b0

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.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/README.md

@@ -0,0 +1,64 @@
+# Puma Worker Killer
+
+[![Build Status](https://travis-ci.org/schneems/puma_worker_killer.png?branch=master)](https://travis-ci.org/schneems/puma_worker_killer)
+
+
+## What
+
+If you have a memory leak in your code, finding and plugging it can be a herculean effort. Instead what if you just killed your processes when they got to be too large? The Puma Worker Killer does just that. Similar to [Unicorn Worker Killer](https://github.com/kzk/unicorn-worker-killer) but for the Puma web server. Note that Puma can uses threads or processes to add concurrency, the Puma Worker Killer only helps if you are using clustered mode (concurrency via process).
+
+
+## Install
+
+In your Gemfile add:
+
+```ruby
+gem 'puma_worker_killer'
+```
+
+Then run `$ bundle install`
+
+## Use
+
+Somewhere in your main process run this code:
+
+```ruby
+PumaWorkerKiller.start
+```
+
+That's it. Now on a regular basis the size of all Puma and all of it's forked processes will be evaluated and if they're over the RAM threshold will be killed. Don't worry Puma will notice a process is missing a spawn a fresh copy with a much smaller RAM footprint ASAP.
+
+## Configure
+
+Before calling `start` you can configure `PumaWorkerKiller`. You can do so using a configure block or calling methods directly:
+
+```ruby
+PumaWorkerKiller.config do |config|
+  config.ram           = 1024 # mb
+  config.frequency     = 5    # seconds
+  config.percent_usage = 0.98
+end
+```
+
+It is important that you tell your code how much RAM is available on your system. The default is 512 mb (the same size as a Heroku 1x dyno). You can change this value like this:
+
+```ruby
+PumaWorkerKiller.ram = 1024 # mb
+```
+
+By default it is assumed that you do not want to hit 100% utilization, that is if your code is actually using 512 mb out of 512 mb it would be bad (this is dangerously close to swapping memory and slowing down your programs). So by default processes will be killed when they are at 99 % utilization of the value specified in `PumaWorkerKiller.ram`. You can change that value to 98 % like this:
+
+```ruby
+PumaWorkerKiller.percent_usage = 0.98
+```
+
+You may want to tune the worker killer to run more or less often. You can adjust frequency:
+
+```ruby
+PumaWorkerKiller.frequency = 20 # seconds
+```
+
+## 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/lib/puma_worker_killer.rb

@@ -0,0 +1,26 @@
+require 'get_process_mem'
+
+module PumaWorkerKiller
+  extend self
+
+  attr_accessor :ram, :frequency, :percent_usage
+  self.ram           = 512  # mb
+  self.frequency     = 10   # seconds
+  self.percent_usage = 0.99 # percent of RAM to use
+
+  def config
+    yield self
+  end
+
+  def reaper(ram = self.ram, percent = self.percent_usage)
+    Reaper.new(ram * percent_usage)
+  end
+
+  def start(frequency = self.frequency, reaper = self.reaper)
+    AutoReap.new(frequency, reaper).start
+  end
+end
+
+require 'puma_worker_killer/reaper'
+require 'puma_worker_killer/auto_reap'
+require 'puma_worker_killer/version'

data/lib/puma_worker_killer/auto_reap.rb

@@ -0,0 +1,21 @@
+module PumaWorkerKiller
+  class AutoReap
+    def initialize(timeout, reaper = Reaper.new)
+      @timeout = timeout # seconds
+      @reaper  = reaper
+      @running = false
+    end
+
+    def start
+      @running = true
+
+      Thread.new do
+        while @running
+          @reaper.reap
+          sleep @timeout
+        end
+      end
+    end
+
+  end
+end

data/lib/puma_worker_killer/reaper.rb

@@ -0,0 +1,47 @@
+module PumaWorkerKiller
+  class Reaper
+    def initialize(max_ram, master = self.get_master)
+      @max_ram = max_ram
+      @master  = master
+    end
+
+    def get_master
+      ObjectSpace.each_object(Puma::Cluster).map { |obj| obj }.first
+    end
+
+    def get_memory(pid)
+      GetProcessMem.new(pid).mb
+    end
+
+    def get_workers
+      workers = {}
+      @master.instance_variable_get("@workers").each { |worker| workers[worker] = get_memory(worker.pid) }
+      workers
+    end
+
+    def get_total_memory(workers = self.get_workers)
+      master_memory = get_memory(Process.pid)
+      worker_memory = workers.map {|_, mem| mem }.inject(&:+) || 0
+      worker_memory + master_memory
+    end
+
+    def wait(pid)
+      Process.wait(pid)
+    rescue Errno::ECHILD
+    end
+
+    def reap
+      return false unless @master
+      workers      = get_workers
+      total_memory = get_total_memory(workers)
+      if workers.any? && total_memory > @max_ram
+        biggest_worker, memory_used = workers.sort_by {|_, mem| mem }.last
+        biggest_worker.term
+        @master.log "PumaWorkerKiller: Out of memory. #{workers.count} workers consuming total: #{total_memory} mb out of max: #{@max_ram} mb. Sending TERM to #{biggest_worker.inspect} consuming #{memory_used} mb."
+        wait(biggest_worker.pid)
+      else
+        @master.log "PumaWorkerKiller: Consuming #{total_memory} mb with master and #{workers.count} workers"
+      end
+    end
+  end
+end

data/lib/puma_worker_killer/version.rb

@@ -0,0 +1,3 @@
+module PumaWorkerKiller
+  VERSION = "0.0.1"
+end

data/puma_worker_killer.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'puma_worker_killer/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "puma_worker_killer"
+  gem.version       = PumaWorkerKiller::VERSION
+  gem.authors       = ["Richard Schneeman"]
+  gem.email         = ["richard.schneeman+rubygems@gmail.com"]
+  gem.description   = %q{ }
+  gem.summary       = %q{ }
+  gem.homepage      = "https://github.com/schneems/puma_worker_killer"
+  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_dependency "puma",              "~> 2"
+  gem.add_dependency "get_process_mem",   "~> 0"
+  gem.add_development_dependency "rake",  "~> 10.1"
+end

data/test/puma_worker_killer_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class PumaWorkerKillerTest < Test::Unit::TestCase
+
+  def test_worker_reaped
+    ram      = 1 #mb
+    cluster = FakeCluster.new
+    reaper   = PumaWorkerKiller::Reaper.new(ram, cluster)
+    worker_count = 10
+    worker_count.times { cluster.add_worker }
+
+    assert_equal worker_count, cluster.workers.count
+    refute cluster.workers.detect {|w| w.is_term? }
+
+    reaper.reap
+    assert_equal 1, cluster.workers.select {|w| w.is_term? }.count
+
+    reaper.reap
+    assert_equal 2, cluster.workers.select {|w| w.is_term? }.count
+
+    reaper.reap
+    assert_equal 3, cluster.workers.select {|w| w.is_term? }.count
+  ensure
+    cluster.workers.map(&:term)
+  end
+
+  def test_kills_memory_leak
+    ram     = 75 #mb
+    cluster = FakeCluster.new
+    reaper  = PumaWorkerKiller::Reaper.new(ram, cluster)
+    while reaper.get_total_memory < (ram * 0.80)
+      cluster.add_worker
+    end
+
+    reaper.reap
+    assert_equal 0, cluster.workers.select {|w| w.is_term? }.count
+
+    while reaper.get_total_memory < ram
+      cluster.add_worker
+    end
+
+    reaper.reap
+    assert_equal 1, cluster.workers.select {|w| w.is_term? }.count
+  ensure
+    cluster.workers.map(&:term)
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,65 @@
+Bundler.require
+
+require 'puma_worker_killer'
+require 'test/unit'
+
+
+# Mock object stand in for Puma::Cluster
+class FakeCluster
+  def initialize
+    @workers = []
+  end
+
+  class Worker
+    attr_accessor :pid
+
+    def initialize(pid)
+      @pid = pid
+    end
+
+    def memory_leak
+      while true
+
+      end
+    end
+
+    # not public interface, used for testing
+    def is_term?
+      @first_term_sent
+    end
+
+    def term
+      begin
+        if @first_term_sent && (Time.new - @first_term_sent) > 30
+          @signal = "KILL"
+        else
+          @first_term_sent ||= Time.new
+        end
+
+        Process.kill "TERM", @pid
+        Process.wait(@pid)
+      rescue Errno::ESRCH, Errno::ECHILD
+      end
+    end
+  end
+
+  def log(msg)
+    puts msg
+  end
+
+  def do_work
+    while true
+      sleep 1
+    end
+  end
+
+  # not a public interface, added to make testing easier
+  def workers
+    @workers
+  end
+
+  def add_worker
+    pid = fork { do_work }
+    @workers << Worker.new(pid)
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: puma_worker_killer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Richard Schneeman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: get_process_mem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: " "
+email:
+- richard.schneeman+rubygems@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/puma_worker_killer.rb
+- lib/puma_worker_killer/auto_reap.rb
+- lib/puma_worker_killer/reaper.rb
+- lib/puma_worker_killer/version.rb
+- puma_worker_killer.gemspec
+- test/puma_worker_killer_test.rb
+- test/test_helper.rb
+homepage: https://github.com/schneems/puma_worker_killer
+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: ''
+test_files:
+- test/puma_worker_killer_test.rb
+- test/test_helper.rb
+has_rdoc: