check_passenger 0.1

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.sublime-workspace
+*.sublime-project

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Alvaro Redondo
+
+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,29 @@
+# CheckPassenger
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'check_passenger'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install check_passenger
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/check_passenger/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,8 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end

data/TODO.md

@@ -0,0 +1,12 @@
+# Release
+
+- README page.
+
+
+# Other
+
+- Option `all` to monitor all counters for all applications and globally,
+  without possibility to raise alerts.
+- PerfDatum class.
+- Option to set TTL used to estimate live processes.
+- Option to set TTL of cached data.

data/bin/check_passenger

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path('../lib', File.dirname(__FILE__))
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'thor'
+require 'check_passenger'
+require 'tmpdir'
+
+class CheckPassengerCLI < Thor
+  include CheckPassenger::NagiosCheck
+
+  class_option :app_name, aliases: 'n', banner: 'Limit check to application with APP_NAME'
+  class_option :cache, aliases: 'C', type: :boolean,
+                banner: 'Cache data to avoid fast successive calls to passenger-status'
+  class_option :debug, aliases: 'D', type: :boolean, banner: 'Debug mode'
+  class_option :dump, aliases: 'd', type: :boolean, banner: 'Dump passenger-status output on error'
+  class_option :include_all, aliases: 'a', type: :boolean,
+                banner: 'Also include counter for all running apps'
+  class_option :passenger_status_path, aliases: 'p', banner: 'Path to passenger-status command'
+
+  desc 'memory', 'Check Passenger memory'
+  option :warn, banner: 'Memory usage threshold to raise warning status', aliases: 'w'
+  option :crit, banner: 'Memory usage threshold to raise critical status', aliases: 'c'
+  def memory
+    run_check do
+      CheckPassenger::Check.memory(options)
+    end
+  end
+
+  desc 'processes', 'Check Passenger processes'
+  option :warn, aliases: 'w', banner: 'Process count threshold to raise warning status'
+  option :crit, aliases: 'c', banner: 'Process count threshold to raise critical status'
+  def processes
+    run_check do
+      CheckPassenger::Check.process_count(options)
+    end
+  end
+
+  desc 'live_processes', 'Check Passenger live processes'
+  option :warn, aliases: 'w', banner: 'Live process count threshold to raise warning status'
+  option :crit, aliases: 'c', banner: 'Live process count threshold to raise critical status'
+  def live_processes
+    run_check do
+      CheckPassenger::Check.live_process_count(options)
+    end
+  end
+
+  private
+
+  def dump_passenger_status_output(exception = nil)
+    passenger_status_output = nil
+
+    if exception and exception.respond_to?(:passenger_status_output)
+      passenger_status_output = exception.passenger_status_output
+    end
+
+    if passenger_status_output.nil? and CheckPassenger::Check.parsed_data
+      passenger_status_output = CheckPassenger::Check.parsed_data.passenger_status_output
+    end
+
+    if passenger_status_output
+      filename = 'passenger_status_output_dump-%s.txt' % Time.now.strftime('%Y%m%d%H%M%S')
+      dump_path = File.expand_path(filename, Dir.tmpdir)
+      File.open(dump_path, 'wb') { |file| file.write passenger_status_output }
+      return dump_path
+    else
+      return nil
+    end
+  end
+
+  def run_check
+    if options[:include_all] and options[:app_name]
+      raise ArgumentError, 'Data for all apps can only be included when monitoring a global counter'
+    end
+
+    output_status, output_data = yield
+    nagios_output(output_status, output_data)
+
+  rescue StandardError => e
+    if options[:debug] or options[:dump]
+      if dump_path = dump_passenger_status_output(e)
+        message = e.message + ' -- passenger-status output dumped to %s' % dump_path
+        e = e.class.new(message)
+      end
+    end
+
+    if options[:debug]
+      raise e
+    else
+      case e
+      when CheckPassenger::StatusOutputError
+        nagios_error('Passenger UNKNOWN - An error occurred while parsing passenger-status output: %s' % e.message)
+      else
+        nagios_error('Passenger UNKNOWN - %s (%s)' % [e.message, e.class.to_s])
+      end
+    end
+  end
+end
+
+CheckPassengerCLI.start(ARGV)

data/check_passenger.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'check_passenger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'check_passenger'
+  spec.version       = CheckPassenger::VERSION
+  spec.authors       = ['Alvaro Redondo']
+  spec.email         = ['alvaro@redondo.name']
+  spec.summary       = %q{Nagios check to monitor Passenger processes and memory}
+  # spec.description   = %q{TODO: Write a longer description. Optional.}
+  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'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'minitest-reporters'
+
+  spec.add_dependency 'thor', '~> 0.19.1'
+end

data/lib/check_passenger.rb

