puma_auto_tune 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ae138aad2de4355bff1e6ca326819e19e314833f
+  data.tar.gz: c4a2411f07991c426e532929e6822167bb18c671
+SHA512:
+  metadata.gz: 0232c6f1ed6ba0ce7c4070758c2a4d5fbc4bef59224183afe867c7659a1a74ab9c5f56bb0d78ac1279793fde4681b2048e516444e893d8e3d83c7a8e7b9b4471
+  data.tar.gz: 9f8812bb72f44646c69ef51ba7cec68c49bc37cdc95aa9a3cd9e51f8802916872f275279c6defa04c036598caa4201908126263410125e717a37a8f3b3940455

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+*.gem
+test/logs/

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,4 @@
+source "https://rubygems.org"
+
+gemspec
+

data/README.md

@@ -0,0 +1,200 @@
+# Puma Auto Tune
+
+[![Build Status](https://travis-ci.org/schneems/puma_auto_tune.png?branch=master)](https://travis-ci.org/schneems/puma_auto_tune)
+
+## What
+
+Performance without the (T)pain: `puma_auto_tune` will automatically adjust the number of [puma](https://github.com/puma/puma) workers to optimize the performance of your Ruby web application.
+
+## How
+
+Puma is a web server that allows you to adjust the amount of processes and threads it uses to process requests. At a very simple level the more processes and threads you have the more requests you can process concurrently. However this comes at a cost, more processes means more RAM and more threads means more CPU usage. You want to get as close to maxing out your resources without going over.
+
+The amount of memory and CPU your program consumes is also a factor of your code, as well as the amount of load it is under. Larger applications require more RAM. More requests mean more Ruby objects are created and garbage collected as your application generates web pages. Because of these factors, there is no one size fits all number for workers and threads, that's where Puma Auto Tune comes in.
+
+Run Puma Auto Tune in production under load, or in staging while simulating load with tools like [siege](http://www.joedog.org/siege-home/), [blitz.io](https://www.blitz.io/), or [flood.io](https://flood.io/) for a long enough time and we will compute and set your application numbers to maximize concurrent requests without going over your system limits.
+
+Currently Puma Auto Tune will optimize the number of workers (processes) based on RAM.
+
+## Install
+
+In your `Gemfile` add:
+
+```ruby
+gem 'puma_auto_tune'
+```
+
+Then run `$ bundle install`.
+
+## Use
+
+In your application call:
+
+```ruby
+PumaAutoTune.start
+```
+
+In Rails you could place this in an initializer such as `config/initializers/puma_auto_tune.rb`.
+
+Puma Auto Tune will attempt to find an ideal number of workers for your application.
+
+
+## Config
+
+You will need to configure your Puma Auto Tune to be aware of the maximum amount of RAM it can use.
+
+```ruby
+PumaAutoTune.config do |config|
+  config.ram = 512 # mb: available on system
+end
+```
+
+The default is `512` which matches the amount of ram available on a Heroku dyno. There are a few other advanced config options:
+
+```ruby
+PumaAutoTune.config do |config|
+  config.ram           = 1024 # mb: available on system
+  config.frequency     = 20   # seconds: the duration to check memory usage
+  config.reap_duration = 30   # seconds: how long `reap_cycle` will be run for
+end
+```
+
+To see defaults check out [puma_auto_tune.rb](lib/puma_auto_tune/puma_auto_tune.rb)
+
+
+## Hitting the Sweet Spot
+
+Puma Auto Tune is designed to tune the number of workers for a given application while it is running. Once you restart the program the tuning must start over. Once the algorithm has found the "sweet spot" you can maximize your application throughput by manually setting the number of `workers` that puma starts with. To help you do this Puma Auto Tune outputs semi-regular logs with formatted values.
+
+```
+puma.resource_ram_mb=476.6328125 puma.current_cluster_size=5
+```
+
+You can use a service such as [librato](https://metrics.librato.com/) to pull values out of your logs and graph them. When you see over time that your server settles on a given `cluster_size` you should set this as your default `puma -w $PUMA_WORKERS` if you're using the CLI to start your app or if you're using a `config/puma.rb` file:
+
+```ruby
+workers Integer(ENV['PUMA_WORKERS'] || 3)
+```
+
+## Puma Worker Killer
+
+Do not use with `puma_worker_killer` gem. Puma Auto Tune takes care of memory leaks in addition to tuning your puma workers.
+
+
+## How it Works: Tuning Algorithm (RAM)
+
+Simple by default, custom for true Puma hackers. The best way to think of the tuner is to start with the different states of memory consumption Puma can be under:
+
+- Unused RAM: we can add a worker
+- Memory leak (too much RAM usage): we should restart a worker
+- Too much RAM usage: we can remove a worker
+- Just right: No need to scale up or down.
+
+The algorithm will periodically get the total memory used by Puma and take action appropriately.
+
+#### Memory States: Unused RAM
+
+The memory of the smallest worker is recorded. If adding another worker does not put the total memory over the threshold then one will be added.
+
+#### Memory States: Memory Leak (too much RAM usage)
+
+When the amount of memory is more than that on the system, we assume a memory leak and restart the largest worker. This will trigger a check to determine if the result was due to a memory leak or because we have too many workers.
+
+#### Memory States: Too much RAM Usage
+
+After a worker has been restarted we will aggressively check for memory usage for a fixed period of time, default is 90 seconds(`PumaAutoTune.reap_reap_duration`). If memory goes over the limit, it is assumed that the cause is due to excess workers. The number of workers will be decreased by one. Puma Auto Tune will record the number of total workers that were present when we went over and set this as a new maximum worker number. After removing a process, Puma Auto Tune again checks for memory overages for the same duration and continues to decrement the number of workers until the total memory consumed is under the maximum.
+
+#### Memory States: Just Right
+
+Periodically the tuner will wake up and take note of memory usage. If it cannot scale up, and doesn't need to scale down it goes back to sleep.
+
+## Customizing the Algorithm
+
+Here's the fun part. You can write your own algorithm using the included hook system. The default algorithm is implemented as a series of [pre-defined hooks](lib/puma_auto_tune/defaults/ram/hooks.rb).
+
+You can over-write one or more of the hooks to add custom behavior. To define hooks call:
+
+```ruby
+PumaAutoTune.hooks(:ram) do |auto|
+
+end
+```
+
+Each hook has a name and can be over-written by calling `set` and passing in the symbol of the hook you wish to over-write. These are the default RAM hooks:
+
+- `:cycle`
+- `:reap_cycle`
+- `:out_of_memory`
+- `:under_memory`
+- `:add_worker`
+- `:remove_worker`
+
+
+Once you have the hook object you can use the `call` method to jump to other hooks.
+
+### Cycle
+
+This is the main event loop of your program. This code will be called every `PumaAutoTune.frequency` seconds. To over-write you can do this:
+
+
+```ruby
+PumaAutoTune.hooks(:ram) do |auto|
+  auto.set(:cycle) do |memory, master, workers|
+    if memory > PumaAutoTune.ram # mb
+      auto.call(:out_of_memory)
+    else
+      auto.call(:under_memory) if memory + workers.last.memory
+    end
+  end
+end
+```
+
+### Reap Cycle
+
+When you think you might run out of memory call the `reap_cycle`. The code in this hook will be called in a loop for `PumaAutoTune.reap_duration` seconds.
+
+```ruby
+PumaAutoTune.hooks do |auto|
+  auto.set(:reap_cycle) do |memory, master, workers|
+    if memory > PumaAutoTune.ram
+      auto.call(:remove_worker)
+    end
+  end
+end
+```
+
+## Add Worker
+
+Bumps up the worker size by one.
+
+```ruby
+PumaAutoTune.hooks do |auto|
+  auto.set(:add_worker) do |memory, master, workers|
+    auto.log "Cluster too small. Resizing to add one more worker"
+    master.add_worker
+    auto.call(:reap_cycle)
+  e
+end
+```
+
+Here we're calling `:reap_cycle` just in case we accidentally went over our memory limit after the increase.
+
+## Remove Worker
+
+Removes a worker. When `remove_worker` is called it will automatically set `PumaAutoTune.max_workers` to be one less than the current number of workers.
+
+```ruby
+PumaAutoTune.hooks do |hook|
+  auto.set(:remove_worker) do |memory, master, workers|
+    auto.log "Cluster too large. Resizing to remove one worker"
+    master.remove_worker
+    auto.call(:reap_cycle)
+  end
+end
+```
+
+In case removing one worker wasn't enough we call `reap_cycle` again. Once a worker has been flagged with `restart` it will report zero RAM usage even if it has not completely terminated.
+
+## 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_auto_tune.rb

@@ -0,0 +1,44 @@
+require 'get_process_mem'
+
+module PumaAutoTune; end
+
+require 'puma_auto_tune/version'
+require 'puma_auto_tune/master'
+require 'puma_auto_tune/worker'
+require 'puma_auto_tune/memory'
+
+
+module PumaAutoTune
+  INFINITY    = 1/0.0
+  RESOURCES = { ram: PumaAutoTune::Memory.new }
+
+  extend self
+
+  attr_accessor :ram, :max_workers, :frequency, :reap_duration
+  self.ram           = 512  # mb
+  self.max_workers   = INFINITY
+  self.frequency     = 10 # seconds
+  self.reap_duration = 90 # seconds
+
+
+  def self.config
+    yield self
+    self
+  end
+
+  def self.hooks(name = nil, resource = nil, &block)
+    @hooks       ||= {}
+    return @hooks if name.nil?
+    resource     ||= RESOURCES[name] || raise("no default resource specified for #{name.inspect}")
+    @hooks[name] ||= Hook.new(resource)
+    block.call(@hooks[name]) if block
+    @hooks[name]
+  end
+
+  def start
+    hooks.map {|name, hook| hook.auto_cycle}
+  end
+end
+
+
+require 'puma_auto_tune/hook'

data/lib/puma_auto_tune/defaults/ram/hooks.rb

@@ -0,0 +1,52 @@
+## This is the default algorithm
+PumaAutoTune.hooks(:ram) do |auto|
+  # Runs in a continual loop controlled by PumaAutoTune.frequency
+  auto.set(:cycle) do |memory, master, workers|
+    if memory > PumaAutoTune.ram # mb
+      auto.call(:out_of_memory)
+    else
+      auto.call(:under_memory) if memory + workers.last.memory
+    end
+  end
+
+  # Called repeatedly for `PumaAutoTune.reap_duration`.
+  # call when you think you may have too many workers
+  auto.set(:reap_cycle) do |memory, master, workers|
+    if memory > PumaAutoTune.ram
+      auto.call(:remove_worker)
+    end
+  end
+
+  # Called when puma is using too much memory
+  auto.set(:out_of_memory) do |memory, master, workers|
+    largest_worker = workers.last # ascending worker size
+    auto.log "Potential memory leak. Reaping largest worker", largest_worker_memory_mb: largest_worker.memory
+    largest_worker.restart
+    auto.call(:reap_cycle)
+  end
+
+  # Called when puma is not using all available memory
+  # PumaAutoTune.max_workers is tracked automatically by `remove_worker`
+  auto.set(:under_memory) do |memory, master, workers|
+    theoretical_max_mb = memory + workers.first.memory # assending worker size
+    if theoretical_max_mb < PumaAutoTune.ram && workers.size + 1 < PumaAutoTune.max_workers
+      auto.call(:add_worker)
+    else
+      auto.log "All is well"
+    end
+  end
+
+  # Called to add an extra worker
+  auto.set(:add_worker) do |memory, master, workers|
+    auto.log "Cluster too small. Resizing to add one more worker"
+    master.add_worker
+    auto.call(:reap_cycle)
+  end
+
+  # Called to remove 1 worker from pool. Sets maximum size
+  auto.set(:remove_worker) do |memory, master, workers|
+    auto.log "Cluster too large. Resizing to remove one worker"
+    master.remove_worker
+    auto.call(:reap_cycle)
+  end
+end

data/lib/puma_auto_tune/defaults/ram/wrappers.rb

@@ -0,0 +1,19 @@
+PumaAutoTune.hooks(:ram) do |auto|
+  auto.wrap(:reap_cycle) do |block|
+    Proc.new do |resource, master, workers|
+      ends_at = Time.now - PumaAutoTune.reap_duration
+      while Time.now < ends_at
+        sleep 1
+        block.call(*auto.args)
+      end
+    end
+  end
+
+  auto.wrap(:remove_worker) do |block|
+    Proc.new do |resource, master, workers|
+      resource.reset
+      PumaAutoTune.max_workers = workers.size - 1
+      block.call(*auto.args)
+    end
+  end
+end

data/lib/puma_auto_tune/hook.rb

@@ -0,0 +1,60 @@
+module PumaAutoTune
+  class Hook
+
+    def initialize(resource)
+      @resource = resource
+      @started  = Time.now
+      @hooks    = {}
+      @wraps    = {}
+    end
+
+    def define_hook(name, &block)
+      wrap_hook(name)
+      @hooks[name] = block
+    end
+    alias :set :define_hook
+
+    def call(name)
+      hook = @hooks[name] or raise "No such hook #{name.inspect}. Available: #{@hooks.keys.inspect}"
+      hook.call(self.args)
+    end
+
+    def wrap_hook(name, &block)
+      if block
+        @wraps[name] = block
+      else
+        if wrap = @wraps[name]
+          @hooks[name] = wrap.call(@hooks[name])
+        end
+      end
+    end
+    alias :wrap :wrap_hook
+
+    def auto_cycle
+      Thread.new do
+        loop do
+          sleep PumaAutoTune.frequency
+          call(:cycle) if @resource.master.running?
+        end
+      end
+    end
+
+    def log(msg, options = {})
+      elapsed = (Time.now - @started).ceil
+      msg     = ["PumaAutoTune (#{elapsed}s): #{msg}"]
+
+      options[@resource.name] = @resource.amount
+      options["current_cluster_size"] = @resource.workers.size
+      options.each { |k, v| msg << "puma.#{k.to_s.downcase}=#{v}" }
+      puts msg.join(" ")
+    end
+
+    def args
+      @resource.reset
+      [@resource.amount, @resource.master, @resource.workers]
+    end
+  end
+end
+
+require 'puma_auto_tune/defaults/ram/wrappers'
+require 'puma_auto_tune/defaults/ram/hooks'

data/lib/puma_auto_tune/master.rb

@@ -0,0 +1,45 @@
+module PumaAutoTune
+  class Master
+  def initialize(master = nil)
+      @master = master || get_master
+    end
+
+    def running?
+      @master && workers.any?
+    end
+
+    # https://github.com/puma/puma/blob/master/docs/signals.md#puma-signals
+    def remove_worker
+      send_signal("TTOU")
+    end
+
+    # https://github.com/puma/puma/blob/master/docs/signals.md#puma-signals
+    def add_worker
+      send_signal("TTIN")
+    end
+
+    # less cryptic interface
+    def send_signal(signal, pid = Process.pid)
+      Process.kill(signal, pid)
+    end
+
+    def memory
+      @memory
+    end
+    alias :mb :memory
+
+    def get_memory
+      @memory = ::GetProcessMem.new(Process.pid).mb
+    end
+
+    def workers
+      @master.instance_variable_get("@workers").map {|w| PumaAutoTune::Worker.new(w) }
+    end
+
+    private
+
+    def get_master
+      ObjectSpace.each_object(Puma::Cluster).map { |obj| obj }.first if defined?(Puma::Cluster)
+    end
+  end
+end

data/lib/puma_auto_tune/memory.rb

@@ -0,0 +1,41 @@
+require 'delegate'
+
+module PumaAutoTune
+
+  class Memory
+    attr_accessor :master, :workers
+
+    def initialize(master = PumaAutoTune::Master.new)
+      @master = master
+    end
+
+    def name
+      "resource_ram_mb"
+    end
+
+    def amount
+      @mb ||= begin
+        worker_memory = workers.map {|w| w.memory }.inject(&:+) || 0
+        worker_memory + @master.get_memory
+      end
+    end
+
+    def largest_worker
+      workers.last
+    end
+
+    def smallest_worker
+      workers.first
+    end
+
+    def workers
+      workers ||= @master.workers.sort_by! {|w| w.get_memory }
+    end
+
+    def reset
+      raise "must set master" unless @master
+      @workers      = nil
+      @mb           = nil
+    end
+  end
+end

data/lib/puma_auto_tune/version.rb

@@ -0,0 +1,3 @@
+module PumaAutoTune
+  VERSION = '0.0.1'
+end

data/lib/puma_auto_tune/worker.rb

@@ -0,0 +1,35 @@
+module PumaAutoTune
+  class Worker
+
+    def initialize(worker)
+      @worker = worker
+    end
+
+    def memory
+      @memory || get_memory
+    end
+    alias :mb :memory
+
+    def get_memory
+      @memory = if restarting?
+        0
+      else
+        ::GetProcessMem.new(self.pid).mb
+      end
+    end
+
+    def restarting?
+      @restarting
+    end
+
+
+    def restart
+      @restarting = true
+      @worker.term
+    end
+
+    def pid
+      @worker.pid
+    end
+  end
+end

data/puma_auto_tune.gemspec

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

data/test/fixtures/app.ru

@@ -0,0 +1,14 @@
+require 'rack'
+require 'rack/server'
+
+run Proc.new {|env| [200, {}, ['Hello World']] }
+
+
+
+require 'puma_auto_tune'
+
+PumaAutoTune.config do |config|
+  config.ram       = Integer(ENV['PUMA_RAM'])       if ENV['PUMA_RAM']
+  config.frequency = Integer(ENV['PUMA_FREQUENCY']) if ENV['PUMA_FREQUENCY']
+end
+PumaAutoTune.start

data/test/fixtures/config.rb

@@ -0,0 +1,11 @@
+threads Integer(ENV['MIN_THREADS']  || 1), Integer(ENV['MAX_THREADS'] || 16)
+workers Integer(ENV['PUMA_WORKERS'] || 3)
+
+port        ENV['PORT']     || 0 # using 0 tells the OS to grab first open port
+environment ENV['RACK_ENV'] || 'development'
+preload_app!
+
+Thread.abort_on_exception = true
+
+on_worker_boot do
+end

data/test/puma_auto_tune_test.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class PumaAutoTuneTest < Test::Unit::TestCase
+
+  def teardown
+    @puma.shutdown if @puma
+  end
+
+  def test_starts
+    @puma = PumaRemote.new.spawn
+    @puma.wait
+    assert_match "PumaAutoTune", @puma.log.read
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,50 @@
+Bundler.require
+
+require 'test/unit'
+
+class PumaRemote
+
+  attr_accessor :path, :frequency, :config, :log, :ram, :pid
+
+  def initialize(options = {})
+    @path      = options[:path]      || fixture_path("app.ru")
+    @frequency = options[:frequency] || 1
+    @config    = options[:config]    || fixture_path("config.rb")
+    @log       = options[:log]       || new_log_file
+    @ram       = options[:ram]       || 512
+  end
+
+  def wait
+    until log.read.match %r{booted}
+      sleep 1
+    end
+    sleep 1
+    self
+  end
+
+  def shutdown
+    if pid
+      Process.kill('TERM', pid)
+      Process.wait(pid)
+    end
+
+    FileUtils.remove_entry_secure log
+  end
+
+  def spawn
+    FileUtils.mkdir_p(log.dirname)
+    FileUtils.touch(log)
+    @pid = Process.spawn("exec env PUMA_FREQUENCY=#{frequency} PUMA_RAM=#{ram} bundle exec puma #{path} -C #{config} > #{log}")
+    self
+  end
+
+  def new_log_file
+    Pathname.new("test/logs/puma_#{rand(1...2000)}_#{Time.now.to_f}.log")
+  end
+
+  def fixture_path(name = nil)
+    path = Pathname.new(File.expand_path("../fixtures", __FILE__))
+    return path.join(name) if name
+    path
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: puma_auto_tune
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Richard Schneeman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !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: " Puma performance without all the (T)pain "
+email:
+- richard.schneeman+rubygems@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- lib/puma_auto_tune.rb
+- lib/puma_auto_tune/defaults/ram/hooks.rb
+- lib/puma_auto_tune/defaults/ram/wrappers.rb
+- lib/puma_auto_tune/hook.rb
+- lib/puma_auto_tune/master.rb
+- lib/puma_auto_tune/memory.rb
+- lib/puma_auto_tune/version.rb
+- lib/puma_auto_tune/worker.rb
+- my.log
+- puma_auto_tune.gemspec
+- test/fixtures/app.ru
+- test/fixtures/config.rb
+- test/puma_auto_tune_test.rb
+- test/test_helper.rb
+homepage: https://github.com/schneems/puma_auto_tune
+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.2
+signing_key: 
+specification_version: 4
+summary: ''
+test_files:
+- test/fixtures/app.ru
+- test/fixtures/config.rb
+- test/puma_auto_tune_test.rb
+- test/test_helper.rb