snipr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA512: 
+  metadata.gz: 0431e21ba622f828ce67bbef64c3ea2bd900e9dac1e6069dbeb88feb0389c6837f9dd1a5654918dd3a2059b69ce52c836927522ea5f1a6c4aa5bec1f74d51bd3
+  data.tar.gz: f2f45b0e24e2576610dd7883ac64b9828dd2ef6586320399d77832b54a597183a297e11e18a252a93130179c86cb11da4d7c610b9d4b90d5acb6a86afb5421ea
+SHA1: 
+  metadata.gz: e4ba65cbad1a2cd5acb11c37237b5f843328a176
+  data.tar.gz: 9ab5063ba228c17e50ab64634c58efea2fc6aee4

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.ruby-gemset

@@ -0,0 +1 @@
+snipr

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.8.7-p374

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in snipr.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Lance Woodson
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,44 @@
+# Snipr
+
+Tool to manage runaway processes.  More to be written later.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'snipr'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install snipr
+
+## Usage
+
+#### Culling Runaway Resque Workers
+```
+Usage: reap_resque_workers [options]
+
+Can be used to reap runaway resque workers that have exceeded too much memory use, CPU use, or time alive.
+By default, this sends USR1 to the parent worker process, which causes it to immediately kill the runaway
+child.  The parent will then spawn another child to continue work.
+
+Options:
+    -m, --memory [BYTES]             Workers using more than some bytes size of memory
+    -c, --cpu [PERCENTAGE]           workers using more than a percentage of CPU
+    -a, --alive [SECONDS]            Workers that have been alive for some length of time in seconds
+    -s, --signal [SIGNAL]            Signal to send to the worker's parent.  Defaults to USR1.
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/snipr/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/reap_resque_workers

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+require 'ostruct'
+require 'optparse'
+
+options = OpenStruct.new({
+  :signal => 'USR1'
+})
+
+parser = OptionParser.new do |config|
+  config.banner = "Usage: reap_resque_workers [options]"
+  config.separator ""
+  config.separator "Can be used to reap runaway resque workers " +
+                   "that have exceeded too much memory use, " +
+                   "CPU use, or time alive."
+  config.separator "By default, this sends USR1 to the parent worker " +
+                   "process, which causes it to immediately kill " +
+                   "the runaway"
+  config.separator "child.  The parent will then spawn another child to " +
+                   "continue work."
+  config.separator ""
+  config.separator "Options:"
+
+  desc = "Workers using more than some bytes size of memory"
+  config.on("-m", "--memory [BYTES]", desc) do |bytes|
+    options.bytes = bytes.to_i
+  end
+
+  desc = "workers using more than a percentage of CPU"
+  config.on("-c", "--cpu [PERCENTAGE]", desc) do |cpu|
+    options.cpu = cpu.to_f
+  end
+
+  desc = "Workers that have been alive for some length of time in seconds"
+  config.on("-a", "--alive [SECONDS]", desc) do |sec|
+    options.alive = sec.to_i
+  end
+
+  desc = "Signal to send to the worker's parent.  Defaults to USR1."
+  config.on("-s", "--signal [SIGNAL]", desc) do |signal|
+    options.signal = signal
+  end
+end.parse!
+
+# TODO remove me
+$: << 'lib'
+
+require 'snipr'
+output = Snipr::Output.new
+
+unless options.bytes || options.keys || options.alive
+  output.err("error - You must specify at least one of -m, -c or -a")
+  Kernel.exit(-1)
+end
+
+signaller = Snipr::ProcessSignaller.new do |signaller|
+  signaller.signal          options.signal
+  signaller.target_parent   true
+  signaller.include         /resque/
+  signaller.include         /processing/i
+  signaller.exclude         /scheduler/i
+
+  if options.bytes
+    signaller.memory_greater_than(options.bytes)
+  end
+
+  if options.cpu
+    signaller.cpu_greater_than(options.cpu)
+  end
+
+  if options.alive
+    signaller.alive_longer_than(options.alive)
+  end
+
+  signaller.on_no_processes do
+    output.info("no runaways found")
+  end
+
+  signaller.after_signal do |signal, process|
+    msg = "sent #{signal} to worker #{process.ppid} to gracefully shutdown " +
+          "child #{process.pid}"
+    output.info(msg)
+
+    msg = "memory:#{process.memory} cpu:#{process.cpu} time_alive: " +
+          "#{process.seconds_alive} command: #{process.command}"
+    output.info(msg)
+  end
+
+  signaller.on_error do |error, signal, process|
+    raise error
+    if signal && process
+      output.err("error sending #{signal} to #{process.ppid} to gracefully shutdown #{process.pid}: #{error}")
+    else
+      output.err("error: #{error}")
+      Kernel.exit(-1)
+    end
+  end
+end
+
+signaller.send_signals

data/lib/snipr.rb

@@ -0,0 +1,24 @@
+require 'open3'
+
+require 'snipr/version'
+require 'snipr/output'
+require 'snipr/process_locator'
+require 'snipr/process_signaller'
+
+module Snipr
+  ##
+  # Error raised when a system command fails
+  class ExecError < StandardError; end
+
+  ##
+  # Executes a command, returning the output as
+  # an array of lines.  Raises an ExecError if the
+  # command did not execute cleanly.
+  def self.exec_cmd(command)
+    Open3.popen3(command) do |stdin, stdout, stderr|
+      err = stderr.read
+      raise ExecError, err unless err.empty?
+      stdout.read.split("\n")
+    end
+  end
+end

data/lib/snipr/output.rb

@@ -0,0 +1,27 @@
+require 'time'
+
+module Snipr
+  ##
+  # Class for writing to standard error & standard out in a
+  # uniform way.
+  class Output
+    ##
+    # Write a message prepended with an ISO8601 timestamp to
+    # STDOUT
+    def info(msg)
+      STDOUT.write("#{runtime} #{msg}\n")
+    end
+
+    ##
+    # Write a message prepndend with an ISO8601 timestamp to
+    # STDERR
+    def err(msg)
+      STDERR.write("#{runtime} #{msg}\n")
+    end
+
+    private
+    def runtime
+      Time.now.iso8601
+    end
+  end
+end

data/lib/snipr/process_locator.rb

@@ -0,0 +1,134 @@
+module Snipr
+  ##
+  # Simple data structure representing a kernel process
+  KernelProcess = Struct.new(:pid,:ppid,:memory,:cpu,:etime,:seconds_alive,:command)
+
+  ##
+  # Responsible for locating running processes and returning an array
+  # of KernelProcess objects that represent them.  Uses the output of
+  # ps to locate processes, so this only works on *nix.  Tested on
+  # RHEL 6.5 and Linux Mint
+  class ProcessLocator
+    DAY_SECONDS = 86400
+    HOUR_SECONDS = 3600
+    MINUTE_SECONDS = 60
+
+
+    attr_accessor :signal
+    attr_reader :includes, :excludes, :filters
+
+    def initialize
+      @includes = []
+      @excludes = []
+      @filters = []
+    end
+
+    ##
+    # Locates the processes that match all include patterns and do not
+    # match all exclude patterns
+    def locate
+      processes = includes.reduce(all_processes, &by_inclusion_patterns)
+      processes = excludes.reduce(processes, &by_exclusion_patterns)
+      processes = filters.reduce(processes, &by_filter)
+    end
+
+    ##
+    # Define a pattern that the command portion of the ps command must match to
+    # include the process.  Multiple patterns can be defined and all must be
+    # matched
+    def include(pattern)
+      includes << pattern
+    end
+
+    ##
+    # Define a pattern that the command portion of the ps command must match to
+    # exclude the process.  Multiple patterns can be defined and all will be
+    # rejected.
+    def exclude(pattern)
+      excludes << pattern
+    end
+
+    ##
+    # Define a size in bytes that processes must be greater than to be included
+    # in the result.
+    def memory_greater_than(bytes)
+      filter { |process| process.memory > bytes }
+    end
+
+    ##
+    # Define a cpu use percentage that processes must be greater than to be
+    # included in the result.
+    def cpu_greater_than(percent)
+      filter {|process| process.cpu > percent}
+    end
+
+    ##
+    # Define a time in seconds that processes must have been alive for longer
+    # than to be included in results
+    def alive_longer_than(sec)
+      filter {|process| process.seconds_alive > sec}
+    end
+
+    ##
+    # Define your own filter using a lambda that receives a KernelProcess object
+    # and returns true if the process should be included in results
+    def filter(&callable)
+      filters << callable
+    end
+
+    private
+    def clear!
+      @includes = []
+      @excludes = []
+    end
+
+    def by_inclusion_patterns
+      lambda {|processes, filter| processes.select(&match(filter))}
+    end
+
+    def by_exclusion_patterns
+      lambda {|processes, filter| processes.reject(&match(filter))}
+    end
+
+    def by_filter
+      lambda {|processes, filter| processes.select(&filter)}
+    end
+
+    def match(filter)
+      lambda {|process| process.command.match(filter)}
+    end
+
+    def all_processes
+      Snipr.exec_cmd('ps h -eo pid,ppid,size,%cpu,etime,cmd').map do |line|
+        pid, ppid, mem, cpu, etime, *cmd = line.split
+        cmd = cmd.join(" ")
+
+        KernelProcess.new(
+          pid.to_i,
+          ppid.to_i,
+          mem.to_i,
+          cpu.to_f,
+          etime,
+          parse_seconds(etime),
+          cmd
+        )
+      end
+    end
+
+    ##
+    # Parses etime, which is in the format dd-hh:mm:ss
+    # dd- will be omitted if the run time is < 24 hours
+    # hh: will be omitted if the run time is < 1 hour
+    def parse_seconds(etime)
+      time, days = etime.split("-").reverse
+      sec, min, hr = time.split(":").reverse
+
+      total = 0
+      total += days.to_i * DAY_SECONDS if days
+      total += hr.to_i * HOUR_SECONDS if hr
+      total += min.to_i * MINUTE_SECONDS if min
+      total += sec.to_i if sec
+      total
+    end
+  end
+end

data/lib/snipr/process_signaller.rb

@@ -0,0 +1,113 @@
+require 'forwardable'
+
+module Snipr
+  ##
+  # Class that can send signals to targetted processes or their
+  # parent processes and invoke callbacks around the actions.  Delegates
+  # process location to a ProcessLocator.  Is configured using a
+  # block on initialization as follows:
+  #
+  # signaller = ProcessSignaller.new do |signaller|
+  #   signaller.include       /resque/
+  #   signaller.exclude       /scheduler/
+  #   signaller.signal        "USR1"
+  #   signaller.target_parent false
+  #
+  #   signaller.on_no_processes do
+  #     puts "No processes"
+  #   end
+  #
+  #   signaller.before_signal do |signal, process|
+  #     puts "Sending #{signal} to #{process.pid}"
+  #   end
+  #
+  #   signaller.after_signal do |signal, process|
+  #     puts "Sent #{signal} to #{process.pid}"
+  #   end
+  #
+  #   signaller.on_error do |e, signal, process|
+  #     puts "Ooops, got #{e} sending #{signal} to #{process.pid}"
+  #   end
+  # end
+  #
+  # signaller.send_signals
+  #
+  class ProcessSignaller
+    extend Forwardable
+    def_delegators :locator, :include, :exclude, :memory_greater_than,
+                   :cpu_greater_than, :alive_longer_than, :filter
+
+    attr_reader :signal
+    attr_writer :locator
+
+    def initialize(&block)
+      @locator = ProcessLocator.new
+      on_no_processes {}
+      before_signal {}
+      after_signal {}
+      on_error {|e, process, signal| raise e}
+      block.call(self)
+    end
+
+    ##
+    # Send the specified signal to all located processes
+    def send_signals
+      processes = @locator.locate
+
+      if processes.empty?
+        @on_no_processes.call
+      else
+        processes.each do |process|
+          signal_process(process)
+        end
+      end
+    rescue StandardError => e
+      @on_error.call(e)
+    end
+
+    def signal(signal)
+      @signal = Signal.list[signal.to_s.upcase].tap do |sig|
+        unless sig
+          raise "'#{signal}' not found -- see http://ruby-doc.org/core-1.8.7/Signal.html#method-c-list"
+        end
+      end
+    end
+
+    def locator(locator=nil)
+      @locator ||= (locator || ProcessLocator.new)
+    end
+
+    def on_no_processes(&callback)
+      @on_no_processes = callback
+    end
+
+    def before_signal(&callback)
+      @before_signal = callback
+    end
+
+    def after_signal(&callback)
+      @after_signal = callback
+    end
+
+    def on_error(&callback)
+      @on_error = callback
+    end
+
+    def target_parent(flag=false)
+      @target_parent = flag
+    end
+
+    private
+    def signal_process(process)
+      @before_signal.call(@signal, process)
+      if @target_parent
+        Process.kill(@signal, process.ppid)
+      else
+        Process.kill(@signal, process.pid)
+      end
+      @after_signal.call(@signal, process)
+    rescue StandardError => e
+      @on_error.call(e, @signal, process)
+    end
+  end
+end

data/lib/snipr/version.rb

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

data/snipr.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'snipr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "snipr"
+  spec.version       = Snipr::VERSION
+  spec.authors       = ["Lance Woodson"]
+  spec.email         = ["lance@webmaneuvers.com"]
+  spec.summary       = %q{Take aim and fire at runaway processes using ruby}
+  spec.description   = <<-END
+Ruby classes and executables for targetting and sending signals to
+*nix processes that match/don't match command name patterns, memory
+use, cpu use and time alive
+  END
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+  spec.add_development_dependency "pry"
+end

data/spec/process_locator_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+module Snipr
+  describe ProcessLocator do
+    describe "#parse_seconds" do
+      let(:result) {subject.send(:parse_seconds, etime)}
+
+      describe "with a time spanning days" do
+        let(:etime) {"1-02:03:04"}
+        it "should calculate the correct number of seconds" do
+          expect(result).to eq(93784)
+        end
+      end
+
+      describe "with a time spanning hours" do
+        let(:etime) {"2:03:04"}
+        it "should calculate the correct number of seconds" do
+          expect(result).to eq(7384)
+        end
+      end
+
+      describe "with a time spanning minutes" do
+        let(:etime) {"03:04"}
+        it "should calculate the correct number of seconds" do
+          expect(result).to eq(184)
+        end
+      end
+
+      describe "with a time spanning seconds" do
+        let(:etime) {"04"}
+        it "should calculate the correct number of seconds" do
+          expect(result).to eq(4)
+        end
+      end
+    end
+
+    describe "#locate" do
+      let(:ps_output) {File.read("spec/ps_output.txt").split("\n")}
+      before do
+        expect(Snipr).to receive(:exec_cmd).and_return(ps_output).at_least(:once)
+      end
+
+      it "should return an array of KernelProcess objects" do
+        process = subject.locate.select{|process| process.pid == 3552}.first
+        expect(process.pid).to eq(3552)
+        expect(process.ppid).to eq(4354)
+        expect(process.memory).to eq(1297860)
+        expect(process.cpu).to eq(8.7)
+        expect(process.etime).to eq("1-07:12:08")
+        expect(process.seconds_alive).to eq(112328)
+        expect(process.command).to eq("resque-1.24.1: Processing foo since 1410077129 [FooJob]")
+      end
+
+      describe "when no processes match filters" do
+        it "should return an empty array" do
+          subject.include /thereisnoinputwiththisstring/
+          expect(subject.locate).to be_empty
+        end
+      end
+
+      describe "when a single include is specified" do
+        it "should return all processes that match the include pattern" do
+          subject.include /Processing/
+          expect(subject.locate.size).to eq(20)
+        end
+      end
+
+      describe "when multiple includes are specified" do
+        it "should return all processses that match all include patterns" do
+          subject.include /Processing/
+          subject.include /Delayed Items/
+          expect(subject.locate.size).to eq(1)
+        end
+      end
+
+      describe "when a single exclude is specified" do
+        it "should return all processes not matching the exclude pattern" do
+          subject.exclude /grep/
+          expect(subject.locate.size).to eq(52)
+        end
+      end
+
+      describe "when multiple excludes are specified" do
+        it "should return all processes that don't match all exclude patterns" do
+          subject.exclude /grep/
+          subject.exclude /scheduler/
+          expect(subject.locate.size).to eq(51)
+        end
+      end
+
+      describe "when filtering processes by memory greater than" do
+        it "should return only processes using memory greater than the specified amount" do
+          subject.memory_greater_than(1000000000)
+          expect(subject.locate.size).to eq(1)
+          expect(subject.locate.first.pid).to eq(32178)
+        end
+      end
+
+      describe "when filtering processes by cpu greater than" do
+        it "should return only processes using cpu greater than the specified amount" do
+          subject.cpu_greater_than(90.0)
+          expect(subject.locate.size).to eq(1)
+          expect(subject.locate.first.pid).to eq(6337)
+        end
+      end
+
+      describe "when filtering processes by alive longer than" do
+        it "should return only processes that have been alive longer than the specified amount" do
+          subject.alive_longer_than(31449600)
+          expect(subject.locate.size).to eq(1)
+          expect(subject.locate.first.pid).to eq(28309)
+        end
+      end
+
+      describe "when filtering by a custom filter" do
+        it "should return only processes that match the filter" do
+          subject.filter { |process| process.pid % 2 == 0 }
+          expect(subject.locate.size).to eq(24)
+        end
+      end
+    end
+  end
+end

data/spec/process_signaller_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Snipr
+  describe ProcessSignaller do
+    let(:signal) {Signal.list["USR1"]}
+    let(:ps_output) {File.read("spec/ps_output.txt").split("\n")}
+    let(:checkins) {OpenStruct.new}
+    subject do
+      ProcessSignaller.new do |signaller|
+        signaller.include /resque/i
+        signaller.signal  "USR1"
+
+        signaller.on_no_processes do
+          checkins.on_no_processes = true
+        end
+
+        signaller.before_signal do |signal, process|
+          checkins.before_signal = "#{signal} > #{process.pid}"
+        end
+
+        signaller.after_signal do |signal, process|
+          checkins.after_signal = "#{signal} > #{process.pid}"
+        end
+
+        signaller.on_error do |exc, signal, process|
+          msg = "#{exc}"
+          if signal && process
+            msg += " #{signal} > #{process.pid}"
+          end
+          checkins.on_error = msg
+        end
+      end
+    end
+
+    describe "#signal" do
+      it "should raise an error if the signal is not defined by the system" do
+        expect{subject.signal("AJDKASDJKLASD")}.to raise_error
+      end
+
+      it "should assign the numeric value of the signal as defined by the system" do
+        expect(subject.signal("USR1")).to eq(Signal.list["USR1"])
+      end
+    end
+
+    describe "#signal" do
+      context "when there is a general failure" do
+        let(:locator) {subject.instance_variable_get(:@locator)}
+
+        it "should invoke the on_error callback" do
+          expect(locator).to receive(:locate).and_raise('Ouch!')
+          subject.send_signals
+          expect(checkins.on_error).to eq("Ouch!")
+        end
+      end
+
+      context "when no processes found" do
+        before {subject.exclude /resque/i}
+        it "should invoke the on_no_processes callback" do
+          subject.send_signals
+          expect(checkins.on_no_processes).to be_truthy
+        end
+      end
+
+      context "when process is found" do
+        before do
+          expect(Snipr).to receive(:exec_cmd).and_return(ps_output).at_least(:once)
+          subject.cpu_greater_than(90)
+        end
+
+        context "targetting the process itself" do
+          it "should send the appropriate signal to the process and call callbacks" do
+            expect(Process).to receive(:kill).with(signal, 6337)
+            subject.send_signals
+            expect(checkins.before_signal).to eq("#{signal} > 6337")
+            expect(checkins.after_signal).to eq("#{signal} > 6337")
+          end
+        end
+        
+        context "targetting the parent process" do
+          it "should send the appropriate signal to the parent process and call callbacks" do
+            subject.target_parent true
+            expect(Process).to receive(:kill).with(signal, 4347)
+            subject.send_signals
+            expect(checkins.before_signal).to eq("#{signal} > 6337")
+            expect(checkins.after_signal).to eq("#{signal} > 6337")
+          end
+        end
+
+        context "when encountering an error signalling a process" do
+          it "should call the on_error callback" do
+            expect(Process).to receive(:kill).with(signal, 6337).and_raise('Ouch!')
+            subject.send_signals
+            expect(checkins.on_error).to eq("Ouch! #{signal} > 6337")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/ps_output.txt

@@ -0,0 +1,53 @@
+ 3552  4354 1297860 8.7 1-07:12:08 resque-1.24.1: Processing foo since 1410077129 [FooJob]
+ 4236     1 1169412 0.0 3-12:52:29 resque-1.24.1: Waiting for bar,bar
+ 4238     1 1191864 0.0 3-12:52:29 resque-1.24.1: Waiting for foo,bar
+ 4241     1 1192064 0.0 3-12:52:29 resque-1.24.1: Waiting for foo,bar
+ 4245     1 1184716 0.2 3-12:52:29 resque-1.24.1: Forked 28309 at 1410084369
+ 4248     1 1206600 0.3 3-12:52:29 resque-1.24.1: Forked 28778 at 1410189413
+ 4250     1 1198872 0.2 3-12:52:29 resque-1.24.1: Forked 32153 at 1410189457
+ 4253     1 1202312 0.3 3-12:52:29 resque-1.24.1: Forked 31818 at 1410189453
+ 4257     1 1194072 0.4 3-12:52:29 resque-1.24.1: Forked 17477 at 1410188882
+ 4259     1 1188480 0.0 3-12:52:29 resque-1.24.1: Waiting for foo,bar
+ 4263     1 1188872 0.0 3-12:52:29 resque-1.24.1: Waiting for foo,bar
+ 4265     1 1189032 0.0 3-12:52:29 resque-1.24.1: Waiting for foo,bar
+ 4269     1 1182676 0.1 3-12:52:29 resque-1.24.1: Forked 29640 at 1410189424
+ 4271     1 1195432 0.2 3-12:52:29 resque-1.24.1: Forked 32035 at 1410189455
+ 4274     1 1181816 0.1 3-12:52:29 resque-1.24.1: Forked 31915 at 1410189454
+ 4277     1 1188152 0.1 3-12:52:28 resque-1.24.1: Forked 32038 at 1410189455
+ 4280     1 1179444 0.1 3-12:52:28 resque-1.24.1: Forked 30789 at 1410185297
+ 4284     1 1169100 0.0 3-12:52:28 resque-1.24.1: Waiting for baz
+ 4293     1 1183856 0.0 3-12:52:28 resque-1.24.1: Waiting for baz
+ 4301     1 1170028 0.0 3-12:52:28 resque-1.24.1: Waiting for baz
+ 4309     1 1155112 0.0 3-12:52:28 resque-1.24.1: Waiting for baz
+ 4316     1 1188900 0.0 3-12:52:28 resque-1.24.1: Waiting for baz
+ 4321     1 1196844 0.3 3-12:52:28 resque-1.24.1: Forked 7229 at 1410131675
+ 4324     1 1157052 0.3 3-12:52:28 resque-1.24.1: Forked 28474 at 1410189411
+ 4326     1 1179852 0.1 3-12:52:28 resque-1.24.1: Forked 27462 at 1410189396
+ 4337     1 1202044 0.3 3-12:52:28 resque-1.24.1: Forked 32178 at 1410189457
+ 4340     1 1202976 0.3 3-12:52:27 resque-1.24.1: Forked 31662 at 1410189012
+ 4347     1 1163824 0.4 3-12:52:27 resque-1.24.1: Forked 6337 at 1410189132
+ 4351     1 1163120 0.2 3-12:52:27 resque-1.24.1: Forked 22400 at 1410189331
+ 4354     1 1196480 0.2 3-12:52:27 resque-1.24.1: Forked 3552 at 1410077129
+ 4357     1 1163572 0.3 3-12:52:27 resque-1.24.1: Forked 8356 at 1410189171
+ 4361     1 1187620 0.0 3-12:52:27 resque-1.24.1: Waiting for foo
+ 4364     1 1169364 0.0 3-12:52:27 resque-1.24.1: Waiting for bar
+ 5585     1 972188 0.0  3-12:50:57 resque-scheduler-2.0.1: Processing Delayed Items                       
+ 6337  4347 1293004 99.9      05:26 resque-1.24.1: Processing foo since 1410189132 [FooJob]
+ 7229  4321 1292692 8.2   16:03:03 resque-1.24.1: Processing foo since 1410131675 [FooJob]
+ 8356  4357 1220988 19.0     04:47 resque-1.24.1: Processing foo since 1410189171 [FooJob]
+17477  4257 1194072 0.0      09:35 resque-1.24.1: Processing foo since 1410188882 [FooJob]
+22400  4351 1219712 3.3      02:06 resque-1.24.1: Processing foo since 1410189331 [FooJob]
+27462  4326 1194624 2.1      01:02 resque-1.24.1: Processing foo since 1410189396 [FooJob]
+28309  4245 1278328 7.1 364-05:11:28 resque-1.24.1: Processing foo since 1410084369 [FooJob]
+28474  4324 1182012 6.7      00:47 resque-1.24.1: Processing foo since 1410189410 [FooJob]
+28778  4248 1205572 4.9      00:45 resque-1.24.1: Processing foo since 1410189413 [FooJob]
+29640  4269 1189152 3.2      00:34 resque-1.24.1: Processing foo since 1410189424 [FooJob]
+30789  4280 1263476 6.7   01:09:21 resque-1.24.1: Processing foo since 1410185297 [FooJob]
+31662  4340 1286344 2.7      07:26 resque-1.24.1: Processing foo since 1410189012 [FooJob]
+31818  4253 1202312 4.6      00:05 resque-1.24.1: Processing foo since 1410189452 [FooJob]
+31915  4274 1181816 13.2     00:04 resque-1.24.1: Processing foo since 1410189454 [FooJob]
+32035  4271 1195432 13.5     00:02 resque-1.24.1: Processing foo since 1410189455 [FooJob]
+32038  4277 1188152 13.0     00:02 resque-1.24.1: Processing foo since 1410189455 [FooJob]
+32153  4250 1198872 21.0     00:01 resque-1.24.1: Processing foo since 1410189457 [FooJob]
+32178  4337 1001202048 0.0      00:00 resque-1.24.1: Processing bar since 1410189457 [BarJob]
+32189 28509   276  0.0       00:00 grep resque

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'rspec'
+require 'snipr'

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: snipr
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Lance Woodson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-09-08 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.6"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "10.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.1.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: pry
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id005 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: |
+  Ruby classes and executables for targetting and sending signals to
+  *nix processes that match/don't match command name patterns, memory
+  use, cpu use and time alive
+
+email: 
+- lance@webmaneuvers.com
+executables: 
+- reap_resque_workers
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/reap_resque_workers
+- lib/snipr.rb
+- lib/snipr/output.rb
+- lib/snipr/process_locator.rb
+- lib/snipr/process_signaller.rb
+- lib/snipr/version.rb
+- snipr.gemspec
+- spec/process_locator_spec.rb
+- spec/process_signaller_spec.rb
+- spec/ps_output.txt
+- spec/spec_helper.rb
+homepage: ""
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id005
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id005
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Take aim and fire at runaway processes using ruby
+test_files: 
+- spec/process_locator_spec.rb
+- spec/process_signaller_spec.rb
+- spec/ps_output.txt
+- spec/spec_helper.rb