@@ -0,0 +1,13 @@
+%w{
+  nagios_check
+  check
+  parser
+  passenger_status
+  status_output_error
+  version
+}.each { |lib| require 'check_passenger/' + lib }
+
+module CheckPassenger
+  LIVE_PROCESS_TTL_IN_SECONDS = 300
+  CACHE_TTL = 5
+end

data/lib/check_passenger/check.rb

@@ -0,0 +1,96 @@
+require 'tmpdir'
+
+module CheckPassenger
+  class Check
+    class << self
+      include CheckPassenger::NagiosCheck
+
+      attr_reader :parsed_data
+
+      COUNTER_LABELS = {
+        live_process_count: '%d live processes',
+        memory: '%dMB memory used',
+        process_count: '%d processes'
+      }
+
+      def check_counter(counter_name, options = {})
+        load_parsed_data(options)
+        output_data = []
+
+        counter = parsed_data.send(counter_name.to_sym, options[:app_name])
+        output_status = nagios_status(counter, options)
+
+        data = {
+          text: 'Passenger %s %s - %s' %
+                [
+                  options[:app_name] || parsed_data.passenger_version,
+                  output_status.to_s.upcase,
+                  COUNTER_LABELS[counter_name.to_sym] % counter
+                ],
+          counter: counter_name.to_s, value: counter,
+          warn: options[:warn], crit: options[:crit],
+          min: 0, max: nil
+        }
+        if !options[:app_name] and [:process_count, :live_process_count].include?(counter_name.to_sym)
+          data[:max] = parsed_data.max_pool_size
+        end
+        output_data << data
+
+        if !options[:app_name] and options[:include_all]
+          parsed_data.application_names.each do |app_name|
+            counter = parsed_data.send(counter_name.to_sym, app_name)
+            output_data << {
+              text: '%s %s' % [app_name, COUNTER_LABELS[counter_name.to_sym] % counter],
+              counter: counter_name.to_s, value: counter
+            }
+          end
+        end
+
+        return [output_status, output_data]
+      end
+
+      def method_missing(method, *args)
+        if COUNTER_LABELS.keys.include?(method)
+          check_counter(method, *args)
+        else
+          super
+        end
+      end
+
+      def respond_to?(method)
+        return true if COUNTER_LABELS.keys.include?(method)
+        super
+      end
+
+      private
+
+      def load_parsed_data(options)
+        @parsed_data = options[:parsed_data]
+
+        if @parsed_data.nil? and options[:cache]
+          cache_file_path = File.expand_path('check_passenger_cache.dump', Dir.tmpdir)
+
+          if File.exist?(cache_file_path) and (Time.now - File.mtime(cache_file_path) < CACHE_TTL)
+            File.open(cache_file_path, 'rb') { |file| @parsed_data = Marshal.load(file.read) }
+          end
+        end
+
+        if @parsed_data.nil?
+          @parsed_data = Parser.new(passenger_status(options[:passenger_status_path]).run)
+
+          if options[:cache]
+            File.open(cache_file_path, 'wb') { |file| file.write Marshal.dump(@parsed_data) }
+          end
+        end
+
+        @parsed_data
+      end
+
+      def passenger_status(passenger_status_path = nil)
+        @passenger_status ||= PassengerStatus
+        @passenger_status.path = passenger_status_path
+        @passenger_status
+      end
+    end
+  end
+end

data/lib/check_passenger/nagios_check.rb

@@ -0,0 +1,66 @@
+module CheckPassenger
+  module NagiosCheck
+    EXIT_CODES = { ok: 0, warn: 1, crit: 2 }
+
+    private
+
+    def nagios_error(message)
+      puts message
+      exit 3
+    end
+
+    def nagios_output(status, data)
+      unless [:ok, :warn, :crit].include?(status)
+        raise ArgumentError, 'Invalid status provided: %s' % status.to_s
+      end
+
+      data = [data] unless data.is_a?(Array)
+
+      data.each do |line|
+        raise ArgumentError, 'No status text provided' unless line.has_key?(:text)
+
+        if line[:counter] and line[:value]
+          puts '%s|%s=%d;%s;%s;%s;%s' % [
+            line[:text],
+            line[:counter], line[:value],
+            line[:warn], line[:crit],
+            line[:min], line[:max]
+          ]
+        else
+          puts line[:text]
+        end
+      end
+
+      exit EXIT_CODES[status]
+    end
+
+    def nagios_range_to_condition(nagios_range)
+      case nagios_range
+      when /^(-?\d+)$/
+        lambda { |n| !(0 .. $1.to_i).include?(n) }
+      when /^(-?\d+):~?$/
+        lambda { |n| n < $1.to_i }
+      when /^~?:(-?\d+)$/
+        lambda { |n| n > $1.to_i }
+      when /^(-?\d+):(-?\d+)$/
+        lambda { |n| !($1.to_i .. $2.to_i).include?(n) }
+      when /^@(-?\d+):(-?\d+)$/
+        lambda { |n| ($1.to_i .. $2.to_i).include?(n) }
+      else
+        raise ArgumentError, 'Cannot process Nagios range: %s' % nagios_range
+      end
+    end
+
+    def nagios_status(counter, options = {})
+      status = :ok
+      [:warn, :crit].each do |level|
+        status = level if options[level] && number_outside_range?(counter, options[level])
+      end
+      status
+    end
+
+    def number_outside_range?(number, nagios_range)
+      nagios_range_to_condition(nagios_range).call(number)
+    end
+  end
+end

