cb_sensu_check_processes 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fdb6f6703ba42f26b2799acea9670c547eaf4f6e
+  data.tar.gz: 33ba683bef70de5a85d8ed72459557f521aa65ef
+SHA512:
+  metadata.gz: f937730105c45e68a0dd3d1c28ae50aa36c0339590e4aa5b0fa0f92ab2d54969e0857d1520d1ff36351ff2709d66ee53e6105de13a073a86212bdc25199a0f3e
+  data.tar.gz: eac4f12d6f1b77ec439409c25c404017c52188540c8c367c6fd77d742fba8a5ca500aa0392e5d94548bcae36a9087d7a3f97dc8df556f24b32864b49ae0e71fc

data/CHANGELOG.md

@@ -0,0 +1,84 @@
+#Change Log
+This project adheres to [Semantic Versioning](http://semver.org/).
+
+This CHANGELOG follows the format listed at [Keep A Changelog](http://keepachangelog.com/)
+
+## Unreleased
+
+## [0.0.4] - 2015-07-14
+### Changed
+- updated sensu-plugin gem to 1.2.0
+
+## [0.0.3] - [2015-07-13]
+### Fixed
+- issue #9: variable type conversion to_i in check-process-restart
+
+### Changed
+- updated documentation links in README and CONTRIBUTING
+- removed unused rake tasks from Rakefile
+- puts deps in alpha order in Rakefile
+- puts deps in order in Gemspec
+
+## [0.0.2] - 2015-06-03
+
+### Fixed
+- added binstubs
+
+### Changed
+- removed cruft from /lib
+
+## [0.0.1] - [2015-05-01]
+
+### Added
+- initial stable release
+
+## [0.0.1.alpha.6]
+
+### Added
+- add chef provisioner to Vagrantfile
+- add metadata to gemspec
+
+### Fixed
+- fix rubocop errors
+
+## [0.0.1.alpha.5]
+
+### Added
+- add new check for process uptime metrics
+
+## [0.0.1.alpha.4]
+
+### Changed
+- convert scrips to sys-proctable gem for platform independence
+
+## [0.0.1-alpha.3]
+
+### Added
+- add proc-status-metrics
+
+### Changed
+- change proc-status-metrics to process-status-metrics
+
+## [0.0.1-alpha.2]
+
+### Changed
+- bump Vagrant to Chef 6.6
+- update LICENSE and gemspec authors
+- update README
+
+### Added
+- add required Ruby version *>= 1.9.3*
+- add test/spec_help.rb
+
+## [0.1.0-alpha.1]
+
+- baseline release identical to **sensu-community-plugins** repo
+
+### Changed
+- changed *check-procs* to *check-process* to better reflect its use
+- pinned dependencies
+
+### Added
+- basic yard coverage
+- built against 1.9.3, 2.0, 2.1
+- cryptographically signed

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Sensu-Plugins
+
+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,31 @@
+## Sensu-Plugins-process-checks
+
+[ ![Build Status](https://travis-ci.org/sensu-plugins/sensu-plugins-process-checks.svg?branch=master)](https://travis-ci.org/sensu-plugins/sensu-plugins-process-checks)
+[![Gem Version](https://badge.fury.io/rb/sensu-plugins-process-checks.svg)](http://badge.fury.io/rb/sensu-plugins-process-checks)
+[![Code Climate](https://codeclimate.com/github/sensu-plugins/sensu-plugins-process-checks/badges/gpa.svg)](https://codeclimate.com/github/sensu-plugins/sensu-plugins-process-checks)
+[![Test Coverage](https://codeclimate.com/github/sensu-plugins/sensu-plugins-process-checks/badges/coverage.svg)](https://codeclimate.com/github/sensu-plugins/sensu-plugins-process-checks)
+[![Dependency Status](https://gemnasium.com/sensu-plugins/sensu-plugins-process-checks.svg)](https://gemnasium.com/sensu-plugins/sensu-plugins-process-checks)
+[![Codeship Status for sensu-plugins/sensu-plugins-process-checks](https://codeship.com/projects/feb27000-d25e-0132-6aab-4ad10baf29cc/status?branch=master)](https://codeship.com/projects/77521)
+
+## Functionality
+
+**check-processs** and **check-process-restart**  will check processes on a system and alert if specific conditions exist based upon a set of filters that each has implemented.
+
+**check-cmd** will run a specific user designated command and parse the output with a regex or check for a specific status code.  If either of these conditions is not what is expected it will alert.
+
+## Files
+ * bin/check-cmd.rb
+ * bin/check-process-restart.rb
+ * bin/check-process.rb
+ * bin/check-threads-count.rb
+ * bin/metrics-process-status.rb
+ * bin/metrics-processes-threads-count.rb
+ * bin/process-uptime-metrics.sh
+
+## Usage
+
+## Installation
+
+[Installation and Setup](http://sensu-plugins.io/docs/installation_instructions.html)
+
+## Notes

data/bin/check-cmd.rb

@@ -0,0 +1,78 @@
+#! /usr/bin/env ruby
+#
+# check-cmd
+#
+# DESCRIPTION:
+#   Generic check raising an error if exit code of command is not N.
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: english
+#
+# USAGE:
+#
+# NOTES:
+#
+# LICENSE:
+#   Jean-Francois Theroux <failshell@gmail.com>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'English'
+
+#
+# Check Command Status
+#
+class CheckCmdStatus < Sensu::Plugin::Check::CLI
+  option :command,
+         description: 'command to run (might need quotes)',
+         short: '-c',
+         long: '--command COMMAND',
+         required: true
+
+  option :status,
+         description: 'exit status code the check should get',
+         short: '-s',
+         long: '--status STATUS',
+         default: '0'
+
+  option :check_output,
+         description: 'Optionally check the process stdout against a regex',
+         short: '-o',
+         long: '--check_output REGEX'
+
+  # Acquire the exit code and/or output of a command and alert if it is not
+  # what is expected.
+  #
+  def acquire_cmd_status # rubocop:disable all
+    stdout = `#{config[:command]}`
+    # #YELLOW
+    unless $CHILD_STATUS.exitstatus.to_s == config[:status] # rubocop:disable UnlessElse
+      critical "exited with #{$CHILD_STATUS.exitstatus}"
+    else
+      if config[:check_output]
+        if Regexp.new(config[:check_output]).match(stdout)
+          ok "matched #{config[:check_output]} and exited with #{$CHILD_STATUS.exitstatus}"
+        else
+          critical "output didn't match #{config[:check_output]} (exit #{$CHILD_STATUS.exitstatus})"
+        end
+      else
+        ok "exited with #{$CHILD_STATUS.exitstatus}"
+      end
+    end
+  end
+
+  # main function
+  #
+  def run
+    acquire_cmd_status
+  end
+end

data/bin/check-process-restart.rb

@@ -0,0 +1,112 @@
+#! /usr/bin/env ruby
+#  encoding: UTF-8
+#
+#   check-process-restart
+#
+# DESCRIPTION:
+#   This will check if a running process requires a restart if a
+#   dependent package/library has changed (i.e upgraded)
+#
+# OUTPUT:
+#   plain text
+#   Defaults: CRITICAL if 2 or more process require a restart
+#             WARNING if 1 process requires a restart
+#
+# PLATFORMS:
+#   Linux (Debian based distributions)
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: json
+#   deb: debian-goodies
+#   gem: english
+#
+# USAGE:
+#   check-process-restart.rb # Uses defaults
+#   check-process-restart.rb -w 2 -c 5
+#
+# NOTES:
+#   This will only work on Debian based distributions and requires the
+#   debian-goodies package.
+#
+#   Also make sure the user "sensu" can sudo without password
+#
+# LICENSE:
+#   Yasser Nabi yassersaleemi@gmail.com
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+
+require 'sensu-plugin/check/cli'
+require 'json'
+require 'English'
+
+# Use to see if any processes require a restart
+class CheckProcessRestart < Sensu::Plugin::Check::CLI
+  option :warn,
+         short: '-w WARN',
+         description: 'the number of processes to need restart before warn',
+         default: 1
+
+  option :crit,
+         short: '-c CRIT',
+         description: 'the number of processes to need restart before critical',
+         default: 2
+
+  # Debian command to run
+  CHECK_RESTART = '/usr/sbin/checkrestart'
+
+  # Set path for the checkrestart script
+  #
+  def initialize
+    super
+  end
+
+  # Check if we can run checkrestart script
+  # @return [Boolean]
+  #
+  def checkrestart?
+    File.exist?('/etc/debian_version') && File.exist?(CHECK_RESTART)
+  end
+
+  # Run checkrestart and parse process(es) and pid(s)
+  # @return [Hash]
+  def run_checkrestart
+    checkrestart_hash = { found: '', pids: [] }
+
+    out = `sudo #{CHECK_RESTART} 2>&1`
+    if $CHILD_STATUS.to_i != 0
+      checkrestart_hash[:found] = "Failed to run checkrestart: #{out}"
+    else
+      out.lines do |l|
+        m = /^Found\s(\d+)/.match(l)
+        if m
+          checkrestart_hash[:found] = m[1]
+        end
+
+        m = /^\s+(\d+)\s+([ \w\/\-\.]+)$/.match(l)
+        if m
+          checkrestart_hash[:pids] << { m[1] => m[2] }
+        end
+      end
+    end
+    checkrestart_hash
+  end
+
+  # Main run method for the check
+  #
+  def run # rubocop:disable all
+    unless checkrestart?
+      unknown "Can't seem to find checkrestart. This check only works in a Debian based distribution and you need debian-goodies package installed"
+    end
+
+    checkrestart_out = run_checkrestart
+    if /^Failed/.match(checkrestart_out[:found])
+      unknown checkrestart_out[:found]
+    end
+    message JSON.generate(checkrestart_out)
+    found = checkrestart_out[:found].to_i
+    warning if found >= config[:warn].to_i && found < config[:crit].to_i
+    critical if found >= config[:crit].to_i
+    ok
+  end
+end

data/bin/check-process.rb

@@ -0,0 +1,298 @@
+#! /usr/bin/env ruby
+#
+# check-process
+#
+# DESCRIPTION:
+#   Finds processes matching various filters (name, state, etc). Will not
+#   match itself by default. The number of processes found will be tested
+#   against the Warning/critical thresholds. By default, fails with a
+#   CRITICAL if more than one process matches -- you must specify values
+#   for -w and -c to override this.
+#
+#   Attempts to work on Cygwin (where ps does not have the features we
+#   need) by calling Windows' tasklist.exe, but this is not well tested.#
+#
+# OUTPUT:
+#   plain text
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: english
+#
+# USAGE:
+#   # chef-client is running
+#   check-procs -p chef-client -W 1
+#
+#   # there are not too many zombies
+#   check-procs -s Z -w 5 -c 10
+#
+# NOTES:
+#
+# LICENSE:
+#   Copyright 2011 Sonian, Inc <chefs@sonian.net>
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'English'
+
+#
+# Check Processes
+#
+class CheckProcess < Sensu::Plugin::Check::CLI
+  option :warn_over,
+         short: '-w N',
+         long: '--warn-over N',
+         description: 'Trigger a warning if over a number',
+         proc: proc(&:to_i)
+
+  option :crit_over,
+         short: '-c N',
+         long: '--critical-over N',
+         description: 'Trigger a critical if over a number',
+         proc: proc(&:to_i)
+
+  option :warn_under,
+         short: '-W N',
+         long: '--warn-under N',
+         description: 'Trigger a warning if under a number',
+         proc: proc(&:to_i),
+         default: 1
+
+  option :crit_under,
+         short: '-C N',
+         long: '--critical-under N',
+         description: 'Trigger a critial if under a number',
+         proc: proc(&:to_i),
+         default: 1
+
+  option :metric,
+         short: '-t METRIC',
+         long: '--metric METRIC',
+         description: 'Trigger a critical if there are METRIC procs',
+         proc: proc(&:to_sym)
+
+  option :match_self,
+         short: '-m',
+         long: '--match-self',
+         description: 'Match itself',
+         boolean: true,
+         default: false
+
+  option :match_parent,
+         short: '-M',
+         long: '--match-parent',
+         description: 'Match parent process it uses ruby {process.ppid}',
+         boolean: true,
+         default: false
+
+  option :cmd_pat,
+         short: '-p PATTERN',
+         long: '--pattern PATTERN',
+         description: 'Match a command against this pattern'
+
+  option :exclude_pat,
+         short: '-x PATTERN',
+         long: '--exclude-pattern PATTERN',
+         description: "Don't match against a pattern to prevent false positives"
+
+  option :file_pid,
+         short: '-f PID',
+         long: '--file-pid PID',
+         description: 'Check against a specific PID'
+
+  option :vsz,
+         short: '-z VSZ',
+         long: '--virtual-memory-size VSZ',
+         description: 'Trigger on a Virtual Memory size is bigger than this',
+         proc: proc(&:to_i)
+
+  option :rss,
+         short: '-r RSS',
+         long: '--resident-set-size RSS',
+         description: 'Trigger on a Resident Set size is bigger than this',
+         proc: proc(&:to_i)
+
+  option :pcpu,
+         short: '-P PCPU',
+         long: '--proportional-set-size PCPU',
+         description: 'Trigger on a Proportional Set Size is bigger than this',
+         proc: proc(&:to_f)
+
+  option :thcount,
+         short: '-T THCOUNT',
+         long: '--thread-count THCOUNT',
+         description: 'Trigger on a Thread Count is bigger than this',
+         proc: proc(&:to_i)
+
+  option :state,
+         short: '-s STATE',
+         long: '--state STATE',
+         description: 'Trigger on a specific state, example: Z for zombie',
+         proc: proc { |a| a.split(',') }
+
+  option :user,
+         short: '-u USER',
+         long: '--user USER',
+         description: 'Trigger on a specific user',
+         proc: proc { |a| a.split(',') }
+
+  option :esec_over,
+         short: '-e SECONDS',
+         long: '--esec-over SECONDS',
+         proc: proc(&:to_i),
+         description: 'Match processes that older that this, in SECONDS'
+
+  option :esec_under,
+         short: '-E SECONDS',
+         long: '--esec-under SECONDS',
+         proc: proc(&:to_i),
+         description: 'Match process that are younger than this, in SECONDS'
+
+  option :cpu_over,
+         short: '-i SECONDS',
+         long: '--cpu-over SECONDS',
+         proc: proc(&:to_i),
+         description: 'Match processes cpu time that is older than this, in SECONDS'
+
+  option :cpu_under,
+         short: '-I SECONDS',
+         long: '--cpu-under SECONDS',
+         proc: proc(&:to_i),
+         description: 'Match processes cpu time that is younger than this, in SECONDS'
+
+  # Read the pid file
+  # @param path [String] the path to the pid file, including the file
+  def read_pid(path)
+    if File.exist?(path)
+      File.read(path).strip.to_i
+    else
+      unknown "Could not read pid file #{path}"
+    end
+  end
+
+  # read the output of a command
+  # @param cmd [String] the command to read the output from
+  def read_lines(cmd)
+    IO.popen(cmd + ' 2>&1') do |child|
+      child.read.split("\n")
+    end
+  end
+
+  # create a hash from the output of each line of a command
+  # @param line [String]
+  # @param cols
+  #
+  def line_to_hash(line, *cols)
+    Hash[cols.zip(line.strip.split(/\s+/, cols.size))]
+  end
+
+  # Is this running on cygwin
+  #
+  #
+  def on_cygwin?
+    # #YELLOW
+    `ps -W 2>&1`; $CHILD_STATUS.exitstatus == 0 # rubocop:disable Semicolon
+  end
+
+  # Acquire all the proceeses on a system for further analysis
+  #
+  def acquire_procs
+    if on_cygwin?
+      read_lines('ps -aWl').drop(1).map do |line|
+        # Horrible hack because cygwin's ps has no o option, every
+        # format includes the STIME column (which may contain spaces),
+        # and the process state (which isn't actually a column) can be
+        # blank. As of revision 1.35, the format is:
+        # const char *lfmt = "%c %7d %7d %7d %10u %4s %4u %8s %s\n";
+        state = line.slice!(0..0)
+        _stime = line.slice!(45..53)
+        line_to_hash(line, :pid, :ppid, :pgid, :winpid, :tty, :uid, :etime, :command, :time).merge(state: state)
+      end
+    else
+      read_lines('ps axwwo user,pid,vsz,rss,pcpu,nlwp,state,etime,time,command').drop(1).map do |line|
+        line_to_hash(line, :user, :pid, :vsz, :rss, :pcpu, :thcount, :state, :etime, :time, :command)
+      end
+    end
+  end
+
+  # Match to a time
+  #
+  def etime_to_esec(etime) # rubocop:disable all
+    m = /(\d+-)?(\d\d:)?(\d\d):(\d\d)/.match(etime)
+    (m[1] || 0).to_i * 86_400 + (m[2] || 0).to_i * 3600 + (m[3] || 0).to_i * 60 + (m[4] || 0).to_i
+  end
+
+  # Match to a time
+  #
+  def cputime_to_csec(time)  # rubocop:disable all
+    m = /(\d+-)?(\d\d:)?(\d\d):(\d\d)/.match(time)
+    (m[1] || 0).to_i * 86_400 + (m[2] || 0).to_i * 3600 + (m[3] || 0).to_i * 60 + (m[4] || 0).to_i
+  end
+
+  # The main function
+  #
+  def run # rubocop:disable all
+    procs = acquire_procs
+
+    if config[:file_pid] && (file_pid = read_pid(config[:file_pid]))
+      procs.reject! { |p| p[:pid].to_i != file_pid }
+    end
+    procs.reject! { |p| p[:pid].to_i == $PROCESS_ID } unless config[:match_self]
+    procs.reject! { |p| p[:pid].to_i == Process.ppid } unless config[:match_parent]
+    procs.reject! { |p| p[:command] =~ /#{config[:exclude_pat]}/ } if config[:exclude_pat]
+    procs.reject! { |p| p[:command] !~ /#{config[:cmd_pat]}/ } if config[:cmd_pat]
+    procs.reject! { |p| p[:vsz].to_f > config[:vsz] } if config[:vsz]
+    procs.reject! { |p| p[:rss].to_f > config[:rss] } if config[:rss]
+    procs.reject! { |p| p[:pcpu].to_f > config[:pcpu] } if config[:pcpu]
+    procs.reject! { |p| p[:thcount].to_i > config[:thcount] } if config[:thcount]
+    procs.reject! { |p| etime_to_esec(p[:etime]) >= config[:esec_under] } if config[:esec_under]
+    procs.reject! { |p| etime_to_esec(p[:etime]) <= config[:esec_over] } if config[:esec_over]
+    procs.reject! { |p| cputime_to_csec(p[:time]) >= config[:cpu_under] } if config[:cpu_under]
+    procs.reject! { |p| cputime_to_csec(p[:time]) <= config[:cpu_over] } if config[:cpu_over]
+    procs.reject! { |p| !config[:state].include?(p[:state]) } if config[:state]
+    procs.reject! { |p| !config[:user].include?(p[:user]) } if config[:user]
+
+    msg = "Found #{procs.size} matching processes"
+    msg += "; cmd /#{config[:cmd_pat]}/" if config[:cmd_pat]
+    msg += "; state #{config[:state].join(',')}" if config[:state]
+    msg += "; user #{config[:user].join(',')}" if config[:user]
+    msg += "; vsz < #{config[:vsz]}" if config[:vsz]
+    msg += "; rss < #{config[:rss]}" if config[:rss]
+    msg += "; pcpu < #{config[:pcpu]}" if config[:pcpu]
+    msg += "; thcount < #{config[:thcount]}" if config[:thcount]
+    msg += "; esec < #{config[:esec_under]}" if config[:esec_under]
+    msg += "; esec > #{config[:esec_over]}" if config[:esec_over]
+    msg += "; csec < #{config[:cpu_under]}" if config[:cpu_under]
+    msg += "; csec > #{config[:cpu_over]}" if config[:cpu_over]
+    msg += "; pid #{config[:file_pid]}" if config[:file_pid]
+
+    if config[:metric]
+      # #YELLOW
+      count = procs.map { |p| p[config[:metric]].to_i }.reduce { |a, b| a + b } # rubocop:disable SingleLineBlockParams
+      msg += "; #{config[:metric]} == #{count}"
+    else
+      count = procs.size
+    end
+
+    # #YELLOW
+    if !!config[:crit_under] && count < config[:crit_under] # rubocop:disable Style/DoubleNegation
+      critical msg
+    # #YELLOW
+    elsif !!config[:crit_over] && count > config[:crit_over] # rubocop:disable Style/DoubleNegation
+      critical msg
+    # #YELLOW
+    elsif !!config[:warn_under] && count < config[:warn_under] # rubocop:disable Style/DoubleNegation
+      warning msg
+    # #YELLOW
+    elsif !!config[:warn_over] && count > config[:warn_over] # rubocop:disable Style/DoubleNegation
+      warning msg
+    else
+      ok msg
+    end
+  end
+end

data/bin/check-threads-count.rb

@@ -0,0 +1,96 @@
+#! /usr/bin/env ruby
+#
+#   check-threads-count.rb
+#
+# DESCRIPTION:
+#   Counts the number of threads running on the system and alerts if that number is greater than the warning or critical values.
+#   The default warning and critical count thresholds come from the ~32000 thread limit in older Linux kernels.
+#
+# OUTPUT:
+#   check
+#
+# PLATFORMS:
+#   Linux, Windows
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: sys-proctable
+#
+# USAGE:
+#   The check will return an UNKNOWN if the sys-proctable version is not new enough to support it.
+#
+# NOTES:
+#   sys-proctable > 0.9.5 is required for counting threads
+#
+# LICENSE:
+#   Copyright (c) 2015 Contegix LLC
+#   Richard Chatteron richard.chatterton@contegix.com
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/check/cli'
+require 'sys/proctable'
+
+#
+# Check Threads Count
+#
+class ThreadsCount < Sensu::Plugin::Check::CLI
+  option :warn,
+         description: 'Produce a warning if the total number of threads is greater than this value.',
+         short: '-w WARN',
+         default: 30_000,
+         proc: proc(&:to_i)
+
+  option :crit,
+         description: 'Produce a critical if the total number of threads is greater than this value.',
+         short: '-c CRIT',
+         default: 32_000,
+         proc: proc(&:to_i)
+
+  PROCTABLE_MSG = 'sys-proctable version newer than 0.9.5 is required for counting threads with -t or --threads'
+
+  # Exit with an unknown if sys-proctable is not high enough to support counting threads.
+  def check_proctable_version
+    Gem.loaded_specs['sys-proctable'].version > Gem::Version.create('0.9.5')
+  end
+
+  # Takes a value to be tested as an integer. If a new Integer instance cannot be created from it, return 1.
+  # See the comments on get_process_threads() for why 1 is returned.
+  def test_int(i)
+    return Integer(i) rescue return 1
+  end
+
+  # Takes a process struct from Sys::ProcTable.ps() as an argument
+  # Attempts to use the Linux thread count field :nlwp first, then tries the Windows field :thread_count.
+  # Returns the number of processes in those fields.
+  # Otherwise, returns 1 as all processes are assumed to have at least one thread.
+  def get_process_threads(p)
+    if p.respond_to?(:nlwp)
+      return test_int(p.nlwp)
+    elsif p.respond_to?(:thread_count)
+      return test_int(p.thread_count)
+    else
+      return 1
+    end
+  end
+
+  def count_threads
+    ps_table = Sys::ProcTable.ps
+    ps_table.reduce(0) do |sum, p|
+      sum + get_process_threads(p)
+    end
+  end
+
+  # Main function
+  def run # rubocop:disable all
+    if !check_proctable_version
+      unknown PROCTABLE_MSG unless check_proctable_version
+    else
+      threads = count_threads
+      critical "#{threads} threads running, over threshold #{config[:crit]}" if threads > config[:crit]
+      warning "#{threads} threads running, over threshold #{config[:warn]}" if threads > config[:warn]
+      ok "#{threads} threads running"
+    end
+  end
+end

data/bin/metrics-process-status.rb

@@ -0,0 +1,144 @@
+#! /usr/bin/env ruby
+#  encoding: UTF-8
+#
+#   proc-status-metrics
+#
+# DESCRIPTION:
+#   For all processes owned by a user AND/OR matching a provided process
+#   name substring, return selected memory metrics from /proc/[PID]/status
+
+#
+# OUTPUT:
+#   metric data
+#
+# PLATFORMS:
+#   Linux
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#
+# USAGE:
+#
+# NOTES:
+#   - This check names the metrics after the full process name
+#     string as found in /proc/[PID]/cmdline, so data will be lost if
+#     you have multiple processes with identical cmdlines.
+#   - A process that changes its cmdline but still matches the search
+#     query will be duplicated as multiple discovered processes.
+#   - We make some assumptions in parsing /proc/[PID]/status, this will
+#     mostly only work with the memory-related stats.
+
+#
+# LICENSE:
+#   Copyright (c) 2014 Cozy Services Ltd. opensource@cozy.co
+#   Matt Greensmith mgreensmith@cozy.co
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/metric/cli'
+require 'socket'
+
+#
+# String
+# monkeypatch for helping validate PID strings
+#
+class String
+  # if its and integer, set it to a string
+  def integer?
+    to_i.to_s == self
+  end
+end
+
+#
+# Proc Status
+#
+# /proc/[PID]/status memory metrics plugin
+#
+class ProcStatus < Sensu::Plugin::Metric::CLI::Graphite
+  option :user,
+         description: 'Query processes owned by a user',
+         short: '-u USER',
+         long: '--user USER'
+
+  option :processname,
+         description: 'Process name substring to match against, not a regex.',
+         short: '-p PROCESSNAME',
+         long: '--process-name PROCESSNAME'
+
+  option :scheme,
+         description: 'Metric naming scheme',
+         long: '--scheme SCHEME',
+         default: "#{Socket.gethostname}.proc"
+
+  option :metrics,
+         description: 'Memory metrics to collect from /proc/[PID]/status, comma-separated',
+         short: '-m METRICS',
+         long: '--metrics METRICS',
+         default: 'VmSize,VmRSS,VmSwap'
+
+  # Build search command
+  #
+  def pgrep_command
+    pgrep_command = 'pgrep '
+    pgrep_command << "-u #{config[:user]} " if config[:user]
+    pgrep_command << "-f #{config[:processname]} " if config[:processname]
+    pgrep_command << '2<&1'
+  end
+
+  # Acquire process_pids
+  #
+  # @param pgrep_output [String]
+  #
+  def acquire_valid_pids(pgrep_output)
+    res = pgrep_output.split("\n").map(&:strip)
+    pids = res.reject { |x| !x.integer? }
+    pids
+  end
+
+  # Acquire the sate for the supplied PID
+  #
+  # @param pid [String]
+  #
+  def acquire_stats_for_pid(pid) # rubocop:disable all
+    return nil unless ::File.exist?(::File.join('/proc', pid, 'cmdline'))
+
+    cmdline_raw = `cat /proc/#{pid}/cmdline`
+    cmdline = cmdline_raw.strip.gsub(/[^[:alnum:]]/, '_')
+
+    metric_names = config[:metrics].split(',')
+    proc_status_lines = `cat /proc/#{pid}/status`.split("\n")
+
+    out = { "#{cmdline}" => {} }
+
+    metric_names.each do |m|
+      line = proc_status_lines.select { |x| /^#{m}/.match(x) }.first # rubocop:disable all
+      val = line ? line.split("\t")[1].to_i : nil
+      out[cmdline.to_s][m] = val
+    end
+    out
+  end
+
+  # Main functino
+  #
+  def run # rubocop:disable all
+    fail 'You must supply -u USER or -p PROCESSNAME' unless config[:user] || config[:processname]
+    metrics = {}
+    pgrep_output = `#{pgrep_command}`
+    pids = acquire_valid_pids(pgrep_output)
+
+    pids.each do |p|
+      data = acquire_stats_for_pid(p)
+      metrics.merge!(data) unless data.nil?
+    end
+
+    timestamp = Time.now.to_i
+
+    metrics.each do |proc_name, stats|
+      stats.each do |stat_name, value|
+        output [config[:scheme], proc_name, stat_name].join('.'), value, timestamp
+      end
+    end
+    ok
+  end
+end

data/bin/metrics-processes-threads-count.rb

@@ -0,0 +1,102 @@
+#! /usr/bin/env ruby
+#
+#   metric-processes-threads-count.rb
+#
+# DESCRIPTION:
+#   Counts the number of processes running on the system (and optionally, the number of running threads) and outputs it in metric format.
+#   Can alternatively count the number of processes/threads matching a certain substring.
+#
+# OUTPUT:
+#   metric data
+#
+# PLATFORMS:
+#   Linux, Windows
+#
+# DEPENDENCIES:
+#   gem: sensu-plugin
+#   gem: sys-proctable
+#
+# USAGE:
+#   Pass [-t|--threads] to count the number of running threads in addition to processes.
+#   The check will return an UNKNOWN if the sys-proctable version is not new enough to support counting threads.
+#
+# NOTES:
+#   sys-proctable > 0.9.5 is required for counting threads (-t, --threads)
+#
+# LICENSE:
+#   Copyright (c) 2015 Contegix LLC
+#   Richard Chatteron richard.chatterton@contegix.com
+#   Released under the same terms as Sensu (the MIT license); see LICENSE
+#   for details.
+#
+
+require 'sensu-plugin/metric/cli'
+require 'sys/proctable'
+
+#
+# Processes and Threads Count Metrics
+#
+class ProcessesThreadsCount < Sensu::Plugin::Metric::CLI::Graphite
+  option :scheme,
+         description: 'Scheme for metric output',
+         short: '-s SCHEME',
+         long: '--scheme SCHEME',
+         default: 'system'
+
+  option :threads,
+         description: 'If specified, count the number of threads running on the system in addition to processes. Note: Requires sys-proctables > 0.9.5',
+         short: '-t',
+         long: '--threads',
+         boolean: true,
+         default: false
+
+  PROCTABLE_MSG = 'sys-proctable version newer than 0.9.5 is required for counting threads with -t or --threads'
+
+  # Exit with an unknown if sys-proctable is not high enough to support counting threads.
+  def check_proctable_version
+    Gem.loaded_specs['sys-proctable'].version > Gem::Version.create('0.9.5')
+  end
+
+  # Takes a value to be tested as an integer. If a new Integer instance cannot be created from it, return 1.
+  # See the comments on get_process_threads() for why 1 is returned.
+  def test_int(i)
+    return Integer(i) rescue return 1
+  end
+
+  # Takes a process struct from Sys::ProcTable.ps() as an argument
+  # Attempts to use the Linux thread count field :nlwp first, then tries the Windows field :thread_count.
+  # Returns the number of processes in those fields.
+  # Otherwise, returns 1 as all processes are assumed to have at least one thread.
+  def get_process_threads(p)
+    if p.respond_to?(:nlwp)
+      return test_int(p.nlwp)
+    elsif p.respond_to?(:thread_count)
+      return test_int(p.thread_count)
+    else
+      return 1
+    end
+  end
+
+  def count_threads(ps_table)
+    ps_table.reduce(0) do |sum, p|
+      sum + get_process_threads(p)
+    end
+  end
+
+  # Main function
+  def run # rubocop:disable all
+    if config[:threads]
+      unknown PROCTABLE_MSG unless check_proctable_version
+    end
+    ps_table = Sys::ProcTable.ps
+    processes = ps_table.length
+    threads = count_threads(ps_table) if config[:threads]
+
+    timestamp = Time.now.to_i
+    output "#{[config[:scheme], 'process_count'].join('.')} #{processes} #{timestamp}"
+    if config[:threads]
+      output "#{[config[:scheme], 'thread_count'].join('.')} #{threads} #{timestamp}"
+    end
+    ok
+  end
+end

data/bin/process-uptime-metrics.sh

@@ -0,0 +1,91 @@
+#!/bin/bash
+
+#Author: Abhishek Jain<abhi111jain@gmail.com
+
+#This script greps for a process if the process name is specified or looks for the pid file in case the path to the pid file is specified.
+#If the grep is successful in the former case or the pid file is present with a valid running state in the latter case, a value of 1 is 
+#associated with the metric (<metric_name> <metric value> <timestamp>) format and outputted otherwise a value of 0 is emitted with the same format.
+#The metric name is constructed based on the scheme prefix specified. If not specified, the hostname is picked as the metric scheme and the metric
+#name is <hostname>.<process_name>.<uptime>
+
+#Example run
+#
+# process-uptime-metrics.sh -f <path_to_pid_file> -s <scheme like uptime.metrics.hostname.my_process
+#
+# The above would emit a line in the following format "uptime.metrics.hostname.uptime.my_process <value(0/1)> <timestamp>"
+#
+#Alternatively (using the process name instead of the pid file
+#
+# process-uptime-metrics.sh -p my_process -s uptime.metrics.hostname
+#
+# Output: "uptime.metrics.hostname.my_process <value(0/1)> <timestamp>"
+#
+#
+
+
+# #RED
+SCHEME=`hostname`
+
+usage()
+{
+  cat <<EOF
+usage: $0 options
+
+This plugin produces CPU usage (%)
+
+OPTIONS:
+   -h      Show this message
+   -p      PID
+   -f      Path to PID file
+   -s      Metric naming scheme, text to prepend to cpu.usage (default: $SCHEME)
+EOF
+}
+
+while getopts "hp:f:s:" OPTION
+  do
+    case $OPTION in
+      h)
+        usage
+        exit 1
+        ;;
+      p)
+        PROCESS="$OPTARG"
+        ;;
+      s)
+        SCHEME="$OPTARG"
+        ;;
+      f)
+        PIDFILE="$OPTARG"
+        ;;
+      ?)
+        usage
+        exit 1
+        ;;
+    esac
+done
+
+if [ ${PROCESS} ]; then
+  scriptname=`basename $0`
+  SCHEME="${SCHEME}.${PROCESS}"
+  ret=`ps aux | grep "${PROCESS}" | grep -v grep | grep -v $scriptname`
+  if [ ! "${ret}" ]; then
+    echo "$SCHEME.uptime 0 `date +%s`"
+    exit 0
+  fi
+  echo "$SCHEME.uptime 1 `date +%s`"
+  exit 0
+fi
+
+if [ ${PIDFILE} ]; then
+  if [ ! -e ${PIDFILE} ]; then
+    echo "$SCHEME.uptime 0 `date +%s`"
+    exit 0
+  fi
+  pid=`cat ${PIDFILE} | tr -d ' '`
+  if [ ! -f /proc/${pid}/status ]; then
+    echo "$SCHEME.uptime 0 `date +%s`"
+    exit 0
+  fi
+  echo "$SCHEME.uptime 1 `date +%s`"
+  exit 0
+fi

data/lib/sensu-plugins-process-checks/version.rb

@@ -0,0 +1,9 @@
+module SensuPluginsProcessChecks
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 5
+
+    VER_STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end

data/lib/sensu-plugins-process-checks.rb

@@ -0,0 +1 @@
+require 'sensu-plugins-process-checks/version'

metadata

@@ -0,0 +1,236 @@
+--- !ruby/object:Gem::Specification
+name: cb_sensu_check_processes
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Sensu-Plugins and contributors
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: english
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: sensu-plugin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: sys-proctable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+- !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: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !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.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.30'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.30'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Sensu plugins for checking running processes
+email: "<sensu-users@googlegroups.com>"
+executables:
+- metrics-process-status.rb
+- check-cmd.rb
+- check-process-restart.rb
+- check-process.rb
+- check-threads-count.rb
+- metrics-processes-threads-count.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- bin/check-cmd.rb
+- bin/check-process-restart.rb
+- bin/check-process.rb
+- bin/check-threads-count.rb
+- bin/metrics-process-status.rb
+- bin/metrics-processes-threads-count.rb
+- bin/process-uptime-metrics.sh
+- lib/sensu-plugins-process-checks.rb
+- lib/sensu-plugins-process-checks/version.rb
+homepage: https://github.com/sensu-plugins/sensu-plugins-process-checks
+licenses:
+- MIT
+metadata:
+  maintainer: "@rmc3"
+  development_status: active
+  production_status: unstable - testing recommended
+  release_draft: 'false'
+  release_prerelease: 'false'
+post_install_message: You can use the embedded Ruby by setting EMBEDDED_RUBY=true
+  in /etc/default/sensu
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+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: Sensu plugins for checking running processes
+test_files: []
+has_rdoc: