check_passenger 1.0 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac4b91af6cd0dfb61d99dccd54d6b0929bf314d1
+  data.tar.gz: fae7ccced65cb78805f5829ed260ab75798b2c5c
+SHA512:
+  metadata.gz: 7f567d1df12c061229ad83fc44b234416af3289ac128f94967f20fc9a984cd153d9346e16168a65510d3d24aa1b7473e6e30f4d5f36915c5b23babff7a6fbd89
+  data.tar.gz: 9eb4de4362e5bb4721453bb1baa751d2234047e0a99786cb71aded782f7ae60035cf05e22e72ec1acb04745df005fdad7695ffbe265818c0458e13959e394372

data/.codeclimate.yml

@@ -0,0 +1,8 @@
+# Save as .codeclimate.yml (note leading .) in project root directory
+languages:
+  Ruby: true
+  JavaScript: false
+  PHP: false
+  Python: false
+# exclude_paths:
+# - "foo/bar.rb"

data/.rubocop.yml

@@ -0,0 +1,32 @@
+Documentation:
+  Enabled: false
+Metrics/AbcSize:
+  Enabled: false
+Metrics/ClassLength:
+  Enabled: false
+Metrics/MethodLength:
+  Enabled: false
+Metrics/ModuleLength:
+  Enabled: false
+Style/AndOr:
+  Enabled: false
+Style/ClassAndModuleChildren:
+  Enabled: false
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/CollectionMethods:
+  Enabled: yes
+Lint/LiteralInInterpolation:
+  Enabled: yes
+
+Metrics/LineLength:
+  Max: 120
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+Style/DotPosition:
+  EnforcedStyle: trailing
+Style/EmptyElse:
+  EnforcedStyle: empty
+Style/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.1.6
+  - 2.2.2
+script: bundle exec rake test
+addons:
+  code_climate:
+    repo_token: 6214a7723a1d2d9de5f408fc150f9ddc857fdb3c641eab55b3c2a5d231aef571

data/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+## 1.1.0
+
+- Add checks for application queues and top-level queue sizes
+- Improve documentation
+
+
+## 1.0
+
+- Improve command help
+- Raise CRIT alert a sought application is not found running
+- Bug fixes
+
+
+## 0.2
+
+- Bug fixes
+
+
+## 0.1
+
+Initial release

data/CONTRIBUTING.md

