passenger_monitor 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8bd9f81728f7936c57c6b33e432dd01ac8c5fc05
+  data.tar.gz: 1e69bfc416b5f071d2e22ad3387281e2960b587a
+SHA512:
+  metadata.gz: 2e21c97df5604ecd32cc45e8305bb0430d59e111e90672312f74603dc8a168bcb5616dcfe2c28585d7ccfbae72ce1a2abfee80497641b181069e7310d0f4158d
+  data.tar.gz: f1d6f40ed111dff31334205ab22cf7ce0656c9210593217fa53b1cc7cd56f0db1f9e970a1e82d4e7d2091d6a82ec284de3530861e5f898659eb473a1de6bf6a0

data/.gitignore

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

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 VinSol
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Akshay Vishnoi
+
+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,68 @@
+# PassengerMonitor
+
+[![Code Climate](https://codeclimate.com/github/vinsol/passenger-monitor/badges/gpa.svg)](https://codeclimate.com/github/vinsol/passenger-monitor)
+
+This gem monitors passenger workers of your application and if the workers exceed the memory limit then it kills them (first gracefully, waits and then forcefully). It fetches the memory of the passenger workers from the system command `passenger-memory-stats`, checks the memory of each worker **concurrently (using threads)** and kills them if it finds them bloated. First, it kills the process gracefully and wait for it to die, if the process still appears then it kills it forcefully
+
+## Installation
+
+Add this line to your application's `Gemfile`:
+
+```ruby
+gem 'passenger-monitor'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install passenger-monitor
+
+## Usage
+
+The gem provides a service class which can be initialized to check the passenger workers.
+
+```ruby
+PassengerMonitor.run({:memory_limit=>"150",
+                      :log_file=>"passenger_config.log",
+                      :wait_time=>"15",
+                      :process_name_regex=>"passenger"})
+```
+
+**Parameters options:**
+1. **:memory_limit**: allowed memory limit for a passenger worker
+2. **:log_file**: the name of the log file
+3. **:wait_time**: the time to wait to kill the worker forcefully
+4. **:process_name_regex**: regex for the passenger worker of the application
+
+### Use Rake task
+It also provides a rake task which can be scheduled in cron tasks. To load tasks add following lines in your `Rakefile`:
+
+```ruby
+spec = Gem::Specification.find_by_name 'passenger_monitor'
+Dir.glob("#{spec.gem_dir}/lib/tasks/*.rake").each { |task_file| load task_file }
+```
+Now rake task `passenger:monitor` will be available. For custom configuration, send arguments in task in following order: `:memory_limit, :log_file, :wait_time, :process_name_regex`:
+
+```system
+bundle exec rake passenger:monitor[150,"passenger_config.log",15,"Passenger RubyApp"]
+```
+
+That's it, now never think of bloated passengers.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/passenger-monitor/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
+
+Credits
+-------
+
+[![vinsol.com: Ruby on Rails, iOS and Android developers](http://vinsol.com/vin_logo.png "Ruby on Rails, iOS and Android developers")](http://vinsol.com)
+
+Copyright (c) 2014 [vinsol.com](http://vinsol.com "Ruby on Rails, iOS and Android developers"), released under the New MIT License

data/Rakefile

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

data/lib/passenger_monitor/monitor.rb

@@ -0,0 +1,148 @@
+module PassengerMonitor
+  class Monitor
+    # Default allowed memory limit for a passenger worker (MB)
+    DEFAULT_MEMORY_LIMIT = 150 # in MB
+    # Default log file name
+    DEFAULT_LOG_FILE = 'passenger_monitoring.log'
+    # default waiting time after graceful kill attempt to kill process forcefully
+    DEFAULT_WAIT_TIME = 10 # in Seconds
+    # Passenger Process Name Regex
+    DEFAULT_PROCESS_NAME_REGEX = /Passenger RubyApp:/
+
+    # Initialize the service and apply a check on all passenger processes
+    # given `configurations` (defaults to `{}`)
+    #
+    # == Parameters:
+    # config::
+    #   Hash which includes the configurations keys i.e.
+    #     1. :memory_limit - allowed memory limit for a passenger worker
+    #     2. :log_file - the name of the log file
+    #     3. :wait_time - the time to wait to kill the worker forcefully
+    #     4. :process_name_regex - regex for the passenger worker of the application
+    #
+    def self.run(config = {})
+      new(config).check
+    end
+
+    # Sets memory limit, log file, wait time, process name regex and logger
+    #
+    def initialize(params = {})
+      @memory_limit = fetch_memory_limit(params)
+      @log_file = fetch_log_file(params)
+      @wait_time = fetch_wait_time(params)
+      @process_name_regex = fetch_process_name_regex(params)
+      @logger = Logger.new(@log_file)
+    end
+
+    # Checks memory of all the passenger processes and for bloadted workers
+    # it creates thread for each to kill it.
+    #
+    def check
+      @logger.info 'Checking bloated Passenger workers'
+
+      threads = []
+
+      passenger_workers_details.each_line do |line|
+        next unless (line =~ @process_name_regex)
+
+        pid, memory_usage =  extract_stats(line)
+
+        # If a given passenger process is bloated try to
+        # kill it gracefully and if it fails, force killing it
+        if bloated?(pid, memory_usage)
+          threads << Thread.new { self.handle_bloated_process(pid) }
+        end
+      end
+
+      threads.map(&:join)
+      @logger.info 'Finished checking for bloated Passenger workers'
+    end
+
+    # Handles bloated processes:
+    #
+    #   1. Kill it gracefully
+    #   2. Wait for the given time
+    #   3. if it still exists then kill it forcefully.
+    #
+    # == Parameters:
+    # pid::
+    #   Process ID.
+    #
+    def handle_bloated_process(pid)
+      kill(pid)
+      wait
+      kill!(pid) if process_running?(pid)
+    end
+
+    private
+
+    def fetch_memory_limit(params)
+      params.key?(:memory_limit) ? params[:memory_limit].to_f : DEFAULT_MEMORY_LIMIT
+    end
+
+    def fetch_log_file(params)
+      params.key?(:log_file) ? params[:log_file] : DEFAULT_LOG_FILE
+    end
+
+    def fetch_wait_time(params)
+      params.key?(:wait_time) ? params[:wait_time].to_i : DEFAULT_WAIT_TIME
+    end
+
+    def fetch_process_name_regex(params)
+      if params.key?(:process_name_regex)
+        Regexp.new(params[:process_name_regex].to_s)
+      else
+        DEFAULT_PROCESS_NAME_REGEX
+      end
+    end
+
+    # Fetches the stats of passenger-memory-stats from system.
+    # Using `env -i` to remove surrounding environment of bundle.
+    def passenger_workers_details
+      passenger_memory_status_path = `env -i which passenger-memory-stats`
+      `env -i #{ passenger_memory_status_path }`
+    end
+
+    # Checks if a given process is still running
+    # == Parameters:
+    # pid::
+    #   Process ID.
+    #
+    def process_running?(pid)
+      Process.getpgid(pid) != -1
+    rescue Errno::ESRCH
+      false
+    end
+
+    # Wait for process to be killed
+    def wait
+      @logger.error "Waiting for worker to shutdown..."
+      sleep(DEFAULT_WAIT_TIME)
+    end
+
+    # Kill it gracefully
+    def kill(pid)
+      @logger.error "Trying to kill #{pid} gracefully..."
+      Process.kill("SIGUSR1", pid)
+    end
+
+    # Kill it forcefully
+    def kill!(pid)
+      @logger.fatal "Force kill: #{pid}"
+      Process.kill("TERM", pid)
+    end
+
+    # Extracts pid and memory usage of a single Passenger worker
+    def extract_stats(line)
+      stats = line.split
+      return stats[0].to_i, stats[3].to_f
+    end
+
+    # Check if a given process is exceeding memory limit
+    def bloated?(pid, size)
+      bloated = size > @memory_limit
+      @logger.error "Found bloated worker: #{pid} - #{size}MB" if bloated
+      bloated
+    end
+  end
+end

data/lib/passenger_monitor/version.rb

@@ -0,0 +1,4 @@
+module PassengerMonitor
+  # Specifies the version of the gem.
+  VERSION = "0.0.1"
+end

data/lib/passenger_monitor.rb

@@ -0,0 +1,6 @@
+require 'passenger_monitor/monitor'
+require 'passenger_monitor/version'
+require 'logger'
+
+module PassengerMonitor
+end

data/lib/tasks/schedule.rake

@@ -0,0 +1,6 @@
+namespace :passenger do
+  desc "monitors passenger workers and kill bloated ones"
+  task :monitor, [:memory_limit, :log_file, :wait_time, :process_name_regex] do |t, args|
+    PassengerMonitor::Monitor.run args
+  end
+end

data/passenger-monitor.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'passenger_monitor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "passenger_monitor"
+  spec.version       = PassengerMonitor::VERSION
+  spec.authors       = ["Akshay Vishnoi"]
+  spec.email         = ["akshay.vishnoi@yahoo.com"]
+  spec.summary       = %q{Monitors passenger workers and kill bloated ones}
+  spec.description   = %q{Monitors passenger workers of your application and if
+    the workers exceeds the memory limit then it kills it (first gracefully, wait and
+    then forcefully).}
+  spec.homepage      = "https://github.com/vinsol/passenger-monitor"
+  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.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
+end

data/spec/passenger_monitor/monitor_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+def stub_system_command(response = '')
+  response = !response.empty? ? response : %Q{
+    25096  637.9 MB   165.4 MB  Passenger RubyApp:
+    25097  637.9 MB   100.4 MB  Passenger RubyApp:
+    25098  637.9 MB   120.4 MB  Passenger RubyApp:
+  }
+
+  allow_any_instance_of(PassengerMonitor::Monitor).to receive(:`).and_return(response)
+end
+
+def stub_process_status(response = -1)
+  allow(Process).to receive(:getpgid).and_return(response)
+end
+
+def stub_process_kill(method_name, signal, pid)
+  allow(Process).to receive(method_name).with(signal, pid)
+end
+
+def stub_wait(time = 10)
+  allow_any_instance_of(PassengerMonitor::Monitor).to receive(:sleep).with(time)
+end
+
+describe PassengerMonitor::Monitor do
+  let(:params) { {
+    :memory_limit=>"200",
+    :log_file=>"passenger_monitor.log",
+    :wait_time=>"15",
+    :process_name_regex=>"passenger"}}
+
+  let(:object_with_params) { PassengerMonitor::Monitor.new(params) }
+  let(:object_without_params) { PassengerMonitor::Monitor.new }
+
+  after do
+    ["passenger_monitoring.log", "passenger_monitor.log"].each do |file_name|
+      `rm #{file_name}`
+    end
+  end
+
+  describe 'Constants' do
+    it 'PassengerMonitor::Monitor::DEFAULT_MEMORY_LIMIT => 150' do
+      expect(PassengerMonitor::Monitor::DEFAULT_MEMORY_LIMIT).to eq(150)
+    end
+    it "PassengerMonitor::Monitor::DEFAULT_LOG_FILE => 'passenger_monitoring.log'" do
+      expect(PassengerMonitor::Monitor::DEFAULT_LOG_FILE).to eq('passenger_monitoring.log')
+    end
+    it 'PassengerMonitor::Monitor::DEFAULT_WAIT_TIME => 10' do
+      expect(PassengerMonitor::Monitor::DEFAULT_WAIT_TIME).to eq(10)
+    end
+    it 'PassengerMonitor::Monitor::DEFAULT_PROCESS_NAME_REGEX => /Passenger RubyApp:/' do
+      expect(PassengerMonitor::Monitor::DEFAULT_PROCESS_NAME_REGEX).to eq(/Passenger RubyApp:/)
+    end
+  end
+
+  describe 'Parameters' do
+    before do
+      stub_system_command
+    end
+
+    context 'when params are not provided' do
+      it 'picks up default configurations' do
+        expect(object_without_params.instance_variable_get(:@memory_limit)).to eq(150)
+        expect(object_without_params.instance_variable_get(:@log_file)).to eq('passenger_monitoring.log')
+        expect(object_without_params.instance_variable_get(:@wait_time)).to eq(10)
+        expect(object_without_params.instance_variable_get(:@process_name_regex)).to eq(/Passenger RubyApp:/)
+      end
+    end
+
+    context 'when params are provided' do
+      it 'picks up custom params' do
+        expect(object_with_params.instance_variable_get(:@memory_limit)).to eq(200)
+        expect(object_with_params.instance_variable_get(:@log_file)).to eq('passenger_monitor.log')
+        expect(object_with_params.instance_variable_get(:@wait_time)).to eq(15)
+        expect(object_with_params.instance_variable_get(:@process_name_regex)).to eq(/passenger/)
+      end
+    end
+  end
+
+  describe 'passenger workers' do
+    after do
+      PassengerMonitor::Monitor.run
+    end
+
+    context 'when workers are bloated' do
+      before do
+        stub_system_command
+        stub_process_kill(:kill, 'SIGUSR1', 25096)
+        stub_process_status
+        stub_wait
+      end
+
+      it 'tries to kill them gracefully' do
+        expect(Process).to receive(:kill).with('SIGUSR1', 25096)
+      end
+
+      it 'waits for the workers to get killed' do
+        expect_any_instance_of(PassengerMonitor::Monitor).to receive(:sleep).with(10)
+      end
+
+      context 'when workers are killed gracefully' do
+        it 'doesn\'t try to kill them forcefully' do
+          expect(Process).not_to receive(:kill).with('TERM', 25096)
+        end
+      end
+
+      context 'when workers are not killed gracefully' do
+        before do
+          stub_process_status(1)
+        end
+
+        it 'tries to kill them forcefully' do
+          expect(Process).to receive(:kill).with('TERM', 25096)
+        end
+      end
+    end
+
+    context 'when workers are not bloated' do
+      before { stub_system_command(%Q{
+        25096  637.9 MB   105.4 MB  Passenger RubyApp:
+        25098  637.9 MB   120.4 MB  Passenger RubyApp:
+        })
+      }
+
+      it 'doesn\'t create threads' do
+        expect(Thread).not_to receive(:new)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'passenger_monitor'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: passenger_monitor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Akshay Vishnoi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: |-
+  Monitors passenger workers of your application and if
+      the workers exceeds the memory limit then it kills it (first gracefully, wait and
+      then forcefully).
+email:
+- akshay.vishnoi@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/passenger_monitor.rb
+- lib/passenger_monitor/monitor.rb
+- lib/passenger_monitor/version.rb
+- lib/tasks/schedule.rake
+- passenger-monitor.gemspec
+- spec/passenger_monitor/monitor_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/vinsol/passenger-monitor
+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.4.3
+signing_key: 
+specification_version: 4
+summary: Monitors passenger workers and kill bloated ones
+test_files:
+- spec/passenger_monitor/monitor_spec.rb
+- spec/spec_helper.rb