data/lib/check_passenger/parser.rb

@@ -0,0 +1,120 @@
+module CheckPassenger
+  class Parser
+    UNIT_MULTIPLIERS = { 's' => 1, 'm' => 60, 'h' => 3_600, 'd' => 86_400 }
+
+    attr_reader :max_pool_size, :passenger_status_output, :passenger_version
+
+    def initialize(passenger_status_output)
+      @passenger_status_output = passenger_status_output
+      parse_passenger_status_output
+    end
+
+    def application_names
+      @application_data.map { |app_data| app_data[:name] }
+    end
+
+    def live_process_count(app_name = nil)
+      if app_name
+        app_data = application_data(app_name)
+        app_data[:live_process_count]
+      else
+        @application_data.inject(0) { |sum, e| sum + e[:live_process_count] }
+      end
+    end
+
+    def memory(app_name = nil)
+      if app_name
+        app_data = application_data(app_name)
+        app_data[:memory]
+      else
+        @application_data.inject(0) { |sum, e| sum + e[:memory] }
+      end
+    end
+
+    def process_count(app_name = nil)
+      if app_name
+        app_data = application_data(app_name)
+        app_data[:process_count]
+      else
+        @process_count
+      end
+    end
+
+    private
+
+    def application_data(app_name)
+      if app_name
+        data = @application_data.select { |d| d[:name].include?(app_name) }
+        if data.size == 0
+          raise ArgumentError, 'Could not find an application by "%s"' % app_name
+        elsif data.size > 1
+          raise ArgumentError, 'More than one application match "%s"' % app_name
+        else
+          return data.first
+        end
+      else
+        return @application_data
+      end
+    end
+
+    def is_process_alive?(last_used)
+      life_to_seconds(last_used) < LIVE_PROCESS_TTL_IN_SECONDS
+    end
+
+    def life_to_seconds(last_used)
+      last_used.split(/\s+/).inject(0) do |sum, part|
+        if part =~ /^(\d+)([a-z])$/
+          unless UNIT_MULTIPLIERS.has_key?($2)
+          raise StatusOutputError.new(
+              'Unknown time unit "%s" in "%s"' % [$2, last_used],
+              passenger_status_output
+            )
+          end
+          sum + $1.to_i * UNIT_MULTIPLIERS[$2]
+        else
+          sum
+        end
+      end
+    end
+
+    def parse_application_data(output)
+      output.split("\n\n").map do |app_output|
+        app_data = {}
+
+        app_output =~ /App root: +([^\n]+)/
+        raise StatusOutputError.new('Could not find app name', passenger_status_output) unless $1
+        app_data[:name] = $1.strip
+
+        app_data[:process_count] = app_output.scan(/PID *: *\d+/).size
+        app_data[:memory] = app_output.scan(/Memory *: *(\d+)M/).inject(0.0) { |s, m| s + m[0].to_f }
+        app_data[:live_process_count] = (
+          app_output.scan(/Last used *: *([^\n]+)/).select { |m| is_process_alive?(m[0]) }
+        ).size
+
+        app_data
+      end
+    end
+
+    def parse_passenger_status_output
+      passenger_status_output =~ /^(.*?)-+ +Application groups +-+[^\n]*\n(.*)$/m
+      raise StatusOutputError.new('Did not find "Application groups" section', passenger_status_output) unless $1
+
+      generic_data = $1
+      application_data = $2
+
+      generic_data =~ /Version *: *([.\d]+)/
+      raise StatusOutputError.new('Could not find Passenger version', passenger_status_output) unless $1
+      @passenger_version = $1
+
+      generic_data =~ /Max pool size *: *(\d+)/
+      raise StatusOutputError.new('Could not find max pool size', passenger_status_output) unless $1
+      @max_pool_size = $1.to_i
+
+      generic_data =~ /Processes *: *(\d+)/
+      raise StatusOutputError.new('Could not find process count', passenger_status_output) unless $1
+      @process_count = $1.to_i
+
+      @application_data = parse_application_data(application_data)
+    end
+  end
+end