stalin 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1895ae07adb3fd17811e68a5762343a42a424c55
+  data.tar.gz: d703399879596243653ed8d4b2a1380fdbc64890
+SHA512:
+  metadata.gz: fec5772f43ae44d775b5fce828f47d64555423eb2f271bcee8a006af8aeb0c53127b6d1091b840e85442c393d7cb41f4cc65aad7a363c7e1dfcfc4bf11736948
+  data.tar.gz: 1753c88baab75f9e0a77f1427b00f2f0d3194b973fcde1886f1d3eb4ef7d67ba7d68716d8e15595dc0696a2f4b9855d136c99d671e72623da501b95f6269bc7b

data/AUTHORS

@@ -0,0 +1,4 @@
+Kazuki Ohta <kazuki.ohta _at_ gmail.com>
+Sadayuki FURUHASHI <frsyuki _at_ gmail.com>
+Jonathan Clem <jonathan _at_ jclem.net>
+Tony Spataro <xeger _at_ xeger.net>

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+Release 0.0.1 - 2015/02/09
+  * initial fork of unicorn-worker-killer

data/LICENSE

@@ -0,0 +1,93 @@
+===== Stalin License
+
+Copyright (c) 2015 Tony Spataro
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Stalin is derived from https://github.com/kzk/unicorn-worker-killer
+including some code which was copied verbatim. The licensing
+information for unicorn-worker-killer is reproduced below.
+
+===== unicorn-worker-killer license
+
+Unicorn is copyrighted free software by all contributors, see logs in
+revision control for names and email addresses of all of them.
+
+You can redistribute it and/or modify it under either the terms of the
+GNU General Public License (GPL) as published by the Free Software
+Foundation (FSF), version {3.0}[http://www.gnu.org/licenses/gpl-3.0.txt]
+or version {2.0}[http://www.gnu.org/licenses/gpl-2.0.txt]
+or the Ruby-specific license terms (see below).
+
+The unicorn project leader (Eric Wong) reserves the right to add future
+versions of the GPL (and no other licenses) as published by the FSF to
+the licensing terms.
+
+=== Ruby-specific terms (if you're not using the GPLv2 or GPLv3)
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise make them
+       Freely Available, such as by posting said modifications to Usenet or an
+       equivalent medium, or by allowing the author to include your
+       modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict with
+       standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+       together with instructions (in the manual page or equivalent) on where
+       to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of the
+       software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+  5. The scripts and library files supplied as input to or produced as
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them,
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.md

@@ -0,0 +1,48 @@
+# stalin
+
+Given Ruby's proclivity for heap fragmentation, Web application worker processes tend to exhaust
+all available memory unless the server is restarted periodically. When all of the workers restart
+at once, downtime or bad request throughput may result.
+
+Stalin is a gem that gradually kills your workers before they cause swapping, resulting in better
+availability for your application. Its design goals are modularity and compatibility with a range
+of platforms and app servers.
+
+Metrics include:
+  - Resident Set Size (RSS)
+
+Data sources include:
+  - Linux ProcFS
+  - Generic ps
+
+Supported app servers include:
+  - Rainbows (via Rack middleware + SIGQUIT) 
+  - Unicorn (via Rack middleware + SIGQUIT)
+
+(As you can see, we are far short of our _goal_ to support many servers! More to come as needed;
+I'm happy to take your contributions.)
+
+# Installation
+
+Just include stalin in your Gemfile.
+
+    gem 'stalin'
+
+# Usage
+
+Add these lines near the top of your `config.ru`
+
+    # Unicorn self-process killer
+    require 'stalin'
+
+    # Max memory size (RSS) per worker
+    mb = 1024**2
+    use Stalin::Adapter::Rack, (192*mb), (256*mb)
+
+# Tuning
+
+TODO
+
+# Special Thanks
+
+- [@kzk](http://github.com/kzk/) for the [unicorn-worker-killer] gem which this is derived from

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler/setup'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "stalin"
+  gem.homepage = "https://github.com/xeger/stalin"
+  gem.license = "MIT"
+  gem.summary = %Q{Kill rack }
+  gem.description = %Q{Kill Web application workers based on arbitrary conditions.}
+  gem.email = "xeger@xeger.net"
+  gem.authors = ["Tony Spataro"]
+  gem.files.exclude ".rspec"
+  gem.files.exclude "Gemfile*"
+  gem.files.exclude "fixtures/**/*"
+  gem.files.exclude "spec/**/*"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+CLEAN.include('pkg')

data/VERSION

@@ -0,0 +1 @@
+0.0.2

data/lib/stalin.rb

@@ -0,0 +1,10 @@
+module Stalin
+  # Exception that watchers raise when they are not supported on the current platform.
+  class Unsupported < NotImplementedError
+  end
+
+end
+
+require 'stalin/killer'
+require 'stalin/watcher'
+require 'stalin/adapter'

data/lib/stalin/adapter.rb

@@ -0,0 +1,7 @@
+module Stalin
+  module Adapter
+
+  end
+end
+
+require 'stalin/adapter/rack'

data/lib/stalin/adapter/rack.rb

@@ -0,0 +1,67 @@
+module Stalin::Adapter
+  # A low-tech but reliable solution that invokes stalin using Rack middleware.
+  # This is suitable for servers that handle SIGQUIT gracefully and spawn new
+  # worker processes as needed.
+  class Rack
+    # Conversion constant for human-readable memory amounts in log messages.
+    MB = Float(1024**2)
+
+    # Create a middleware instance.
+    #
+    # @param [#call] app
+    # @param [Integer] min lower-bound worker memory consumption before restart
+    # @param [Integer] max upper-bound worker memory consumption before restart
+    # @param [Integer] cycle how frequently to check memory consumption (# requests)
+    # @param [Boolean] verbose log extra information
+    def initialize(app, min=1024**3, max=2*1024**3, cycle=16, verbose=false)
+      @app     = app
+      @min     = min
+      @max     = max
+      @cycle   = cycle
+      @verbose = verbose
+    end
+
+    def call(env)
+      result = @app.call(env)
+
+      logger = logger_for(env)
+
+      begin
+        @lim     ||= @min + randomize(@max - @min + 1)
+        @req     ||= 0
+        @req     += 1
+
+        if @req % @cycle == 0
+          @req = 0
+          @watcher ||= ::Stalin::Watcher.new(Process.pid)
+          @killer  ||= ::Stalin::Killer.new(Process.pid)
+          if (used = @watcher.watch) > @lim
+            sig = @killer.kill
+            @watcher.watch
+            logger.info "stalin (pid: %d) send SIG%s; memory usage %.1f MB > %.1f MB" %
+                          [Process.pid, sig, used / MB, @lim / MB]
+            @cycle = 2
+          elsif @verbose
+            logger.info "stalin (pid: %d) soldiers on; memory usage %.1f MB < %.1f MB" %
+                           [Process.pid, used / MB, @lim / MB]
+          end
+        end
+      rescue Exception => e
+        logger.error "stalin (pid: %d) ERROR %s: %s (%s)" %
+                      [Process.pid, e.class.name, e.message, e.backtrace.first]
+      end
+
+      result
+    end
+
+    private
+
+    def randomize(integer)
+      RUBY_VERSION > "1.9" ? Random.rand(integer.abs) : rand(integer)
+    end
+
+    def logger_for(env)
+      env['rack.logger'] || (@logger ||= Logger.new(STDERR))
+    end
+  end
+end

data/lib/stalin/killer.rb

@@ -0,0 +1,33 @@
+module Stalin
+  # Kill a process by sending SIGQUIT several times, then SIGTERM, and finally SIGKILL.
+  class Killer
+    # Number of cumulative tries to send SIGQUIT before we escalate to SIGTERM
+    MAX_QUIT = 10
+    # Number of cumulative tries before we escalate to SIGKILL
+    MAX_TERM = 15
+
+    # @param [Integer] pid target process ID
+    def initialize(pid)
+      @pid = pid
+      @tries = 0
+    end
+
+    # Try to kill the target process by sending it a shutdown signal.
+    #
+    # @return [:QUIT,:TERM,:KILL] name of signal that we sent
+    def kill
+      case @tries
+      when (0...MAX_QUIT)
+        sig = :QUIT
+      when (MAX_QUIT...MAX_TERM)
+        sig = :TERM
+      else
+        sig = :KILL
+      end
+
+      @tries += 1
+      Process.kill(sig, @pid)
+      sig
+    end
+  end
+end

data/lib/stalin/watcher.rb

@@ -0,0 +1,22 @@
+module Stalin
+  module Watcher
+    def self.new(pid)
+      it = nil
+
+      constants.each do |konst|
+        begin
+          konst = const_get(konst)
+          it = konst.new(pid)
+          break
+        rescue Stalin::Unsupported
+          next
+        end
+      end
+
+      it || raise(Stalin::Unsupported, "No compatible Watcher was found among #{constants}")
+    end
+  end
+end
+
+require 'stalin/watcher/linux_proc_statm'
+require 'stalin/watcher/unix_ps'

data/lib/stalin/watcher/linux_proc_statm.rb

@@ -0,0 +1,30 @@
+module Stalin::Watcher
+  # Watcher that uses procfs (specifically /proc/<pid>/statm) to determine memory usage.
+  class LinuxProcStatm
+    # @raise [Stalin::Unsupported] if watcher cannot be instantiated on current platform
+    # @param [Integer] pid target process ID
+    def initialize(pid)
+      @statm = "/proc/%d/statm" % [pid]
+      raise Stalin::Unsupported, "Unreadable or nonexistent file: #{@statm}" unless File.readable?(@statm)
+
+      page_size = `getconf PAGESIZE`
+      @page_size = Integer(page_size) rescue nil
+      raise Stalin::Unsupported, "Cannot determine page size: #{page_size}" unless $?.success? && @page_size.kind_of?(Integer)
+    end
+
+    # Report on memory usage.
+    #
+    # @return [Integer,nil] target process' memory usage in bytes, nil if process not found
+    def watch
+      vsz, rss, shared = File.read(@statm).split(' ')
+      vsz              = Integer(vsz) * @page_size
+      rss              = Integer(rss) * @page_size
+      shared           = Integer(shared) * @page_size
+
+      rss
+    rescue SystemCallError
+      # assume any failure means that process has gone away
+      nil
+    end
+  end
+end

data/lib/stalin/watcher/unix_ps.rb

@@ -0,0 +1,33 @@
+module Stalin::Watcher
+  class UnixPs
+    # @raise [Stalin::Unsupported] if watcher cannot be instantiated on current platform
+    # @param [Integer] pid target process ID
+    def initialize(pid)
+      begin
+        ps(Process.pid)
+      rescue StandardError => e
+        raise Stalin::Unsupported, "ps failed: #{e.message}"
+      end
+
+      @pid = pid
+    end
+
+    # Report on memory usage.
+    #
+    # @return [Integer,nil] target process' memory usage in bytes, nil if process not found
+    def watch
+      ps(@pid)
+    rescue ArgumentError
+      nil
+    end
+
+    private
+
+    # Report on memory usage.
+    #
+    # @return [Integer] target process' memory usage in bytes
+    def ps(pid)
+      Integer(`#{"ps -o rss= -p %d" % [pid]}`) * 1024
+    end
+  end
+end

data/stalin.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: stalin 0.0.2 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "stalin"
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib"]
+  s.authors = ["Tony Spataro"]
+  s.date = "2015-02-10"
+  s.description = "Kill Web application workers based on arbitrary conditions."
+  s.email = "xeger@xeger.net"
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.md"
+  ]
+  s.files = [
+    "AUTHORS",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "lib/stalin.rb",
+    "lib/stalin/adapter.rb",
+    "lib/stalin/adapter/rack.rb",
+    "lib/stalin/killer.rb",
+    "lib/stalin/watcher.rb",
+    "lib/stalin/watcher/linux_proc_statm.rb",
+    "lib/stalin/watcher/unix_ps.rb",
+    "stalin.gemspec"
+  ]
+  s.homepage = "https://github.com/xeger/stalin"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "2.2.2"
+  s.summary = "Kill rack"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<jeweler>, ["~> 2.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 3.0"])
+      s.add_development_dependency(%q<sinatra>, ["~> 1.4"])
+      s.add_development_dependency(%q<unicorn>, ["~> 4.8"])
+    else
+      s.add_dependency(%q<jeweler>, ["~> 2.0"])
+      s.add_dependency(%q<rspec>, ["~> 3.0"])
+      s.add_dependency(%q<sinatra>, ["~> 1.4"])
+      s.add_dependency(%q<unicorn>, ["~> 4.8"])
+    end
+  else
+    s.add_dependency(%q<jeweler>, ["~> 2.0"])
+    s.add_dependency(%q<rspec>, ["~> 3.0"])
+    s.add_dependency(%q<sinatra>, ["~> 1.4"])
+    s.add_dependency(%q<unicorn>, ["~> 4.8"])
+  end
+end
+

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: stalin
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Tony Spataro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: unicorn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.8'
+description: Kill Web application workers based on arbitrary conditions.
+email: xeger@xeger.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- AUTHORS
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/stalin.rb
+- lib/stalin/adapter.rb
+- lib/stalin/adapter/rack.rb
+- lib/stalin/killer.rb
+- lib/stalin/watcher.rb
+- lib/stalin/watcher/linux_proc_statm.rb
+- lib/stalin/watcher/unix_ps.rb
+- stalin.gemspec
+homepage: https://github.com/xeger/stalin
+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: Kill rack
+test_files: []