sensu-plugins-java 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67ebd54061f265732e24b02bcc4a07893ebe0897
-  data.tar.gz: cfb12fb13e140d225aa0c70a88f0a4712e04315d
+  metadata.gz: ab00e78e1241adeeeb6695522213bede8f50ce69
+  data.tar.gz: 542d2d4ec7fae55dc6041576b35c4cd64eecdbee
 SHA512:
-  metadata.gz: fa6a77231c5a163b1eca5fec1281881ee95645bd96de298870f2af155c2a6abf6427508cc9e71f705d381a9d58d07dba30a745639a04cb53ee87335a97e1d05b
-  data.tar.gz: 08278681637d5a3fd280ad88a887a85def2809e43b1a0b1180df73e9d5fa0db444f34a03a977afaef9b5e2038e0493da95cc348343c56a76120bf0008b8e5a0e
+  metadata.gz: 9bd326b76ba1d35b660760574812846e4a611c4069e8e512574ceefa3e243853109c1c9c40a78514bfa868abb8354f83c8659e01bcb0757c05961d2d13d5c5be
+  data.tar.gz: 92856fcddeb6796053fb6e4463b66a1564c331f85d0b7888d6bb8a2ded9357a771e7b0f6a3c0cc9b941d177e1a8011218d17c5212fe71a8892336b5d902d3daf

data/CHANGELOG.md

@@ -3,6 +3,14 @@ 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.6] - 2017-06-09
+### Changed
+- refactor of check-java-heap-pcnt.sh, metrics-java-heap-graphite.sh made java version agnostic. jstat -gc returns 17 columns and has metaspace in java8. jstat -gc returns 15 columns and has permgen space in java 7, 6. These will work for both versions.
+- run jstat only once for performance improvement
+- Fix issue #11.
+- java-heap-pcnt, check-java-heap-pcnt-java8, metrics-java-heap-graphite-java8 could be removed in a future release
+
 ## [0.0.5] - 2016-11-02
 ### Changed
 - metrics-jstat.py: support added for py2.6 (RHEL/CentOS 6.x)