@@ -0,0 +1,12 @@
+# Contribution Guidelines
+
+1. Fork this repository (https://github.com/aredondo/check_passenger/fork). The repository follows the [Git Flow branching model](http://nvie.com/posts/a-successful-git-branching-model/) so when forking, please do so from the `develop` branch, as there may be commits that have still not made it to `master`.
+2. Create your feature branch: `git checkout -b feature/my-new-feature`
+3. Commit your changes
+4. Make sure that all the tests pass: `rake test`
+5. Run Rubocop to confirm that it does not raise any warnings
+6. Make sure to update [CHANGELOG.md](CHANGELOG.md) to list your changes. Also, update [README.md](README.md) if necessary. Please, do not update the gem version.
+7. Push to the branch: `git push origin feature/my-new-feature`
+8. Create a new Pull Request
+
+Thanks!

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in check_passenger.gemspec
 gemspec
+
+gem 'codeclimate-test-reporter', group: :test, require: nil

data/README.md

@@ -1,5 +1,10 @@
 # check_passenger
 
+[![Gem Version](https://badge.fury.io/rb/check_passenger.svg)](http://badge.fury.io/rb/check_passenger)
+[![Build Status](https://travis-ci.org/aredondo/check_passenger.svg?branch=master)](https://travis-ci.org/aredondo/check_passenger)
+[![Code Climate](https://codeclimate.com/github/aredondo/check_passenger/badges/gpa.svg)](https://codeclimate.com/github/aredondo/check_passenger)
+[![License](http://img.shields.io/:license-mit-blue.svg)](LICENSE.txt)
+
 This gem provides a Nagios check command to monitor running Passenger processes and the memory that they use.
 
 It can report data on a global or per-application basis, and raise warnings and alerts when consumption exceeds given thresholds.
@@ -15,30 +20,39 @@ Alternatively, the gem can be built from the source code with `gem build`, and m
 
 Either way, the `check_passenger` command should become available in the path—although it may be necessary to perform an additional action, such as running `rbenv rehash` or similar.
 
+This gem requires Ruby 1.9+.
+
 
 ## Usage
 
 **check\_passenger** is intended to be executed in the same machine or machines where Passenger is running. It will call `passenger-status` and gather all data from its output.
 
-Typically, the Nagios service will be running in a separate machine from those being monitored. Remote execution of `check_passenger` is then usually achieved with Nagios Remote Plugin Executor (NRPE), or MK's Remote Plugin Executor (MRPE).
+Typically, the Nagios service will be running in a separate machine from those being monitored. Remote execution of **check\_passenger** is then usually achieved with Nagios Remote Plugin Executor (NRPE), or MK's Remote Plugin Executor (MRPE).
 
-`check_passenger` reads all necessary settings from the command-line when it's run, and does not take configuration from a file. It supports three working modes depending on the aspect being monitored, which are called with an argument as:
+**check\_passenger** reads all necessary settings from the command-line when it's run, and does not take configuration from a file. It supports several working modes, one for each aspect that can be monitored, which are called with an argument as:
 
     # check_passenger <mode>
 
-Where the `<mode>` argument can be on of the following:
+Where the `<mode>` argument can be one of the following:
 
 * `processes`: These are the Passenger processes that are currently running, associated to applications.
 * `live_processes`: Of all the running processes, how many are actually being used. See the section [Passenger Live Processes](#passenger-live-processes) below.
 * `memory`: Memory occupied by the Passenger processes that are running.
+* `requests`: Number of requests that are waiting in application queues. See the section [Passenger Request Queues](#passenger-request-queues) below.
+* `top_level_requests`: Number of requests waiting in the top-level queue. See the section [Passenger Request Queues](#passenger-request-queues) below.
 
-In addition, **check\_passenger** can be called with the following options:
+When checking for `processes`, `live_processes`, `memory`, or `requests`—that is, any check type except for `top_level_requests`—, the following options can be provided to filter data by application, or to get separate counters for each running application:
 
 * `-n, --app-name`: Limit check to application with *APP_NAME*—see the section [Global or Per-Application Reporting](#global-or-per-application-reporting) below.
+* `-a, --include-all`: Apart from reporting on a global counter, add data for the same counter for each running Passenger application—see the section [Global or Per-Application Reporting](#global-or-per-application-reporting) below.
+
+These two options are mutually exclusive.
+
+In addition, **check\_passenger** can be called with the following options for any check type:
+
 * `-C, --cache`: Cache parsed output of `passenger-status`—see the section [Data Caching](#data-caching) below.
 * `-D, --debug`: Let exception raise to the command-line, and keep the output of `passenger-status` in a file for debugging purposes.
 * `-d, --dump`: Keep the output of `passenger-status` in a file for debugging purposes.
-* `-a, --include-all`: Apart from reporting on a global counter, add data for the same counter for each running Passenger application—see the section [Global or Per-Application Reporting](#global-or-per-application-reporting) below.
 * `-p, --passenger-status-path`: Full path to the `passenger-status` command—most of the time not needed.
 
 To raise warnings and alerts, use the `-w, --warn`, and `-c, --crit` options. Ranges can be provided as described in the [Nagios Plugin Development Guidelines](https://nagios-plugins.org/doc/guidelines.html#THRESHOLDFORMAT). Note that memory is measured in megabytes.
@@ -48,7 +62,7 @@ Finally, run `check_passenger help [mode]` to get usage information on the comma
 
 ## Global or Per-Application Reporting
 
-For each of the aspects that **check\_passenger** can monitor (processes, live processes, and memory), it can focus on all the applications running with Passenger, or on a specific application. This is controlled with the `-n` (`--app-name`), and `-a` (`--include-all`) options, as seen in the following examples.
+For most of the aspects that **check\_passenger** can monitor (processes, live processes, application request queue size, and memory), it can focus on all the applications running with Passenger, or on a specific application. This is controlled with the `-n` (`--app-name`), and `-a` (`--include-all`) options, as seen in the following examples.
 
 The following command returns a counter for all the running Passenger processes in the machine:
 
@@ -75,7 +89,7 @@ Finally, it's possible to obtain a global counter, together with additional coun
 
 This allows to monitor a resource, together with how much of it is being used by each application. Note though, that when monitoring a particular counter for all the applications in this way, it won't be possible to set alerts—just add an additional check for the alert you want to set for an application or globally.
 
-All these examples work the same with processes, live processes, and memory.
+All these examples work the same with processes, live processes, request queue size, and memory. The exception is the check for requests waiting in the top-level queue, which is just a global counter.
 
 
 ## Passenger Live Processes
@@ -85,6 +99,23 @@ Passenger reuses running processes in a sort of LIFO manner. This means that whe
 In order to estimate the live process count, **check\_passenger** takes a look at those that have been run in the last 300 seconds (or 5 minutes). This works well as long as **check\_passenger** is executed with a periodicity of 5 minutes or less.
 
 
+## Passenger Request Queues
+
+> Phusion Passenger's internal state consists of a list of Groups (representing applications), each which consist of a list of Processes (representing application processes). When spawning the first process for an application, Phusion Passenger has to create and initialize a Group data structure, run hooks, etc. Since this involves reading from disk and running processes, it can potentially take an arbitrary amount of time. During that time, said request, and any new requests targeted at that application, are put in the top-level queue until the Group is done initializing.
+
+> Each Group has its own queue. As soon as the Group is initialized, relevant requests from the top-level queue are moved to the Group-local queue. This is the reason why the top-level queue is usually empty. The sum of the values of all Group-local queues, plus the value of the top-level queue, is the total number of requests that are queued. In general, if they are non-zero and increasing, the number of workers needs to be increased.
+
+Hongli. (2014, April 12). Re: Difference between "requests in top-level queue" and "requests in queue" in Phusion Passenger [Online forum comment]. Retrieved from http://stackoverflow.com/questions/23025028/difference-between-requests-in-top-level-queue-and-requests-in-queue-in-phus
+
+Three different queued requests counters can be monitored:
+
+* The total number of queued requests: `check_passenger requests`. This is the sum of the top-level queued requests, plus the requests queued in every application group.
+* The number of requests queued for a specific application: `check_passenger requests --app-name APP_NAME`
+* The number of requests waiting in the top-level queue: `check_passenger top_level_requests`
+
+According to the [Phusion Passenger documentation](https://www.phusionpassenger.com/library/admin/apache/overall_status_report.html#viewing-process-and-request-queue-information), the top-level request queue size is supposed to be almost always zero. If it is non-zero for an extended period of time, then there is something very wrong, possibly a Passenger bug.
+
+
 ## Data Caching
 
 In order to set alerts per global or application counter, **check\_passenger** must be called successive times with different settings. For example, to raise alerts on global memory consumption:
@@ -106,11 +137,7 @@ Cached data is stored in the temporary directory of the system, with a time-to-l
 
 ## Contributing
 
-1. Fork it ( https://github.com/aredondo/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
+Please, see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
 
 
 ## License

data/bin/check_passenger

@@ -10,16 +10,15 @@ 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'
+                       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 memory used by Passenger processes'
+  option :app_name, aliases: 'n', banner: 'Limit check to application with APP_NAME'
+  option :include_all, aliases: 'a', type: :boolean, banner: 'Also include counter for all running apps'
   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
@@ -29,6 +28,8 @@ class CheckPassengerCLI < Thor
   end
 
   desc 'processes', 'Check running Passenger processes'
+  option :app_name, aliases: 'n', banner: 'Limit check to application with APP_NAME'
+  option :include_all, aliases: 'a', type: :boolean, banner: 'Also include counter for all running apps'
   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
@@ -38,6 +39,8 @@ class CheckPassengerCLI < Thor
   end
 
   desc 'live_processes', 'Check live Passenger processes'
+  option :app_name, aliases: 'n', banner: 'Limit check to application with APP_NAME'
+  option :include_all, aliases: 'a', type: :boolean, banner: 'Also include counter for all running apps'
   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
@@ -46,6 +49,26 @@ class CheckPassengerCLI < Thor
     end
   end
 
+  desc 'requests', 'Check queued Passenger requests'
+  option :app_name, aliases: 'n', banner: 'Limit check to application with APP_NAME'
+  option :include_all, aliases: 'a', type: :boolean, banner: 'Also include counter for all running apps'
+  option :warn, aliases: 'w', banner: 'Request count threshold to raise warning status'
+  option :crit, aliases: 'c', banner: 'Request count threshold to raise critical status'
+  def requests
+    run_check do
+      CheckPassenger::Check.request_count(options)
+    end
+  end
+
+  desc 'top_level_requests', 'Check requests waiting in top-level queue'
+  option :warn, aliases: 'w', banner: 'Request count threshold to raise warning status'
+  option :crit, aliases: 'c', banner: 'Request count threshold to raise critical status'
+  def top_level_requests
+    run_check do
+      CheckPassenger::Check.top_level_request_count(options)
+    end
+  end
+
   private
 
   def dump_passenger_status_output(exception = nil)
@@ -60,41 +83,53 @@ class CheckPassengerCLI < Thor
     end
 
     if passenger_status_output
-      filename = 'passenger_status_output_dump-%s.txt' % Time.now.strftime('%Y%m%d%H%M%S')
+      filename = format('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
+      dump_path
+    else
+      nil
+    end
+  end
+
+  def exception_for_dumped_passenger_status_output(exception, dump_path)
+    if dump_path
+      message = e.message + " -- passenger-status output dumped to #{dump_path}"
+      exception.class.new(message)
+    else
+      exception
+    end
+  end
+
+  def output_exception(e)
+    case e
+    when CheckPassenger::StatusOutputError
+      nagios_error("Passenger UNKNOWN - An error occurred while parsing passenger-status output: #{e.message}")
     else
-      return nil
+      nagios_error("Passenger UNKNOWN - #{e.message} (#{e.class})")
     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'
+      fail 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
+    if should_dump_passenger_status_output?
+      dump_path = dump_passenger_status_output(e)
+      e = exception_for_dumped_passenger_status_output(e, dump_path)
     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
+    raise e if options[:debug]
+    output_exception(e)
+  end
+
+  def should_dump_passenger_status_output?
+    options[:debug] or options[:dump]
   end
 end
 

data/check_passenger.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   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.summary       = 'Nagios check to monitor Passenger processes and memory'
   # spec.description   = %q{TODO: Write a longer description. Optional.}
   spec.homepage      = 'https://github.com/aredondo/check_passenger'
   spec.license       = 'MIT'

data/lib/check_passenger.rb

@@ -1,4 +1,4 @@
-%w{
+%w(
   nagios_check
   check
   parser
@@ -7,7 +7,7 @@
   no_application_error
   status_output_error
   version
-}.each { |lib| require 'check_passenger/' + lib }
+).each { |lib| require 'check_passenger/' + lib }
 
 module CheckPassenger
   LIVE_PROCESS_TTL_IN_SECONDS = 300

data/lib/check_passenger/check.rb

@@ -10,7 +10,9 @@ module CheckPassenger
       COUNTER_LABELS = {
         live_process_count: ['%d live process', '%d live processes'],
         memory: '%dMB memory used',
-        process_count: ['%d process', '%d processes']
+        process_count: ['%d process', '%d processes'],
+        request_count: ['%d request', '%d requests'],
+        top_level_request_count: ['%d top-level request', '%d top-level requests']
       }
 
       def check_counter(counter_name, options = {})
@@ -21,12 +23,10 @@ module CheckPassenger
         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_with_label(counter, counter_name)
-                ],
+          text: format('Passenger %s %s - %s',
+                       options[:app_name] || parsed_data.passenger_version,
+                       output_status.to_s.upcase,
+                       counter_with_label(counter, counter_name)),
           counter: counter_name.to_s, value: counter,
           warn: options[:warn], crit: options[:crit],
           min: 0, max: nil
@@ -36,11 +36,11 @@ module CheckPassenger
         end
         output_data << data
 
-        if !options[:app_name] and options[:include_all]
+        if 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_with_label(counter, counter_name)],
+              text: format('%s %s', app_name, counter_with_label(counter, counter_name)),
               counter: app_name, value: counter
             }
           end
@@ -50,7 +50,7 @@ module CheckPassenger
 
       rescue NoApplicationError => e
         status = :crit
-        return [status, 'Passenger %s %s - %s' % [e.name, status.to_s.upcase, e.to_s]]
+        return [status, format('Passenger %s %s - %s', e.name, status.to_s.upcase, e.to_s)]
       end
 
       def method_missing(method, *args)
@@ -68,39 +68,46 @@ module CheckPassenger
 
       private
 
+      def cache_file_path
+        File.expand_path('check_passenger_cache.dump', Dir.tmpdir)
+      end
+
+      def cache_parsed_data(data)
+        File.open(cache_file_path, 'wb') { |file| file.write Marshal.dump(data) }
+      end
+
       def counter_with_label(counter, counter_type)
         counter_type = counter_type.to_sym
 
         unless COUNTER_LABELS.keys.include?(counter_type)
-          raise ArgumentError, 'Unknown counter type: %s' % counter_type.to_s
+          fail ArgumentError, "Unknown counter type: #{counter_type}"
         end
 
         label = if COUNTER_LABELS[counter_type].is_a?(Array)
-          counter == 1 ? COUNTER_LABELS[counter_type].first : COUNTER_LABELS[counter_type].last
-        else
-          COUNTER_LABELS[counter_type]
-        end
+                  if counter == 1
+                    COUNTER_LABELS[counter_type].first
+                  else
+                    COUNTER_LABELS[counter_type].last
+                  end
+                else
+                  COUNTER_LABELS[counter_type]
+                end
 
         label % counter
       end
 
+      def load_cached_data
+        return nil unless File.exist?(cache_file_path) and (Time.now - File.mtime(cache_file_path) < CACHE_TTL)
+        File.open(cache_file_path, 'rb') { |file| return Marshal.load(file.read) }
+      end
+
       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
+        @parsed_data = load_cached_data if @parsed_data.nil? and options[:cache]
 
         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
+          cache_parsed_data(@parsed_data) if options[:cache]
         end
 
         @parsed_data