gitlab-puma_worker_killer 0.1.1.gitlab.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c6b50540a891f76c28cbbf9d2515312e145b6d1fafb64ea5d47658875c50a87b
+  data.tar.gz: 2f4f93250b070b77fb03e094c711a5819263606ddf21857e8afa0f2160729ad0
+SHA512:
+  metadata.gz: 6ca131cb1c2a24012a9d501f1773c5a0868904e2742b728f280688c4106792e76b573704e939869ccf08ac364560ef15d0538a8bd03105deffb96588ccdbd856
+  data.tar.gz: eeb62826df447cea6d2adda536b58661e19873382a83c4e844efaffe7969cc938b8caf9d9cd7cdf14107ecf72d1e62a84960840bbf650b7a161a7ed3a1e51c05

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+*.gem
+puma.log

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.10
+  - 2.2.9
+  - 2.3.6
+  - 2.4.3
+  - 2.5.0
+  - ruby-head
+  - rbx
+before_install:
+  - gem install bundler -v 1.12.5
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: rbx

data/CHANGELOG.md

@@ -0,0 +1,27 @@
+## 0.1.1
+
+- Allow PWK to be used with Puma 4 (#72)
+
+## 0.1.0
+
+- Emit extra data via `pre_term` callback before puma worker killer terminates a worker #49.
+
+## 0.0.7
+
+- Logging is configurable #41
+
+## 0.0.6
+
+- Log PID of worker insead of inspecting the worker #33
+
+## 0.0.5
+
+- Support for Puma 3.x
+
+## 0.0.4
+
+- Add ability to do rolling restart
+
+## 0.0.3
+
+- Fix memory metrics in on linux

data/Gemfile

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

data/README.md

@@ -0,0 +1,196 @@
+# Puma Worker Killer
+
+[![Build Status](https://travis-ci.org/schneems/puma_worker_killer.png?branch=master)](https://travis-ci.org/schneems/puma_worker_killer)
+[![Help Contribute to Open Source](https://www.codetriage.com/schneems/puma_worker_killer/badges/users.svg)](https://www.codetriage.com/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.
+
+Puma worker killer can only function if you have enabled cluster mode or hybrid mode (threads + worker cluster). If you are only using threads (and not workers) then puma worker killer cannot help keep your memory in control.
+
+BTW restarting your processes to control memory is like putting a bandaid on a gunshot wound, try figuring out the reason you're seeing so much memory bloat [derailed benchmarks](https://github.com/schneems/derailed_benchmarks) can help.
+
+
+## Install
+
+In your Gemfile add:
+
+```ruby
+gem 'puma_worker_killer'
+```
+
+Then run `$ bundle install`
+
+<!--
+## Use
+
+> If you like `puma_worker_killer` consider using [puma_auto_tune instead](https://github.com/schneems/puma_auto_tune). It handles memory leaks and tunes your workers too!
+
+-->
+
+## Turn on Rolling Restarts
+
+A rolling restart will kill each of your workers on a rolling basis. You set the frequency which it conducts the restart. This is a simple way to keep memory down as Ruby web programs generally increase memory usage over time. If you're using Heroku [it is difficult to measure RAM from inside of a container accurately](https://github.com/schneems/get_process_mem/issues/7), so it is recommended to use this feature or use a [log-drain-based worker killer](https://github.com/arches/whacamole). You can enable roling restarts by running:
+
+```ruby
+# config/puma.rb
+
+before_fork do
+  require 'puma_worker_killer'
+
+  PumaWorkerKiller.enable_rolling_restart # Default is every 6 hours
+end
+
+```
+
+or you can pass in the restart frequency:
+
+```ruby
+PumaWorkerKiller.enable_rolling_restart(12 * 3600) # 12 hours in seconds
+```
+
+Make sure if you do this to not accidentally call `PumaWorkerKiller.start` as well.
+
+## Enable Worker Killing
+
+If you're not running on a containerized platform you can try to detect the amount of memory you're using and only kill Puma workers when you're over that limit. It may allow you to go for longer periods of time without killing a worker however it is more error prone than rolling restarts. To enable measurement based worker killing put this in your `config/puma.rb`:
+
+```ruby
+# config/puma.rb
+
+before_fork do
+  require 'puma_worker_killer'
+
+  PumaWorkerKiller.start
+end
+```
+
+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 and spawn a fresh copy with a much smaller RAM footprint ASAP.
+
+## Troubleshooting
+
+When you boot your program locally you should see debug output:
+
+```
+[77773] Puma starting in cluster mode...
+[77773] * Version 3.1.0 (ruby 2.3.1-p112), codename: El Niño Winter Wonderland
+[77773] * Min threads: 0, max threads: 16
+[77773] * Environment: development
+[77773] * Process workers: 2
+[77773] * Phased restart available
+[77773] * Listening on tcp://0.0.0.0:9292
+[77773] Use Ctrl-C to stop
+[77773] PumaWorkerKiller: Consuming 54.34765625 mb with master and 2 workers.
+```
+
+If you don't see any `PumaWorkerKiller` output, make sure that you are running with multiple workers. PWK only functions if you have workers enabled, you should see something like this when Puma boots:
+
+```
+[77773] * Process workers: 2
+```
+
+If you've configured PWK's frequency try reducing it to a very low value
+
+
+## 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
+  config.rolling_restart_frequency = 12 * 3600 # 12 hours in seconds, or 12.hours if using Rails
+  config.reaper_status_logs = true # setting this to false will not log lines like:
+  # PumaWorkerKiller: Consuming 54.34765625 mb with master and 2 workers.
+
+  config.pre_term = -> (worker) { puts "Worker #{worker.inspect} being killed" }
+end
+PumaWorkerKiller.start
+```
+
+### pre_term
+
+`config.pre_term` will be called just prior to worker termination with the worker that is about to be terminated. This may be useful to use in keeping track of metrics, time of day workers are restarted, etc.
+
+By default Puma Worker Killer will emit a log when a worker is being killed
+
+```
+PumaWorkerKiller: Out of memory. 5 workers consuming total: 500 mb out of max: 450 mb. Sending TERM to pid 23 consuming 53 mb.
+```
+
+or
+
+```
+PumaWorkerKiller: Rolling Restart. 5 workers consuming total: 650mb mb. Sending TERM to pid 34.
+```
+
+However you may want to collect more data, such as sending an event to an error collection service like rollbar or airbrake. The `pre_term` lambda gets called before any worker is killed by PWK for any reason.
+
+### on_calculation
+
+`config.on_calculation` will be called every time Puma Worker Killer calculates memory usage (`config.frequency`). This may be useful for monitoring your total puma application memory usage, which can be contrasted with other application monitoring solutions.
+
+This callback lambda is given a single value for the amount of memory used.
+
+## Attention
+
+If you start puma as a daemon, to add puma worker killer config into puma config file, rather than into initializers:
+Sample like this: (in `config/puma.rb` file):
+
+```ruby
+before_fork do
+  PumaWorkerKiller.config do |config|
+    config.ram           = 1024 # mb
+    config.frequency     = 5    # seconds
+    config.percent_usage = 0.98
+    config.rolling_restart_frequency = 12 * 3600 # 12 hours in seconds, or 12.hours if using Rails
+  end
+  PumaWorkerKiller.start
+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
+```
+
+You may want to periodically restart all of your workers rather than simply killing your largest. To do that set:
+
+```ruby
+PumaWorkerKiller.rolling_restart_frequency = 12 * 3600 # 12 hours in seconds, or 12.hours if using Rails
+```
+
+By default PumaWorkerKiller will perform a rolling restart of all your worker processes every 6 hours. To disable, set to `false`.
+
+You may want to hide the following log lines: `PumaWorkerKiller: Consuming 54.34765625 mb with master and 2 workers.`. To do that set:
+
+```ruby
+PumaWorkerKiller.reaper_status_logs = false
+```
+
+Note: It is `true` by default.
+
+## License
+
+MIT
+
+## Feedback
+
+Open up an issue or ping me on twitter [@schneems](http://twitter.com/schneems).

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/gitlab-puma_worker_killer.gemspec

@@ -0,0 +1,28 @@
+# -*- 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          = "gitlab-puma_worker_killer"
+  gem.version       = PumaWorkerKiller::VERSION
+  gem.authors       = ["Richard Schneeman", "GitLab"]
+  gem.email         = ["richard.schneeman+rubygems@gmail.com", "kamil@gitlab.com"]
+  gem.description   = %q{ Kills pumas, the code kind }
+  gem.summary       = %q{ If you have a memory leak in your web code puma_worker_killer can keep it in check. }
+  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 "gitlab-puma",       ">= 2.7", "< 5"
+  gem.add_dependency "get_process_mem",   "~>  0.2"
+  gem.add_development_dependency "rack", "~> 1.6"
+  gem.add_development_dependency "wait_for_it", "~> 0.1"
+  gem.add_development_dependency "rake",  "~> 10.1"
+  gem.add_development_dependency "test-unit",  ">= 0"
+
+end

data/lib/puma_worker_killer.rb

@@ -0,0 +1,38 @@
+require 'get_process_mem'
+
+module PumaWorkerKiller
+  extend self
+
+  attr_accessor :ram, :frequency, :percent_usage, :rolling_restart_frequency, :reaper_status_logs, :pre_term, :on_calculation
+  self.ram           = 512  # mb
+  self.frequency     = 10   # seconds
+  self.percent_usage = 0.99 # percent of RAM to use
+  self.rolling_restart_frequency = 6 * 3600 # 6 hours in seconds
+  self.reaper_status_logs = true
+  self.pre_term = nil
+  self.on_calculation = nil
+
+  def config
+    yield self
+  end
+
+  def reaper(ram = self.ram, percent = self.percent_usage, reaper_status_logs = self.reaper_status_logs, pre_term = self.pre_term, on_calculation = self.on_calculation)
+    Reaper.new(ram * percent_usage, nil, reaper_status_logs, pre_term, on_calculation)
+  end
+
+  def start(frequency = self.frequency, reaper = self.reaper)
+    AutoReap.new(frequency, reaper).start
+    enable_rolling_restart(rolling_restart_frequency) if rolling_restart_frequency
+  end
+
+  def enable_rolling_restart(frequency = self.rolling_restart_frequency)
+    frequency = frequency + rand(0..10.0) # so all workers don't restart at the exact same time across multiple machines
+    AutoReap.new(frequency, RollingRestart.new).start
+  end
+end
+
+require 'puma_worker_killer/puma_memory'
+require 'puma_worker_killer/reaper'
+require 'puma_worker_killer/rolling_restart'
+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
+          sleep @timeout
+          @reaper.reap
+        end
+      end
+    end
+
+  end
+end

data/lib/puma_worker_killer/puma_memory.rb

@@ -0,0 +1,85 @@
+module PumaWorkerKiller
+  class PumaMemory
+    def initialize(master = nil)
+      @master  = master || get_master
+    end
+
+    def master
+      @master
+    end
+
+    def size
+      workers.size
+    end
+
+    def term_worker(worker)
+      worker.term
+    end
+
+    def term_largest_worker
+      largest_worker.term
+    #   Process.wait(largest_worker.pid)
+    # rescue Errno::ECHILD
+    end
+
+    def workers_stopped?
+      !running?
+    end
+
+    def running?
+      @master && workers.any?
+    end
+
+    def smallest_worker
+      smallest, _ = workers.to_a.first
+      smallest
+    end
+
+    def smallest_worker_memory
+      _, smallest_mem = workers.to_a.first
+      smallest_mem
+    end
+
+    def largest_worker
+      largest_worker, _ = workers.to_a.last
+      largest_worker
+    end
+
+    def largest_worker_memory
+      _, largest_memory_used = workers.to_a.last
+      largest_memory_used
+    end
+
+    # Will refresh @workers
+    def get_total(workers = set_workers)
+      master_memory = GetProcessMem.new(Process.pid).mb
+      worker_memory = workers.map {|_, mem| mem }.inject(&:+) || 0
+      worker_memory + master_memory
+    end
+    alias :get_total_memory :get_total
+
+    def workers
+      @workers || set_workers
+    end
+
+    private
+
+    def get_master
+      ObjectSpace.each_object(Puma::Cluster).map { |obj| obj }.first if defined?(Puma::Cluster)
+    end
+
+    # Returns sorted hash, keys are worker objects, values are memory used per worker
+    # sorted by memory ascending (smallest first, largest last)
+    def set_workers
+      workers = {}
+      @master.instance_variable_get("@workers").each do |worker|
+        workers[worker] = GetProcessMem.new(worker.pid).mb
+      end
+      if workers.any?
+        @workers = Hash[ workers.sort_by {|_, mem| mem } ]
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/puma_worker_killer/reaper.rb

@@ -0,0 +1,40 @@
+module PumaWorkerKiller
+  class Reaper
+    def initialize(max_ram, master = nil, reaper_status_logs = true, pre_term = nil, on_calculation = nil)
+      @cluster = PumaWorkerKiller::PumaMemory.new(master)
+      @max_ram = max_ram
+      @reaper_status_logs = reaper_status_logs
+      @pre_term = pre_term
+      @on_calculation = on_calculation
+    end
+
+    # used for tes
+    def get_total_memory
+      @cluster.get_total_memory
+    end
+
+    def reap
+      return false if @cluster.workers_stopped?
+      total = get_total_memory
+      @on_calculation.call(total) unless @on_calculation.nil?
+
+      if total > @max_ram
+        @cluster.master.log "PumaWorkerKiller: Out of memory. #{@cluster.workers.count} workers consuming total: #{total} mb out of max: #{@max_ram} mb. Sending TERM to pid #{@cluster.largest_worker.pid} consuming #{@cluster.largest_worker_memory} mb."
+
+        # Fetch the largest_worker so that both `@pre_term` and `term_worker` are called with the same worker
+        # Avoids a race condition where:
+        #   Worker A consume 100 mb memory
+        #   Worker B consume 99 mb memory
+        #   pre_term gets called with Worker A
+        #   A new request comes in, Worker B takes it, and consumes 101 mb memory
+        #   term_largest_worker (previously here) gets called and terms Worker B (thus not passing the about-to-be-terminated worker to `@pre_term`)
+        largest_worker = @cluster.largest_worker
+        @pre_term.call(largest_worker) unless @pre_term.nil?
+        @cluster.term_worker(largest_worker)
+
+      elsif @reaper_status_logs
+        @cluster.master.log "PumaWorkerKiller: Consuming #{total} mb with master and #{@cluster.workers.count} workers."
+      end
+    end
+  end
+end

data/lib/puma_worker_killer/rolling_restart.rb

@@ -0,0 +1,21 @@
+module PumaWorkerKiller
+  class RollingRestart
+    def initialize(master = nil)
+      @cluster = PumaWorkerKiller::PumaMemory.new(master)
+    end
+
+    # used for tes
+    def get_total_memory
+      @cluster.get_total_memory
+    end
+
+    def reap(wait_between_worker_kill = 60) # seconds
+      return false unless @cluster.running?
+      @cluster.workers.each do |worker, ram|
+        @cluster.master.log "PumaWorkerKiller: Rolling Restart. #{@cluster.workers.count} workers consuming total: #{ get_total_memory } mb. Sending TERM to pid #{worker.pid}."
+        worker.term
+        sleep wait_between_worker_kill
+      end
+    end
+  end
+end

data/lib/puma_worker_killer/version.rb

@@ -0,0 +1,3 @@
+module PumaWorkerKiller
+  VERSION = "0.1.1.gitlab.1"
+end

data/test/fixtures/big.ru

@@ -0,0 +1,10 @@
+load File.expand_path("../fixture_helper.rb", __FILE__)
+
+PumaWorkerKiller.start
+
+@memory = []
+10_000.times.each do
+  @memory << SecureRandom.hex
+end
+
+run HelloWorldApp

data/test/fixtures/config/puma_worker_killer_start.rb

@@ -0,0 +1,6 @@
+load File.expand_path("../../fixture_helper.rb", __FILE__)
+
+before_fork do
+  require 'puma_worker_killer'
+  PumaWorkerKiller.start
+end

data/test/fixtures/default.ru

@@ -0,0 +1,5 @@
+load File.expand_path("../fixture_helper.rb", __FILE__)
+
+PumaWorkerKiller.start
+
+run HelloWorldApp

data/test/fixtures/fixture_helper.rb

@@ -0,0 +1,25 @@
+require 'securerandom'
+
+require 'rack'
+require 'rack/server'
+
+require 'puma_worker_killer'
+
+PumaWorkerKiller.config do |config|
+  config.ram       = Integer(ENV['PUMA_RAM'])       if ENV['PUMA_RAM']
+  config.frequency = Integer(ENV['PUMA_FREQUENCY']) if ENV['PUMA_FREQUENCY']
+end
+
+puts "Frequency: #{ PumaWorkerKiller.frequency }" if ENV['PUMA_FREQUENCY']
+
+class HelloWorld
+  def response(env)
+    [200, {}, ['Hello World']]
+  end
+end
+
+class HelloWorldApp
+  def self.call(env)
+    HelloWorld.new.response(env)
+  end
+end

data/test/fixtures/on_calculation.ru

@@ -0,0 +1,8 @@
+load File.expand_path("../fixture_helper.rb", __FILE__)
+
+PumaWorkerKiller.config do |config|
+  config.on_calculation = lambda { |usage| puts("Current memory footprint: #{usage} mb") }
+end
+PumaWorkerKiller.start
+
+run HelloWorldApp

data/test/fixtures/pre_term.ru

@@ -0,0 +1,8 @@
+load File.expand_path("../fixture_helper.rb", __FILE__)
+
+PumaWorkerKiller.config do |config|
+  config.pre_term = lambda { |worker| puts("About to terminate worker: #{worker.inspect}") }
+end
+PumaWorkerKiller.start
+
+run HelloWorldApp

data/test/fixtures/rolling_restart.ru

@@ -0,0 +1,5 @@
+load File.expand_path("../fixture_helper.rb", __FILE__)
+
+PumaWorkerKiller.enable_rolling_restart(1) # 1 second
+
+run HelloWorldApp

data/test/puma_worker_killer_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+class PumaWorkerKillerTest < Test::Unit::TestCase
+
+  def test_starts
+    port     = 0 # http://stackoverflow.com/questions/200484/how-do-you-find-a-free-tcp-server-port-using-ruby
+    command  = "bundle exec puma #{ fixture_path.join("default.ru") } -t 1:1 -w 2 --preload --debug -p #{ port }"
+    options  = { wait_for: "booted", timeout: 5, env: { "PUMA_FREQUENCY" => 1 } }
+
+    WaitForIt.new(command, options) do |spawn|
+      assert_contains(spawn, "PumaWorkerKiller")
+    end
+  end
+
+  def test_without_preload
+    port     = 0 # http://stackoverflow.com/questions/200484/how-do-you-find-a-free-tcp-server-port-using-ruby
+    command  = "bundle exec puma #{ fixture_path.join("default.ru") } -t 1:1 -w 2 --debug -p #{ port } -C #{ fixture_path.join("config/puma_worker_killer_start.rb") }"
+    options  = { wait_for: "booted", timeout: 10, env: { "PUMA_FREQUENCY" => 1 } }
+
+    WaitForIt.new(command, options) do |spawn|
+      assert_contains(spawn, "PumaWorkerKiller")
+    end
+  end
+
+  def test_kills_large_app
+    file     = fixture_path.join("big.ru")
+    port     = 0
+    command  = "bundle exec puma #{ file } -t 1:1 -w 2 --preload --debug -p #{ port }"
+    options  = { wait_for: "booted", timeout: 5, env: { "PUMA_FREQUENCY" => 1, 'PUMA_RAM' => 1} }
+
+    WaitForIt.new(command, options) do |spawn|
+      assert_contains(spawn, "Out of memory")
+    end
+  end
+
+  def test_pre_term
+    file     = fixture_path.join("pre_term.ru")
+    port     = 0
+    command  = "bundle exec puma #{ file } -t 1:1 -w 2 --preload --debug -p #{ port }"
+    options  = { wait_for: "booted", timeout: 5, env: { "PUMA_FREQUENCY" => 1, 'PUMA_RAM' => 1} }
+
+    WaitForIt.new(command, options) do |spawn|
+      assert_contains(spawn, "Out of memory")
+      assert_contains(spawn, "About to terminate worker:") # defined in pre_term.ru
+    end
+  end
+
+  def test_on_calculation
+    file     = fixture_path.join("on_calculation.ru")
+    port     = 0
+    command  = "bundle exec puma #{ file } -t 1:1 -w 2 --preload --debug -p #{ port }"
+    options  = { wait_for: "booted", timeout: 5, env: { "PUMA_FREQUENCY" => 1, 'PUMA_RAM' => 1} }
+
+    WaitForIt.new(command, options) do |spawn|
+      assert_contains(spawn, "Out of memory")
+      assert_contains(spawn, "Current memory footprint:") # defined in on_calculate.ru
+    end
+  end
+
+  def assert_contains(spawn, string)
+    assert spawn.wait(string), "Expected logs to contain '#{string}' but it did not, contents: #{ spawn.log.read }"
+  end
+
+  def test_rolling_restart
+
+    file     = fixture_path.join("rolling_restart.ru")
+    port     = 0
+    command  = "bundle exec puma #{ file } -t 1:1 -w 2 --preload --debug -p #{ port }"
+    puts command.inspect
+    options  = { wait_for: "booted", timeout: 15, env: { } }
+
+    WaitForIt.new(command, options) do |spawn|
+      assert_contains(spawn, "Rolling Restart")
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+Bundler.require
+
+require 'puma_worker_killer'
+require 'test/unit'
+require 'wait_for_it'
+
+def fixture_path
+  Pathname.new(File.expand_path("../fixtures", __FILE__))
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: gitlab-puma_worker_killer
+version: !ruby/object:Gem::Version
+  version: 0.1.1.gitlab.1
+platform: ruby
+authors:
+- Richard Schneeman
+- GitLab
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gitlab-puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: get_process_mem
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: wait_for_it
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: " Kills pumas, the code kind "
+email:
+- richard.schneeman+rubygems@gmail.com
+- kamil@gitlab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- gitlab-puma_worker_killer.gemspec
+- lib/puma_worker_killer.rb
+- lib/puma_worker_killer/auto_reap.rb
+- lib/puma_worker_killer/puma_memory.rb
+- lib/puma_worker_killer/reaper.rb
+- lib/puma_worker_killer/rolling_restart.rb
+- lib/puma_worker_killer/version.rb
+- test/fixtures/big.ru
+- test/fixtures/config/puma_worker_killer_start.rb
+- test/fixtures/default.ru
+- test/fixtures/fixture_helper.rb
+- test/fixtures/on_calculation.ru
+- test/fixtures/pre_term.ru
+- test/fixtures/rolling_restart.ru
+- 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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: If you have a memory leak in your web code puma_worker_killer can keep it
+  in check.
+test_files:
+- test/fixtures/big.ru
+- test/fixtures/config/puma_worker_killer_start.rb
+- test/fixtures/default.ru
+- test/fixtures/fixture_helper.rb
+- test/fixtures/on_calculation.ru
+- test/fixtures/pre_term.ru
+- test/fixtures/rolling_restart.ru
+- test/puma_worker_killer_test.rb
+- test/test_helper.rb