@@ -36,7 +44,8 @@ This CHANGELOG follows the format listed at [Keep A Changelog](http://keepachang
 ### Added
 - initial release
 
-[Unreleased]: https://github.com/sensu-plugins/sensu-plugins-java/compare/0.0.4...HEAD
+[Unreleased]: https://github.com/sensu-plugins/sensu-plugins-java/compare/0.0.6...HEAD
+[0.0.6]: https://github.com/sensu-plugins/sensu-plugins-java/compare/0.0.4...0.0.6
 [0.0.4]: https://github.com/sensu-plugins/sensu-plugins-java/compare/0.0.3...0.0.4
 [0.0.3]: https://github.com/sensu-plugins/sensu-plugins-java/compare/0.0.2...0.0.3
 [0.0.2]: https://github.com/sensu-plugins/sensu-plugins-java/compare/0.0.1...0.0.2

data/README.md

@@ -12,10 +12,13 @@
  * bin/check-java-permgen.rb
  * bin/java-heap-pcnt.sh - deprecated, use check-java-heap-pcnt
  * bin/check-java-heap-pcnt.sh
+ * bin/check-java-heap-pcnt-java8.sh - supports java 8 and multiple java processes
  * bin/check-java-heap-pcnt.rb - ruby wrapper for check-java-heap-pcnt.sh
  * bin/metrics-java-heap-graphite.sh
+ * bin/metrics-java-heap-graphite-java8.sh - supports java 8 and multiple java processes
  * metrics-java-heap-graphite.rb - ruby wrapper for metrics-java-heap-graphite.sh
  * bin/metrics-jstat.py
+ * bin/metrics-jstat-java8.py - supports java 8
  * bin/metrics-jstat.rb - ruby wrapper script for metrics-jstat.py
 
 ## Usage

data/bin/check-java-heap-pcnt-java8.sh

@@ -0,0 +1,104 @@
+#!/usr/bin/env bash
+#
+# Evaluate percentage of heap usage on specfic Tomcat backed JVM from Linux based systems based on percentage
+# This was forked from Sensu Community Plugins
+
+# Date: 2017-02-10
+# Modified: Nikoletta Kyriakidou
+
+# You must have openjdk-8-jdk and openjdk-8-jre packages installed
+# http://openjdk.java.net/install/
+#
+# Also make sure the user "sensu" can sudo without password
+
+# #RED
+while getopts 'w:c:n:o:j:hp' OPT; do
+  case $OPT in
+    w)  WARN=$OPTARG;;
+    c)  CRIT=$OPTARG;;
+    n)  NAME=$OPTARG;;
+    o)  OPTIONS=$OPTARG;;
+    j)  JAVA_BIN=$OPTARG;;
+    h)  hlp="yes";;
+    p)  perform="yes";;
+    *)  unknown="yes";;
+  esac
+done
+
+# usage
+HELP="
+    usage: $0 [ -n value -w value -c value -o value -p -h ]
+
+        -n --> Name of JVM process < value
+        -w --> Warning Percentage < value
+        -c --> Critical Percentage < value
+        -o --> options to pass to jps
+        -j --> path to java bin dir (include trailing /)
+        -p --> print out performance data
+        -h --> print this help screen
+"
+
+if [ "$hlp" = "yes" ]; then
+  echo "$HELP"
+  exit 0
+fi
+
+WARN=${WARN:=0}
+CRIT=${CRIT:=0}
+NAME=${NAME:=0}
+JAVA_BIN=${JAVA_BIN:=""}
+
+#Get PIDs of JVM.
+#At this point grep for the names of the java processes running your jvm.
+PIDS=$(sudo ${JAVA_BIN}jps $OPTIONS | grep " $NAME$" | awk '{ print $1}')
+
+projectSize=$(printf "%s\n" $(printf "$PIDS" | wc -w))
+
+i=0
+for PID in $PIDS
+do
+	#Get heap capacity of JVM
+	TotalHeap=$(sudo ${JAVA_BIN}jstat -gccapacity $PID  | tail -n 1 | awk '{ print ($4 + $5 + $6 + $10) / 1024 }')
+
+	#Determine amount of used heap JVM is using
+	UsedHeap=$(sudo ${JAVA_BIN}jstat -gc $PID  | tail -n 1 | awk '{ print ($3 + $4 + $6 + $8) / 1024 }')
+
+	#Get heap usage percentage
+	HeapPer=$(echo "scale=3; $UsedHeap / $TotalHeap * 100" | bc -l| cut -d "." -f1)
+
+
+	if [ "$HeapPer" = "" ]; then
+	  echo "MEM UNKNOWN -"
+	  codes[i]=3
+	fi
+
+	#For multiple projects running we need to print the name
+	if [ "$projectSize" -ne 1 ]; then
+		projectName=$(sudo jps | grep $PID | awk '{ print $2}' | cut -d. -f1)
+		project=$projectName
+	fi
+
+	if [ "$perform" = "yes" ]; then
+	  output="$project jvm heap usage: $HeapPer% | heap usage="$HeapPer"%;$WARN;$CRIT;0"
+	else
+	  output="$project jvm heap usage: $HeapPer% | $UsedHeap MB out of $TotalHeap MB"
+	fi
+
+	if (( $HeapPer >= $CRIT )); then
+	  echo "MEM CRITICAL - $output"
+ 	  codes[i]=2
+	elif (( $HeapPer >= $WARN )); then
+	  echo "MEM WARNING - $output"
+	  codes[i]=1
+	else
+	  echo "MEM OK - $output"
+	  codes[i]=0
+	fi
+	i+=1
+done
+
+if (($projectSize -ne $1 && ${codes[0]} != "0")); then
+	exit ${codes[1]}
+else
+	exit ${codes[0]}
+fi

data/bin/check-java-heap-pcnt.sh

@@ -6,12 +6,15 @@
 # Date: 2013-9-30
 # Modified: Mario Harvey - badmadrad.com
 
-# You must have openjdk-7-jdk and openjdk-7-jre packages installed
+# Date: 2017-06-06
+# Modified: Nic Scott - re-work to be java version agnostic
+
+# depends on jps and jstat in openjdk-devel in openjdk-<VERSION>-jdk and
+# openjdk-<VERSION>-jre packages being installed
 # http://openjdk.java.net/install/
 
-# Also make sure the user "sensu" can sudo without password
+# Also make sure the user "sensu" can sudo jps and jstat without password
 
-# #RED
 while getopts 'w:c:n:o:j:hp' OPT; do
   case $OPT in
     w)  WARN=$OPTARG;;
@@ -27,15 +30,14 @@ done
 
 # usage
 HELP="
-    usage: $0 [ -n value -w value -c value -o value -p -h ]
-
-        -n --> Name of JVM process < value
-        -w --> Warning Percentage < value
-        -c --> Critical Percentage < value
-        -o --> options to pass to jps
-        -j --> path to java bin dir (include trailing /)
-        -p --> print out performance data
-        -h --> print this help screen
+usage: $0 [ -n value -w value -c value -o value -p -h ]
+  -n --> Name of JVM process < value
+  -w --> Warning Percentage < value
+  -c --> Critical Percentage < value
+  -o --> options to pass to jps
+  -j --> path to java bin dir (include trailing /)
+  -p --> print out performance data
+  -h --> print this help screen
 "
 
 if [ "$hlp" = "yes" ]; then
@@ -50,13 +52,29 @@ JAVA_BIN=${JAVA_BIN:=""}
 
 #Get PID of JVM.
 #At this point grep for the name of the java process running your jvm.
-PID=$(sudo ${JAVA_BIN}jps $OPTIONS | grep $NAME | awk '{ print $1}')
+PID=$(sudo ${JAVA_BIN}jps $OPTIONS | grep " $NAME$" | awk '{ print $1}')
+COUNT=$(echo $PID | wc -w)
+if [ $COUNT != 1 ]; then
+  echo "$COUNT java process(es) found with name $NAME"
+  exit 3
+fi
 
-#Get heap capacity of JVM
-TotalHeap=$(sudo ${JAVA_BIN}jstat -gccapacity $PID  | tail -n 1 | awk '{ print ($4 + $5 + $6 + $10) / 1024 }')
+JSTAT=$(sudo ${JAVA_BIN}jstat -gc $PID  | tail -n 1)
 
-#Determine amount of used heap JVM is using
-UsedHeap=$(sudo ${JAVA_BIN}jstat -gc $PID  | tail -n 1 | awk '{ print ($3 + $4 + $6 + $8 + $10) / 1024 }')
+# Java 8 jstat -gc returns 17 columns Java 7 returns 15
+if [[ ${#JSTAT[@]} -gt 15 ]]; then
+  # Metaspace is not a part of heap in Java 8
+  #Get heap capacity of JVM
+  TotalHeap=$(echo $JSTAT | awk '{ print ($1 + $2 + $5 + $7) / 1024 }')
+  #Determine amount of used heap JVM is using
+  UsedHeap=$(echo $JSTAT | awk '{ print ($3 + $4 + $6 + $8) / 1024 }')
+else
+  # PermGen is part of heap in Java <8
+  #Get heap capacity of JVM
+  TotalHeap=$(echo $JSTAT | awk '{ print ($1 + $2 + $5 + $7 + $9) / 1024 }')
+  #Determine amount of used heap JVM is using
+  UsedHeap=$(echo $JSTAT | awk '{ print ($3 + $4 + $6 + $8 + $10) / 1024 }')
+fi
 
 #Get heap usage percentage
 HeapPer=$(echo "scale=3; $UsedHeap / $TotalHeap * 100" | bc -l| cut -d "." -f1)

data/bin/java-heap-pcnt.sh

@@ -45,7 +45,12 @@ NAME=${NAME:=0}
 
 #Get PID of JVM.
 #At this point grep for the name of the java process running your jvm.
-PID=$(sudo jps | grep $NAME | awk '{ print $1}')
+PID=$(sudo jps | grep " $NAME$" | awk '{ print $1}')
+COUNT=$(echo $PID | wc -w)
+if [ $COUNT != 1 ]; then
+    echo "$COUNT java process(es) found with name $NAME"
+    exit 3
+fi
 
 #Get heap capacity of JVM
 TotalHeap=$(sudo jstat -gccapacity $PID  | tail -n 1 | awk '{ print ($4 + $5 + $6 + $10) / 1024 }')

data/bin/metrics-java-heap-graphite-java8.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+#
+# Collect metrics on your JVM and allow you to trace usage in graphite
+
+# Modified: Nikoletta Kyriakidou
+
+# You must have openjdk-8-jdk and openjdk-8-jre packages installed
+# http://openjdk.java.net/install/
+
+# Also make sure the user "sensu" can sudo without password
+
+# #RED
+while getopts 's:n:h' OPT; do
+case $OPT in
+s) SCHEME=$OPTARG;;
+n) NAME=$OPTARG;;
+h) hlp="yes";;
+esac
+done
+#usage
+HELP="
+        usage $0 [ -n value -s value -h ]
+                -n --> NAME or name of jvm process < value
+		-s --> SCHEME or server name ex. :::name::: < value
+                -h --> print this help screen
+"
+if [ "$hlp" = "yes" ]; then
+        echo "$HELP"
+        exit 0
+        fi
+
+SCHEME=${SCHEME:=0}
+NAME=${NAME:=0}
+
+#Get PIDs of JVM.
+#At this point grep for the names of the java processes running your jvm.
+PID=$(sudo jps | grep " $NAME$" | awk '{ print $1}')
+for PID in $PIDS
+do
+  #Get heap capacity of JVM
+  TotalHeap=$(sudo jstat -gccapacity $PID  | tail -n 1 | awk '{ print ($4 + $5 + $6 + $10) / 1024 }')
+
+  #Determine amount of used heap JVM is using
+  UsedHeap=$(sudo jstat -gc $PID  | tail -n 1 | awk '{ print ($3 + $4 + $6 + $8) / 1024 }')
+
+  #Determine Old Space Utilization
+  OldGen=$(sudo jstat -gc $PID  | tail -n 1 | awk '{ print ($8) / 1024 }')
+
+  #Determine Eden Space Utilization
+  ParEden=$(sudo jstat -gc $PID  | tail -n 1 | awk '{ print ($6) / 1024 }')
+
+  #Determine Survivor Space utilization
+  ParSurv=$(sudo jstat -gc $PID  | tail -n 1 | awk '{ print ($3 + $4) / 1024 }')
+
+  #For multiple projects running we need to print the name
+	projectSize=$(printf "%s\n" $(printf "$PIDS" | wc -w))
+
+	if [ "$projectSize" -ne 1 ]; then
+		projectName=$(sudo jps | grep $PID | awk '{ print $2}' | cut -d. -f1)
+		project=$projectName
+	fi
+
+  echo "JVMs.$SCHEME.$project.Committed_Heap $TotalHeap `date '+%s'`"
+  echo "JVMs.$SCHEME.$project.Used_Heap $UsedHeap `date '+%s'`"
+  echo "JVMs.$SCHEME.$project.Eden_Util $ParEden `date '+%s'`"
+  echo "JVMs.$SCHEME.$project.Survivor_Util $ParSurv `date '+%s'`"
+  echo "JVMs.$SCHEME.$project.Old_Util $OldGen `date '+%s'`"
+done

data/bin/metrics-java-heap-graphite.sh

@@ -1,62 +1,97 @@
 #!/usr/bin/env bash
 #
-# Collect metrics on your JVM and allow you to trace usage in graphite
+# Collect metrics on your JVMs and allow you to trace usage in graphite
 
 # Modified: Mario Harvey - badmadrad.com
 
-# You must have openjdk-7-jdk and openjdk-7-jre packages installed
+# Date: 2017-06-06
+# Modified: Nic Scott - re-work to be java version agnostic
+
+# depends on jps and jstat in openjdk-devel in openjdk-<VERSION>-jdk and
+# openjdk-<VERSION>-jre packages being installed
 # http://openjdk.java.net/install/
 
-# Also make sure the user "sensu" can sudo without password
+# Also make sure the user "sensu" can sudo jps and jstat without password
 
-# #RED
 while getopts 's:n:h' OPT; do
-case $OPT in
-s) SCHEME=$OPTARG;;
-n) NAME=$OPTARG;;
-h) hlp="yes";;
-esac
+  case $OPT in
+    s) SCHEME=$OPTARG;;
+    n) NAME=$OPTARG;;
+    h) hlp="yes";;
+  esac
 done
+
 #usage
 HELP="
-        usage $0 [ -n value -s value -h ]
-                -n --> NAME or name of jvm process < value
-		-s --> SCHEME or server name ex. :::name::: < value
-                -h --> print this help screen
+usage $0 [ -n value -s value -h ]
+-n --> NAME or name of jvm process < value
+-s --> SCHEME or server name ex. :::name::: < value
+-h --> print this help screen
 "
 if [ "$hlp" = "yes" ]; then
-        echo "$HELP"
-        exit 0
-        fi
+  echo "$HELP"
+  exit 0
+fi
 
 SCHEME=${SCHEME:=0}
 NAME=${NAME:=0}
+JAVA_BIN=${JAVA_BIN:=""}
 
 #Get PID of JVM.
 #At this point grep for the name of the java process running your jvm.
-PID=$(sudo jps | grep $NAME | awk '{ print $1}')
+PIDS=$(sudo ${JAVA_BIN}jps $OPTIONS | grep " $NAME$" | awk '{ print $1 }')
+COUNT=$(echo $PID | wc -w)
+for PID in $PIDS
+do
+
+  project=$(sudo jps | grep $PID | awk '{ print $2 }' | cut -d. -f1)
 
-#Get heap capacity of JVM
-TotalHeap=$(sudo jstat -gccapacity $PID  | tail -n 1 | awk '{ print ($4 + $5 + $6 + $10) / 1024 }')
+  JSTAT=$(sudo ${JAVA_BIN}jstat -gc $PID  | tail -n 1)
 
-#Determine amount of used heap JVM is using
-UsedHeap=$(sudo jstat -gc $PID  | tail -n 1 | awk '{ print ($3 + $4 + $6 + $8 + $10) / 1024 }')
+  # Java version indifferent memory stats
+  #Determine Old Space Utilization
+  OldGen=$(echo $JSTAT | awk '{ print ($8) / 1024 }')
 
-#Determine Old Space Utilization
-OldGen=$(sudo jstat -gc $PID  | tail -n 1 | awk '{ print ($8) / 1024 }')
+  #Determine Eden Space Utilization
+  ParEden=$(echo $JSTAT | awk '{ print ($6) / 1024 }')
 
-#Determine Permanent Space Utilization
-PermGen=$(sudo jstat -gc $PID  | tail -n 1 | awk '{ print ($10) / 1024 }')
+  #Determine Survivor Space utilization
+  ParSurv=$(echo $JSTAT | awk '{ print ($3 + $4) / 1024 }')
 
-#Determine Eden Space Utilization
-ParEden=$(sudo jstat -gc $PID  | tail -n 1 | awk '{ print ($6) / 1024 }')
+  # Java version-specific memory stats
+  # Java 8 jstat -gc returns 17 columns Java 7 returns 15
+  if [[ ${#JSTAT[@]} -gt 15 ]]; then
+    # Metaspace is NOT a part of heap in Java 8
+    #Get heap capacity of JVM
+    TotalHeap=$(echo $JSTAT | awk '{ print ($1 + $2 + $5 + $7) / 1024 }')
+    #Determine amount of used heap JVM is using
+    UsedHeap=$(echo $JSTAT | awk '{ print ($3 + $4 + $6 + $8) / 1024 }')
+    #Get MetaSpace capacity of JVM
+    TotalMeta=$(echo $JSTAT | awk '{ print ($9) / 1024 }')
+    #Determine Meta Space Utilization
+    UsedMeta=$(echo $JSTAT | awk '{ print ($10) / 1024 }')
 
-#Determine Survivor Space utilization
-ParSurv=$(sudo jstat -gc $PID  | tail -n 1 | awk '{ print ($3 + $4) / 1024 }')
+    echo "JVMs.$SCHEME.$project.Meta_Capacity $TotalMeta `date '+%s'`"
+    echo "JVMs.$SCHEME.$project.Meta_Util $UsedMeta `date '+%s'`"
 
-echo "JVMs.$SCHEME.Committed_Heap $TotalHeap `date '+%s'`"
-echo "JVMs.$SCHEME.Used_Heap $UsedHeap `date '+%s'`"
-echo "JVMs.$SCHEME.Eden_Util $ParEden `date '+%s'`"
-echo "JVMs.$SCHEME.Survivor_Util $ParSurv `date '+%s'`"
-echo "JVMs.$SCHEME.Old_Util $OldGen `date '+%s'`"
-echo "JVMs.$SCHEME.Perm_Util $PermGen `date '+%s'`"
+  else
+    # PermGen IS part of heap in Java <8
+    #Get heap capacity of JVM
+    TotalHeap=$(echo $JSTAT | awk '{ print ($1 + $2 + $5 + $7 + $9) / 1024 }')
+    #Determine amount of used heap JVM is using
+    UsedHeap=$(echo $JSTAT | awk '{ print ($3 + $4 + $6 + $8 + $10) / 1024 }')
+    #Get PermGen capacity of JVM
+    TotalPerm=$(echo $JSTAT | awk '{ print ($9) / 1024 }')
+    #Determine PermGen Space Utilization
+    UsedPerm=$(echo $JSTAT | awk '{ print ($10) / 1024 }')
+
+    echo "JVMs.$SCHEME.$project.Perm_Capacity $TotalPerm `date '+%s'`"
+    echo "JVMs.$SCHEME.$project.Perm_Util $UsedPerm `date '+%s'`"
+  fi
+  echo "JVMs.$SCHEME.$project.Committed_Heap $TotalHeap `date '+%s'`"
+  echo "JVMs.$SCHEME.$project.Heap_Util $UsedHeap `date '+%s'`"
+  echo "JVMs.$SCHEME.$project.Eden_Util $ParEden `date '+%s'`"
+  echo "JVMs.$SCHEME.$project.Survivor_Util $ParSurv `date '+%s'`"
+  echo "JVMs.$SCHEME.$project.Old_Util $OldGen `date '+%s'`"
+
+done

data/bin/metrics-jstat-java8.py

@@ -0,0 +1,316 @@
+#!/usr/bin/python -tt
+#
+# DESCRIPTION:
+# Collect everything that can be collected out of jstat (shells out 5 times)
+# and spits to STDOUT in a graphite ready format, thus meant to be used with a
+# graphite metric tcp handler.
+# Since it shells out to jps(1) you will need the user running the sensu client
+# executing this script to be able to run jps as the same user running the JVM
+# you are trying to get stats from.
+# In addition it will also need to be able to run jstat(2) against the JVM
+# This can be all achieved by allowing the script to be ran as the same user
+# running the JVM, for instance by prepending "sudo -u <jvm_process_owner>"
+# in the command check definition (with the proper sudoers config to allow this
+# with no password being asked)
+#
+# The graphite node is composed of an optional root node (defaults to 'metrics')
+# the specified FQDN "reversed" ('foo.bar.com' becomes 'com.bar.foo') and an
+# optional scheme (defaults to 'jstat')
+#
+# (1) http://docs.oracle.com/javase/8/docs/technotes/tools/share/jps.html
+# (2) http://docs.oracle.com/javase/8/docs/technotes/tools/share/jstat.html
+#
+# OUTPUT:
+# Graphite plain-text format (name value timestamp\n)
+#
+# DEPENDENCIES:
+# Python 2.7 (untested on python 3 but should work fine)
+# Java 8
+#
+#
+# Released under the same terms as Sensu (the MIT license); see LICENSE
+# for details.
+
+# #RED
+import logging
+import logging.handlers
+import optparse
+import sys
+import time
+
+"""
+Python 2.6 support for check_output:
+http://stackoverflow.com/questions/4814970/subprocess-check-output-doesnt-seem-to-exist-python-2-6-5
+"""
+try:
+    from subprocess import STDOUT, check_output, CalledProcessError
+except ImportError:  # pragma: no cover
+    # python 2.6 doesn't include check_output
+    # monkey patch it in!
+    import subprocess
+    STDOUT = subprocess.STDOUT
+
+    def check_output(*popenargs, **kwargs):
+        if 'stdout' in kwargs:  # pragma: no cover
+            raise ValueError('stdout argument not allowed, '
+                             'it will be overridden.')
+        process = subprocess.Popen(stdout=subprocess.PIPE,
+                                   *popenargs, **kwargs)
+        output, _ = process.communicate()
+        retcode = process.poll()
+        if retcode:
+            cmd = kwargs.get("args")
+            if cmd is None:
+                cmd = popenargs[0]
+            raise subprocess.CalledProcessError(retcode, cmd,
+                                                output=output)
+        return output
+    subprocess.check_output = check_output
+
+    # overwrite CalledProcessError due to `output`
+    # keyword not being available (in 2.6)
+    class CalledProcessError(Exception):
+
+        def __init__(self, returncode, cmd, output=None):
+            self.returncode = returncode
+            self.cmd = cmd
+            self.output = output
+
+        def __str__(self):
+            return "Command '%s' returned non-zero exit status %d" % (
+                self.cmd, self.returncode)
+    subprocess.CalledProcessError = CalledProcessError
+
+class JstatMetricsToGraphiteFormat(object):
+  '''Prints jstat metrics to stdout in graphite format
+
+  Shells out to run jstat using the JVM id found via jps (also shelled out) and
+  passed argument to print to STDOUT (for use with sensu) the metrics value.
+  Jstat column titles are replaced with more explanatory names. Requires to be
+  ran as a user that can get the JVM id via jps and run jstat on that JVM'''
+
+  def main(self):
+    # Setting up logging to syslog
+    try:
+      logger = logging.getLogger(__name__)
+      logger.setLevel(logging.DEBUG)
+
+      formatter = logging.Formatter("%(pathname)s: %(message)s")
+
+      handler = logging.handlers.SysLogHandler(address = '/dev/log')
+      handler.setFormatter(formatter)
+      logger.addHandler(handler)
+    except Exception:
+      # booting is more important than logging
+      logging.critical("Failed to configure syslog handler")
+
+    parser = optparse.OptionParser()
+
+    parser.add_option('-g', '--graphite-base',
+      default = 'metrics',
+      dest    = 'graphite_base',
+      help    = 'The base graphite node',
+      metavar = 'NODE')
+
+    parser.add_option('-D', '--debug',
+      action  = 'store_true',
+      default = False,
+      dest    = 'debug',
+      help    = 'Debug output (NOISY!)')
+
+    parser.add_option('-H', '--host',
+      default = None,
+      dest    = 'hostname',
+      help    = 'The name of the host to run jstat on',
+      metavar = 'HOST')
+
+    parser.add_option('-j', '--java-name',
+      default = None,
+      dest    = 'java_app_name',
+      help    = 'The name of the Java app to call jstat on',
+      metavar = 'JAVANAME')
+
+    parser.add_option('-s', '--scheme',
+      default = 'jstat',
+      dest    = 'service',
+      help    = 'Metric naming scheme, text to prepend to metric',
+      metavar = 'SERVICE')
+
+    (options, args) = parser.parse_args()
+
+    if not options.java_app_name:
+      parser.error('A Java app name is required')
+
+    if not options.hostname:
+      parser.error('A host name is required')
+
+    # Replace jstat colums titles with more explicit ones
+    # Stats coming from -gc
+    metric_maps_gc = { "S0U": "survivor_space_0_utilization_KB",
+                       "S1U": "survivor_space_1_utilization_KB",
+                       "EC": "current_eden_space_capacity_KB",
+                       "EU": "eden_space_utilization_KB",
+                       "OC": "current_old_space_capacity_KB",
+                       "OU": "old_space_utilization_KB",
+                       "MC": "metaspace_capacity_KB",
+					   "MU": "metacspace_utilization_KB",
+					   "CCSC": "compressed_class_space_capacity_KB",
+					   "CCSU": "compressed_class_space_used_KB",
+                       "YGC": "number_of_young_generation_GC_events",
+                       "YGCT": "young_generation_garbage_collection_time",
+                       "FGC": "number_of_stop_the_world_events",
+                       "FGCT": "full_garbage_collection_time",
+                       "GCT": "total_garbage_collection_time"
+                       }
+    # Stats coming from -gccapacity
+    metric_maps_gccapacity = { "NGCMN": "minimum_size_of_new_area",
+                               "NGCMX": "maximum_size_of_new_area",
+                               "NGC": "current_size_of_new_area",
+                               "OGCMN": "minimum_size_of_old_area",
+                               "OGCMX": "maximum_size_of_old_area",
+                               "OGC": "current_size_of_old_area",
+                               "MCMN": "minimum_metaspace_capacity",
+							   "MCMX": "maximum_metaspace_capacity",
+							   "MC": "metaspace_capacity",
+							   "CCSMN": "compressed_class_space_minimum_capacity",
+							   "CCSMX": "compressed_class_space_maximum_capacity",
+							   "CCSC": "compressed_class_space_capacity"
+                               }
+
+    # Stats coming from -gcnew
+    metric_maps_gcnew = { "TT" : "tenuring_threshold",
+                          "MTT": "maximum_tenuring_threshold",
+                          "DSS": "adequate_size_of_survivor"
+                           }
+
+    # Stats coming from -compiler
+    metric_maps_compiler = {
+        "Compiled": "compilation_tasks_performed",
+        "Failed": "compilation_tasks_failed",
+        "Invalid": "compilation_tasks_invalidated",
+        "Time": "time_spent_on_compilation_tasks"
+        }
+
+    # Stats coming from -class
+    ## Note that since "Bytes" appears twice in jstat -class output we need
+    ## to differentiate them by colum number
+    metric_maps_class = {
+        "Loaded": "loaded_classes",
+        "Bytes_column2": "loaded_KB",
+        "Unloaded": "unloaded_classes",
+        "Bytes_column4": "unloaded_KB",
+        "Time": "time_spent_on_class_load_unload"
+        }
+
+    def get_jstat_metrics(jstat_option, lvmid, metric_maps):
+      '''Runs jstat with provided option on provided host, returns mapped stats'''
+      def is_number(s):
+        '''returns true if string is a number'''
+        try:
+          float(s)
+          return True
+        except ValueError:
+          pass
+        try:
+          import unicodedata
+          unicodedata.numeric(s)
+          return True
+        except (TypeError, ValueError):
+          pass
+        return False
+
+      # Get stats from jstat stdout
+      try :
+        jstat_gc_out = check_output(["jstat", jstat_option, lvmid])
+      except Exception as e:
+        if options.debug:
+          print e
+          sys.exit(1)
+        logger.critical(e)
+        sys.exit(1)
+
+      values_all = jstat_gc_out.split("\n")[1].split()
+      # Remove non number strings
+      values = [ jstat_val for jstat_val in values_all if is_number(jstat_val) ]
+      # Transform float strings to integers
+      values = map(int, map(float, values))
+
+      # Change stats titles to long names
+      titles = jstat_gc_out.split("\n")[0].split()
+      # Deal with -class special "double Bytes" output
+      if jstat_option == "-class":
+       titles[2] = "Bytes_column2"
+       titles[4] = "Bytes_column4"
+      return dict([(metric_maps[title], values[position]) for position, title in enumerate(titles) if title in metric_maps])
+
+    # Get lvmid (JVM id)
+    try :
+      jps_out = check_output(["jps", "-v"])
+    except Exception as e:
+      if options.debug:
+        print e
+        sys.exit(1)
+      logger.critical(e)
+      sys.exit(1)
+
+    lvmid = False
+    for line in jps_out.split("\n"):
+      if options.java_app_name in line:
+        lvmid = line.split()[0]
+
+    if not lvmid:
+      if options.debug:
+        print "Could not get an LVM id"
+        sys.exit(1)
+      logger.critical("Could not get an LVM id")
+      sys.exit(1)
+
+    # Get stats from -gc
+    gc_stats = get_jstat_metrics("-gc", lvmid, metric_maps_gc)
+    if options.debug:
+      print gc_stats
+    # Get stats from -gccapacity
+    gccapacity_stats = get_jstat_metrics("-gccapacity",
+        lvmid, metric_maps_gccapacity)
+    if options.debug:
+      print gccapacity_stats
+    # Get stats from -gcnew
+    gcnew_stats = get_jstat_metrics("-gcnew", lvmid, metric_maps_gcnew)
+    if options.debug:
+      print gccapacity_stats
+
+    # Put all GC related stats to the same dict
+    gc_stats.update(gccapacity_stats)
+    gc_stats.update(gcnew_stats)
+
+    # Get stats from -compiler
+    compiler_stats = get_jstat_metrics("-compiler", lvmid, metric_maps_compiler)
+    if options.debug:
+      print compiler_stats
+
+    # Get stats from -class
+    class_stats = get_jstat_metrics("-class", lvmid, metric_maps_class)
+    if options.debug:
+      print class_stats
+
+    # Print to stdout in graphite format
+    now = time.time()
+    graphite_base = '.'.join([options.graphite_base,
+        '.'.join(reversed(options.hostname.split('.')))])
+
+    for metric in gc_stats:
+      print "%s.%s.jvm.gc.%s %s %d" % (graphite_base, options.service, metric,
+          gc_stats[metric], now)
+
+    for metric in compiler_stats:
+      print "%s.%s.jvm.compiler.%s %s %d" % (graphite_base, options.service,
+          metric, compiler_stats[metric], now)
+
+    for metric in class_stats:
+      print "%s.%s.jvm.class.%s %s %d" % (graphite_base, options.service,
+          metric, class_stats[metric], now)
+
+    sys.exit(0)
+
+if '__main__' == __name__:
+  JstatMetricsToGraphiteFormat().main()

data/lib/sensu-plugins-java/version.rb

@@ -2,7 +2,7 @@ module SensuPluginsJava
   module Version
     MAJOR = 0
     MINOR = 0
-    PATCH = 5
+    PATCH = 6
 
     VER_STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sensu-plugins-java
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Sensu-Plugins and contributors
@@ -177,12 +177,15 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
+- bin/check-java-heap-pcnt-java8.sh
 - bin/check-java-heap-pcnt.rb
 - bin/check-java-heap-pcnt.sh
 - bin/check-java-permgen.rb
 - bin/java-heap-pcnt.sh
+- bin/metrics-java-heap-graphite-java8.sh
 - bin/metrics-java-heap-graphite.rb
 - bin/metrics-java-heap-graphite.sh
+- bin/metrics-jstat-java8.py
 - bin/metrics-jstat.py
 - bin/metrics-jstat.rb
 - lib/sensu-plugins-java.rb