arborist-snmp 0.1.0.pre20161005111600 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 639227f1252bedce794f5bfabada161a9ff3d8a2
-  data.tar.gz: 713cc9b8bf1fc6fc467b688d9d38656be3e193c9
+  metadata.gz: 833fc064ac6b821016f02ec2b427c7861cc4ebd2
+  data.tar.gz: d14a89c993c13e874b9201388999bb77ac85c06f
 SHA512:
-  metadata.gz: 94b2a8a87fe45817464ddff645ab1058a6ab3577afd893cfc0b2837737ce3240567cf52c6982379a2886ba9590cf0674106ab601cf5ad0e82cc869e005754ffb
-  data.tar.gz: b34cc56ac99c63333a020b5ecf201daf74d310dbe2447fec3568713e128fec3c0cdaaa36a15d7833b4cc2975f5bb14943b9127ef3b62ca3c884106fc1a203212
+  metadata.gz: be00731e69eae712e71e9881abb20ba9d1393de4acad424b8b2c7225b95d351e211a9c20551556f76fde34e59a551ff2716f9f220a247afa35b529b688301ca5
+  data.tar.gz: bd6b4d1292adec637932fc8edccd62fe1db5fbaea2350995ab9c504e2eb002e36470ca7280742fb9b4eb231523fc8744bcb0d5135017bdf4bae8e23c8d5757bd

data/lib/arborist/monitor/snmp.rb

@@ -1,402 +1,144 @@
 # -*- ruby -*-
 # vim: set noet nosta sw=4 ts=4 :
 #encoding: utf-8
-#
+
+require 'arborist/monitor' unless defined?( Arborist::Monitor )
+require 'net-snmp2'
+
 # SNMP checks for Arborist.  Requires an SNMP agent to be installed
-# on target machine, and the various "pieces" enabled.  For your platform.
+# on target machine, and the various "pieces" enabled for your platform.
 #
 # For example, for disk monitoring with Net-SNMP, you'll want to set
 # 'includeAllDisks' in the snmpd.conf. bsnmpd on FreeBSD benefits from
 # the 'bsnmp-ucd' package.  Etc.
 #
+module Arborist::Monitor::SNMP
+	using Arborist::TimeRefinements
+	extend Configurability, Loggability
 
-require 'loggability'
-require 'arborist/monitor' unless defined?( Arborist::Monitor )
-require 'snmp'
-
-using Arborist::TimeRefinements
-
-# SNMP specific monitors and monitor logic.
-#
-class Arborist::Monitor::SNMP
-	extend Loggability
-	log_to :arborist
-
-	# The version of this library.
-	VERSION = '0.1.0'
+	# Loggability API
+	log_to :arborist_snmp
 
-	# "Modes" that this monitor understands.
-	VALID_MODES = %i[ disk load memory swap process ]
+	# Always request the node addresses and any config.
+	USED_PROPERTIES = [ :addresses, :config ].freeze
 
 	# The OID that returns the system environment.
 	IDENTIFICATION_OID = '1.3.6.1.2.1.1.1.0'
 
-	# For net-snmp systems, ignore mount types that match
-	# this regular expression.  This includes null/union mounts
-	# and NFS, currently.
-	STORAGE_IGNORE = %r{25.3.9.(?:2|14)$}
-
-	# The OID that matches a local windows hard disk.  Anything else
-	# is a remote (SMB) mount.
-	WINDOWS_DEVICE = '1.3.6.1.2.1.25.2.1.4'
-
-	# OIDS required to pull disk information from net-snmp.
+	# Global defaults for instances of this monitor
 	#
-	STORAGE_NET_SNMP = [
-		'1.3.6.1.4.1.2021.9.1.2', # paths
-		'1.3.6.1.2.1.25.3.8.1.4', # types
-		'1.3.6.1.4.1.2021.9.1.9'  # percents
-	]
-
-	# OIDS required to pull disk information from Windows.
-	#
-	STORAGE_WINDOWS = [
-		'1.3.6.1.2.1.25.2.3.1.2', # types
-		'1.3.6.1.2.1.25.2.3.1.3', # paths
-		'1.3.6.1.2.1.25.2.3.1.5', # totalsize
-		'1.3.6.1.2.1.25.2.3.1.6'  # usedsize
-	]
-
-	# OIDS for discovering memory usage.
-	#
-	MEMORY = {
-		swap_total: '1.3.6.1.4.1.2021.4.3.0',
-		swap_avail: '1.3.6.1.4.1.2021.4.4.0',
-		mem_avail:  '1.3.6.1.4.1.2021.4.6.0'
-	}
-
-	# OIDS for discovering system load.
-	#
-	LOAD = {
-		five_min: '1.3.6.1.4.1.2021.10.1.3.2'
-	}
-
-	# OIDS for discovering running processes.
-	#
-	PROCESS = {
-		 list: '1.3.6.1.2.1.25.4.2.1.4',
-		 args: '1.3.6.1.2.1.25.4.2.1.5'
-	}
-
-
-	# Defaults for instances of this monitor
-	#
-	DEFAULT_OPTIONS = {
-		timeout:          2,
-		retries:          1,
-		community:        'public',
-		port:             161,
-		storage_error_at: 95,    # in percent full
-		load_error_at:    7,
-		swap_error_at:    25,    # in percent remaining
-		mem_error_at:     51200, # in kilobytes
-		processes:        []     # list of procs to match
-	}
-
-
-	### This monitor is complex enough to require creating an instance from the caller.
-	### Provide a friendlier error message the class was provided to exec() directly.
-	###
-	def self::run( nodes )
-		self.log.error "Please use %s via an instance." % [ self.name ]
-		return {}
+	configurability( 'arborist.snmp' ) do
+		setting :timeout, default: 2
+		setting :retries, default: 1
+		setting :community, default: 'public'
+		setting :version, default: '2c'
+		setting :port, default: 161
+
+		# How many hosts to check simultaneously
+		setting :batchsize, default: 25
 	end
 
-
-	### Create a new instance of this monitor.
-	###
-	def initialize( options=DEFAULT_OPTIONS )
-		options = DEFAULT_OPTIONS.merge( options || {} )
-
-		options.each do |name, value|
-			self.public_send( "#{name}=", value )
-		end
-	end
+	# Indicate to FFI that we're using threads.
+	Net::SNMP.thread_safe = true
 
 
-	# The mode (section) that this SMMP instance should check.
-	# Must be a +VALID_MODES+ mode.
-	attr_reader :mode
+	# The system type, as advertised.
+	attr_reader :system
 
-	# Mapping of node addresses back to the node identifier.
+	# The mapping of addresses back to node identifiers.
 	attr_reader :identifiers
 
-	# The results from the SNMP daemons, keyed by address.
+	# The results hash that is sent back to the manager.
 	attr_reader :results
 
-	# A timeout in seconds if the SNMP server isn't responding.
-	attr_accessor :timeout
-
-	# Retry with the timeout this many times.  Defaults to 1.
-	attr_accessor :retries
-
-	# The SNMP UDP port, if running on non default.
-	attr_accessor :port
-
-	# The community string to connect with.
-	attr_accessor :community
-
-	# Set an error if mount points are above this percentage.
-	attr_accessor :storage_error_at
 
-	# Set an error if the 5 minute load average exceeds this.
-	attr_accessor :load_error_at
-
-	# Set an error if used swap exceeds this percentage.
-	attr_accessor :swap_error_at
-
-	# Set an error if memory used is below this many kilobytes.
-	attr_accessor :mem_error_at
-
-	# Set an error if processes in this array aren't running.
-	attr_accessor :processes
-
-
-	### Set the SNMP mode, after validation.
-	###
-	def mode=( mode )
-		unless VALID_MODES.include?( mode.to_sym )
-			self.log.error "Unknown SNMP mode: %s" % [ mode ]
-			return nil
-		end
-
-		@mode    = mode.to_sym
-		@results = {}
-	end
-
-
-	### Perform the monitoring checks.
+	### Connect to the SNMP daemon and yield.
 	###
 	def run( nodes )
-		self.log.debug "Got nodes to SNMP check: %p" % [ nodes ]
-
-		# Sanity check.
-		#
-		unless self.mode
-			self.log.error "You must set the 'mode' for the SNMP monitor. (%s)" % [ VALID_MODES.join( ', ' ) ]
-			return {}
-		end
 
-		# Create mapping of addresses back to node identifiers.
+		# Create mapping of addresses back to node identifiers,
+		# and retain any custom (overrides) config per node.
 		#
-		@identifiers = nodes.each_with_object({}) do |(identifier, props), hash|
+		@identifiers = {}
+		@results     = {}
+		nodes.each_pair do |(identifier, props)|
 			next unless props.key?( 'addresses' )
 			address = props[ 'addresses' ].first
-			hash[ address ] = identifier
+			self.identifiers[ address ] = [ identifier, props['config'] ]
 		end
 
 		# Perform the work!
 		#
-		threads = []
-		self.identifiers.keys.each do |host|
-			thr = Thread.new do
-				Thread.current.abort_on_exception = true
-				opts = {
-					host:      host,
-					port:      self.port,
-					community: self.community,
-					timeout:   self.timeout,
-					retries:   self.retries
-				}
+		mainstart  = Time.now
+		threads    = ThreadGroup.new
+		batchcount = nodes.size / Arborist::Monitor::SNMP.batchsize
+		self.log.debug "Starting SNMP run for %d nodes" % [ nodes.size ]
+
+		self.identifiers.keys.each_slice( Arborist::Monitor::SNMP.batchsize ).each_with_index do |slice, batch|
+			slicestart = Time.now
+			self.log.debug "  %d hosts (batch %d of %d)" % [
+				slice.size,
+				batch + 1,
+				batchcount + 1
+			]
+
+			slice.each do |host|
+				thr = Thread.new do
+					config = self.identifiers[ host ].last || {}
+					opts = {
+						peername:  host,
+						port:      config[ 'port' ]      || Arborist::Monitor::SNMP.port,
+						version:   config[ 'version' ]   || Arborist::Monitor::SNMP.version,
+						community: config[ 'community' ] || Arborist::Monitor::SNMP.community,
+						timeout:   config[ 'timeout' ]   || Arborist::Monitor::SNMP.timeout,
+						retries:   config[ 'retries' ]   || Arborist::Monitor::SNMP.retries
+					}
 
-				begin
-					SNMP::Manager.open( opts ) do |snmp|
-						case self.mode
-						when :disk
-							self.gather_disks( snmp, host )
-						when :load
-							self.gather_load( snmp, host )
-						when :memory
-							self.gather_free_memory( snmp, host )
-						when :swap
-							self.gather_swap( snmp, host )
-						when :process
-							self.gather_processlist( snmp, host )
-						end
+					snmp = Net::SNMP::Session.open( opts )
+					begin
+						@system = snmp.get( IDENTIFICATION_OID ).varbinds.first.value
+						yield( host, snmp )
+
+					rescue Net::SNMP::TimeoutError, Net::SNMP::Error => err
+						self.log.error "%s: %s %s" % [ host, err.message, snmp.error_message ]
+						self.results[ host ] = {
+							error: "%s" % [ snmp.error_message ]
+						}
+					rescue => err
+						self.results[ host ] = {
+							error: "Uncaught exception. (%s: %s)" % [ err.class.name, err.message ]
+						}
+					ensure
+						snmp.close
 					end
-				rescue SNMP::RequestTimeout
-					self.results[ host ] = {
-						error: "Host is not responding to SNMP requests."
-					}
-				rescue StandardError => err
-					self.results[ host ] = {
-						error: "Network is not accessible. (%s: %s)" % [ err.class.name, err.message ]
-					}
 				end
+
+				threads.add( thr )
 			end
-			threads << thr
-		end
 
-		# Wait for thread completion
-		threads.map( &:join )
+			# Wait for thread completions
+			threads.list.map( &:join )
+			self.log.debug "  finished after %0.1f seconds." % [ Time.now - slicestart ]
+		end
+		self.log.debug "Completed SNMP run for %d nodes after %0.1f seconds." % [ nodes.size, Time.now - mainstart ]
 
 		# Map everything back to identifier -> attribute(s), and send to the manager.
 		#
 		reply = self.results.each_with_object({}) do |(address, results), hash|
 			identifier = self.identifiers[ address ] or next
-			hash[ identifier ] = results
+			hash[ identifier.first ] = results
 		end
-		self.log.debug "Sending to manager: %p" % [ reply ]
 		return reply
-	end
-
-
-	#########
-	protected
-	#########
-
-	### Collect the load information for +host+ from an existing
-	### (and open) +snmp+ connection.
-	###
-	def gather_load( snmp, host )
-		self.log.debug "Getting system load for: %s" % [ host ]
-		load5 = snmp.get( SNMP::ObjectId.new( LOAD[:five_min] ) ).varbind_list.first.value.to_f
-		self.log.debug "  Load on %s: %0.2f" % [ host, load5 ]
-
-		if load5 >= self.load_error_at
-			self.results[ host ] = {
-				error: "Load has exceeded %0.2f over a 5 minute average" % [ self.load_error_at ],
-				load5: load5
-			}
-		else
-			self.results[ host ] = { load5: load5 }
-		end
-	end
-
-
-	### Collect available memory information for +host+ from an existing
-	### (and open) +snmp+ connection.
-	###
-	def gather_free_memory( snmp, host )
-		self.log.debug "Getting available memory for: %s" % [ host ]
-		mem_avail = snmp.get( SNMP::ObjectId.new( MEMORY[:mem_avail] ) ).varbind_list.first.value.to_f
-		self.log.debug "  Available memory on %s: %0.2f" % [ host, mem_avail ]
-
-		if mem_avail <= self.mem_error_at
-			self.results[ host ] = {
-				error: "Available memory is under %0.1fMB" % [ self.mem_error_at.to_f / 1024 ],
-				available_memory: mem_avail
-			}
-		else
-			self.results[ host ] = { available_memory: mem_avail }
-		end
-	end
-
-
-	### Collect used swap information for +host+ from an existing (and
-	### open) +snmp+ connection.
-	###
-	def gather_swap( snmp, host )
-		self.log.debug "Getting used swap for: %s" % [ host ]
-
-		swap_total = snmp.get( SNMP::ObjectId.new(MEMORY[:swap_total]) ).varbind_list.first.value.to_f
-		swap_avail = snmp.get( SNMP::ObjectId.new(MEMORY[:swap_avail]) ).varbind_list.first.value.to_f
-		swap_used  = ( "%0.2f" % ((swap_avail / swap_total.to_f * 100 ) - 100).abs ).to_f
-		self.log.debug "  Swap in use on %s: %0.2f" % [ host, swap_used ]
-
-		if swap_used >= self.swap_error_at
-			self.results[ host ] = {
-				error: "%0.2f%% swap in use" % [ swap_used ],
-				swap_used: swap_used
-			}
-		else
-			self.results[ host ] = { swap_used: swap_used }
-		end
-	end
-
-
-	### Collect mount point usage for +host+ from an existing (and open)
-	#### +snmp+ connection.
-	###
-	def gather_disks( snmp, host )
-		self.log.debug "Getting disk information for %s" % [ host ]
-		errors  = []
-		results = {}
-		mounts  = self.get_disk_percentages( snmp )
-
-		mounts.each_pair do |path, percentage|
-			if percentage >= self.storage_error_at
-				errors << "Mount %s at %d%% capacity" % [ path, percentage ]
-			end
-		end
 
-		results[ :mounts ] = mounts
-		results[ :error ] = errors.join( ', ' ) unless errors.empty?
-
-		self.results[ host ] = results
-	end
-
-
-	### Collect running processes on +host+ from an existing (and open)
-	#### +snmp+ connection.
-	###
-	def gather_processlist( snmp, host )
-		self.log.debug "Getting running process list for %s" % [ host ]
-		procs = []
-
-		snmp.walk([ PROCESS[:list], PROCESS[:args] ]) do |list|
-			process = list[0].value.to_s
-			args    = list[1].value.to_s
-			procs << "%s %s " % [ process, args ]
-		end
-
-		# Check against the running stuff, setting an error if
-		# one isn't found.
-		#
-		errors = []
-		Array( self.processes ).each do |process|
-			process_r = Regexp.new( process )
-			found = procs.find{|p| p.match(process_r) }
-			errors << "Process '%s' is not running" % [ process, host ] unless found
-		end
-
-		self.log.debug "  %d running processes" % [ procs.length ]
-		if errors.empty?
-			self.results[ host ] = {}
-		else
-			self.results[ host ] = { error: errors.join( ', ' ) }
-		end
+	ensure
+		@identifiers = {}
+		@results     = {}
 	end
 
+end # Arborist::Monitor::SNMP
 
-	### Given a SNMP object, return a hash of:
-	###
-	###    device path => percentage full
-	###
-	def get_disk_percentages( snmp )
-
-		# Does this look like a windows system, or a net-snmp based one?
-		system_type = snmp.get( SNMP::ObjectId.new( IDENTIFICATION_OID ) ).varbind_list.first.value
-		disks = {}
-
-		# Windows has it's own MIBs.
-		#
-		if system_type =~ /windows/i
-			snmp.walk( STORAGE_WINDOWS ) do |list|
-				next unless list[0].value.to_s == WINDOWS_DEVICE
-				disks[ list[1].value.to_s ] = ( list[3].value.to_f / list[2].value.to_f ) * 100
-			end
-			return disks
-		end
-
-		# Everything else.
-		#
-		snmp.walk( STORAGE_NET_SNMP ) do |list|
-			mount   = list[0].value.to_s
-			next if mount == 'noSuchInstance'
-
-			next if list[2].value.to_s == 'noSuchInstance'
-			used    = list[2].value.to_i
-
-			typeoid = list[1].value.join('.').to_s
-			next if typeoid =~ STORAGE_IGNORE
-			next if mount =~ /\/(?:dev|proc)$/
-
-			self.log.debug "   %s -> %s -> %s" % [ mount, typeoid, used ]
-			disks[ mount ] = used
-		end
-
-		return disks
-	end
-end # class Arborist::Monitor::SNMP
+require 'arborist/monitor/snmp/cpu'
+require 'arborist/monitor/snmp/disk'
+require 'arborist/monitor/snmp/process'
+require 'arborist/monitor/snmp/memory'
 

data/lib/arborist/monitor/snmp/cpu.rb

@@ -0,0 +1,140 @@
+# -*- ruby -*-
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'arborist/monitor/snmp' unless defined?( Arborist::Monitor::SNMP )
+
+# Machine load/cpu checks.
+#
+# Sets current 1, 5, and 15 minute loads under the 'load' attribute,
+# and calculates/warns on cpu overutilization.
+#
+class Arborist::Monitor::SNMP::CPU
+	include Arborist::Monitor::SNMP
+
+	extend Configurability, Loggability
+	log_to :arborist_snmp
+
+	# OIDS for discovering system load.
+	#
+	OIDS = {
+		load: '1.3.6.1.4.1.2021.10.1.3',
+		cpu:  '1.3.6.1.2.1.25.3.3.1.2'
+	}
+
+	# When walking load OIDS, the iterator count matches
+	# these labels.
+	#
+	LOADKEYS = {
+		1 => :load1,
+		2 => :load5,
+		3 => :load15
+	}
+
+
+	# Global defaults for instances of this monitor
+	#
+	configurability( 'arborist.snmp.cpu' ) do
+		# What overutilization percentage qualifies as a warning
+		setting :warn_at, default: 80
+	end
+
+
+	### Return the properties used by this monitor.
+	###
+	def self::node_properties
+		return USED_PROPERTIES
+	end
+
+
+	### Class #run creates a new instance and immediately runs it.
+	###
+	def self::run( nodes )
+		return new.run( nodes )
+	end
+
+
+	### Perform the monitoring checks.
+	###
+	def run( nodes )
+		super do |host, snmp|
+			self.find_load( host, snmp )
+		end
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Return system CPU data.
+	###
+	def cpu( snmp )
+		return snmp.walk( OIDS[:cpu] )
+	end
+
+
+	### Find load data, add additional niceties for reporting.
+	###
+	def format_load( snmp )
+		info = { cpu: {}, load: {} }
+		cpus = self.cpu( snmp )
+
+		info[ :cpu ][ :count ] = cpus.size
+
+		# Windows SNMP doesn't have a concept of "load" over time,
+		# so we have to just use the current averaged CPU usage.
+		#
+		# This means that windows machines will very likely want to
+		# adjust the default "overutilization" number, considering
+		# it's really just how much of the CPU is used at the time of
+		# the monitor run, along with liberal use of the Observer "only
+		# alert after X events" pragmas.
+		#
+		if self.system =~ /windows\s+/i
+			info[ :cpu ][ :usage ] = cpus.values.inject( :+ ).to_f / cpus.size
+			info[ :message ] = "System is %0.1f%% in use." % [ info[ :cpu ][ :usage ] ]
+
+		# UCDavis stuff is better for alerting only after there has been
+		# an extended load event.  Use the 5 minute average to avoid
+		# state changes on transient spikes.
+		#
+		else
+			snmp.walk( OIDS[:load] ).each_with_index do |(_, value), idx|
+				next unless LOADKEYS[ idx + 1 ]
+				info[ :load ][ LOADKEYS[idx + 1] ] = value.to_f
+			end
+
+			percentage = (( ( info[:load][ :load5 ] / cpus.size ) - 1 ) * 100 ).round( 1 )
+
+			if percentage < 0
+				info[ :message ] = "System is %0.1f%% idle." % [ percentage.abs ]
+				info[ :cpu ][ :usage ] = percentage + 100
+			else
+				info[ :message ] = "System is %0.1f%% overloaded." % [ percentage ]
+				info[ :cpu ][ :usage ] = percentage
+			end
+		end
+
+		return info
+	end
+
+
+	### Collect the load information for +host+ from an existing
+	### (and open) +snmp+ connection.
+	###
+	def find_load( host, snmp )
+		info = self.format_load( snmp )
+
+		config  = identifiers[ host ].last || {}
+		warn_at = config[ 'warn_at' ] || self.class.warn_at
+		usage   = info.dig( :cpu, :usage ) || 0
+
+		if usage >= warn_at
+			info[ :warning ] = "%0.1f utilization exceeds %0.1f percent" % [ usage, warn_at ]
+		end
+
+		self.results[ host ] = info
+	end
+
+end # class Arborist::Monitor::SNMP::CPU
+

data/lib/arborist/monitor/snmp/disk.rb

@@ -0,0 +1,183 @@
+# -*- ruby -*-
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'arborist/monitor/snmp' unless defined?( Arborist::Monitor::SNMP )
+
+# Disk capacity checks.
+#
+# Sets all configured mounts with their current usage percentage
+# in an attribute named "mounts".
+#
+class Arborist::Monitor::SNMP::Disk
+	include Arborist::Monitor::SNMP
+
+	extend Configurability, Loggability
+	log_to :arborist_snmp
+
+	# OIDS required to pull disk information from net-snmp.
+	#
+	STORAGE_NET_SNMP = {
+		path: '1.3.6.1.4.1.2021.9.1.2',
+		percent: '1.3.6.1.4.1.2021.9.1.9',
+		type: '1.3.6.1.2.1.25.3.8.1.4'
+	}
+
+	# The OID that matches a local windows hard disk.
+	#
+	WINDOWS_DEVICES = [
+		'1.3.6.1.2.1.25.2.1.4', # local disk
+		'1.3.6.1.2.1.25.2.1.7'  # removables, but we have to include them for iscsi mounts
+	]
+
+	# OIDS required to pull disk information from Windows.
+	#
+	STORAGE_WINDOWS = {
+		type: '1.3.6.1.2.1.25.2.3.1.2',
+		path: '1.3.6.1.2.1.25.2.3.1.3',
+		total: '1.3.6.1.2.1.25.2.3.1.5',
+		used: '1.3.6.1.2.1.25.2.3.1.6'
+	}
+
+	# The fallback warning capacity.
+	WARN_AT = 90
+
+
+	# Configurability API
+	#
+	configurability( 'arborist.snmp.disk' ) do
+		# What percentage qualifies as a warning
+		setting :warn_at, default: WARN_AT
+
+		# If non-empty, only these paths are included in checks.
+		#
+		setting :include do |val|
+			if val
+				mounts = Array( val ).map{|m| Regexp.new(m) }
+				Regexp.union( mounts )
+			end
+		end
+
+		# Paths to exclude from checks
+		#
+		setting :exclude,
+			default: [ '^/dev(/.+)?$', '^/net(/.+)?$', '^/proc$', '^/run$', '^/sys/' ] do |val|
+			mounts = Array( val ).map{|m| Regexp.new(m) }
+			Regexp.union( mounts )
+		end
+	end
+
+
+	### Return the properties used by this monitor.
+	###
+	def self::node_properties
+		return USED_PROPERTIES
+	end
+
+
+	### Class #run creates a new instance and immediately runs it.
+	###
+	def self::run( nodes )
+		return new.run( nodes )
+	end
+
+
+	### Perform the monitoring checks.
+	###
+	def run( nodes )
+		super do |host, snmp|
+			self.gather_disks( host, snmp )
+		end
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Collect mount point usage for +host+ from an existing (and open)
+	### +snmp+ connection.
+	###
+	def gather_disks( host, snmp )
+		mounts  =  self.system =~ /windows\s+/i ? self.windows_disks( snmp ) : self.unix_disks( snmp )
+		config  = self.identifiers[ host ].last || {}
+		warn_at = config[ 'warn_at' ] || self.class.warn_at
+
+		includes = self.format_mounts( config, 'include' ) || self.class.include
+		excludes = self.format_mounts( config, 'exclude' ) || self.class.exclude
+
+		mounts.reject! do |path, percentage|
+			excludes.match( path ) || ( includes && ! includes.match( path ) )
+		end
+
+		errors   = []
+		warnings = []
+		mounts.each_pair do |path, percentage|
+
+			warn = begin
+			  if warn_at.is_a?( Hash )
+				  warn_at[ path ] || WARN_AT
+			  else
+				  warn_at
+			  end
+			end
+
+			self.log.debug "%s:%s -> at %d, warn at %d" % [ host, path, percentage, warn ]
+
+			if percentage >= warn.to_i
+				if percentage >= 100
+					errors << "%s at %d%% capacity" % [ path, percentage ]
+				else
+					warnings << "%s at %d%% capacity" % [ path, percentage ]
+				end
+			end
+		end
+
+		self.results[ host ] = { mounts: mounts }
+		self.results[ host ][ :error ]   = errors.join(', ')   unless errors.empty?
+		self.results[ host ][ :warning ] = warnings.join(', ') unless warnings.empty?
+	end
+
+
+	### Return a single regexp for the 'include' or 'exclude' section of
+	### resource node's +config+, or nil if nonexistent.
+	###
+	def format_mounts( config, section )
+		list = config[ section ] || return
+		mounts = Array( list ).map{|m| Regexp.new(m) }
+		return Regexp.union( mounts )
+	end
+
+
+	### Fetch information for Windows systems.
+	###
+	def windows_disks( snmp )
+		raw = snmp.get_bulk([
+			STORAGE_WINDOWS[:path],
+			STORAGE_WINDOWS[:type],
+			STORAGE_WINDOWS[:total],
+			STORAGE_WINDOWS[:used]
+		]).varbinds.map( &:value )
+
+		disks = {}
+		raw.each_slice( 4 ) do |device|
+			next unless device[1].respond_to?( :oid ) && WINDOWS_DEVICES.include?( device[1].oid )
+			next if device[2].zero?
+			disks[ device[0] ] = (( device[3].to_f / device[2] ) * 100).round( 1 )
+		end
+
+		return disks
+	end
+
+
+	### Fetch information for Unix/MacOS systems.
+	###
+	def unix_disks( snmp )
+		raw = snmp.get_bulk([
+			STORAGE_NET_SNMP[:path],
+			STORAGE_NET_SNMP[:percent] ]).varbinds.map( &:value )
+
+		return Hash[ *raw ]
+	end
+
+end # class Arborist::Monitor::SNMP::Disk
+

data/lib/arborist/monitor/snmp/memory.rb

@@ -0,0 +1,180 @@
+# -*- ruby -*-
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'arborist/monitor/snmp' unless defined?( Arborist::Monitor::SNMP )
+
+# SNMP memory and swap utilization checks.
+#
+# Set 'usage' and 'available' keys as properties, in percentage/GBs,
+# respectively.
+#
+# By default, doesn't warn on memory usage, only swap, since
+# that's more indicitive of a problem.  You can still set the
+# 'physical_warn_at' key to force warnings on ram usage, for embedded
+# systems or other similar things without virtual memory.
+#
+class Arborist::Monitor::SNMP::Memory
+	include Arborist::Monitor::SNMP
+
+	extend Configurability, Loggability
+	log_to :arborist_snmp
+
+	# OIDS for discovering memory usage.
+	#
+	MEMORY = {
+		total:  '1.3.6.1.4.1.2021.4.5.0',
+		avail: '1.3.6.1.4.1.2021.4.6.0',
+		windows: {
+			label: '1.3.6.1.2.1.25.2.3.1.3',
+			units: '1.3.6.1.2.1.25.2.3.1.4',
+			total: '1.3.6.1.2.1.25.2.3.1.5',
+			used:  '1.3.6.1.2.1.25.2.3.1.6'
+		}
+	}
+
+	# OIDS for discovering swap usage.
+	#
+	SWAP = {
+		total: '1.3.6.1.4.1.2021.4.3.0',
+		avail: '1.3.6.1.4.1.2021.4.4.0'
+	}
+
+	# Global defaults for instances of this monitor
+	#
+	configurability( 'arborist.snmp.memory' ) do
+		# What memory usage percentage qualifies as a warning
+		setting :physical_warn_at, default: nil
+
+		# What swap usage percentage qualifies as a warning
+		setting :swap_warn_at, default: 60
+	end
+
+
+	### Return the properties used by this monitor.
+	###
+	def self::node_properties
+		return USED_PROPERTIES
+	end
+
+
+
+	### Class #run creates a new instance and immediately runs it.
+	###
+	def self::run( nodes )
+		return new.run( nodes )
+	end
+
+
+	### Perform the monitoring checks.
+	###
+	def run( nodes )
+		super do |host, snmp|
+			self.gather_memory( host, snmp )
+		end
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Collect available memory information for +host+ from an existing
+	### (and open) +snmp+ connection.
+	###
+	def gather_memory( host, snmp )
+		info = self.system =~ /windows\s+/i ? self.get_windows( snmp ) : self.get_mem( snmp )
+
+		config           = identifiers[ host ].last || {}
+		physical_warn_at = config[ 'physical_warn_at' ] || self.class.physical_warn_at
+		swap_warn_at     = config[ 'swap_warn_at' ] || self.class.swap_warn_at
+
+		self.log.debug "Memory data on %s: %p" % [ host, info ]
+		memory, swap = info[:memory], info[:swap]
+		self.results[ host ] = { memory: memory, swap: swap }
+
+		memusage = memory[ :usage ].to_i
+		if physical_warn_at && memusage >= physical_warn_at
+			self.results[ host ][ :warning ] = "%0.1f memory utilization exceeds %0.1f percent" % [
+				memusage,
+				physical_warn_at
+			]
+		end
+
+		swapusage = swap[ :usage ].to_i
+		if swapusage >= swap_warn_at
+			self.results[ host ][ :warning ] = "%0.1f swap utilization exceeds %0.1f percent" % [
+				swapusage,
+				swap_warn_at
+			]
+		end
+	end
+
+
+	### Return a hash of usage percentage in use, and free mem in
+	### megs.
+	###
+	def get_mem( snmp )
+		info  = {}
+		info[ :memory ] = self.calc_memory( snmp, MEMORY )
+		info[ :swap ]   = self.calc_memory( snmp, SWAP )
+
+		return info
+	end
+
+
+	### Windows appends virtual and physical memory onto the last two items
+	### of the storage iterator, because that made sense in someone's mind.
+	### Walk the whole oid tree, and get the values we're after, return
+	### a hash of usage percentage in use and free mem in megs.
+	###
+	def get_windows( snmp )
+		info  = { memory: {}, swap: {} }
+		mem_idx, swap_idx = nil
+
+		snmp.walk( MEMORY[:windows][:label] ).each_with_index do |(_, val), i|
+			mem_idx  = i + 1 if val =~ /physical memory/i
+			swap_idx = i + 1 if val =~ /virtual memory/i
+		end
+		return info unless mem_idx
+
+		info[ :memory ] = self.calc_windows_memory( snmp, mem_idx )
+		info[ :swap ]   = self.calc_windows_memory( snmp, swap_idx )
+
+		return info
+	end
+
+
+	### Format usage and available amount, given an OID hash.
+	###
+	def calc_memory( snmp, oids )
+		info = { usage: 0, available: 0 }
+		avail = snmp.get( oids[:avail] ).varbinds.first.value.to_f
+		total = snmp.get( oids[:total] ).varbinds.first.value.to_f
+		used  = total - avail
+
+		return info if avail.zero?
+
+		info[ :usage ]     = (( used / total ) * 100 ).round( 2 )
+		info[ :available ] = (( total - used ) / 1024 ).round( 2 )
+		return info
+	end
+
+
+	### Format usage and available amount for windows.
+	###
+	def calc_windows_memory( snmp, idx)
+		info = { usage: 0, available: 0 }
+		return info unless idx
+
+		units = snmp.get( MEMORY[:windows][:units] + ".#{idx}" ).varbinds.first.value
+		total = snmp.get( MEMORY[:windows][:total] + ".#{idx}" ).varbinds.first.value.to_f * units
+		used  = snmp.get( MEMORY[:windows][:used] + ".#{idx}" ).varbinds.first.value.to_f * units
+
+		info[ :usage ]     = (( used / total ) * 100 ).round( 2 )
+		info[ :available ] = (( total - used ) / 1024 / 1024 ).round( 2 )
+		return info
+	end
+
+
+end # class Arborist::Monitor::SNMP::Memory
+

data/lib/arborist/monitor/snmp/process.rb

@@ -0,0 +1,123 @@
+# -*- ruby -*-
+# vim: set noet nosta sw=4 ts=4 :
+
+require 'arborist/monitor/snmp' unless defined?( Arborist::Monitor::SNMP )
+
+# SNMP running process checks.
+#
+# This only checks running userland processes.
+#
+class Arborist::Monitor::SNMP::Process
+	include Arborist::Monitor::SNMP
+
+	extend Configurability, Loggability
+	log_to :arborist_snmp
+
+
+	# OIDS for discovering running processes.
+	# Of course, Windows does it slightly differently.
+	#
+	PROCESS = {
+		netsnmp: {
+			list: '1.3.6.1.2.1.25.4.2.1.4',
+			args: '1.3.6.1.2.1.25.4.2.1.5'
+		},
+		windows: {
+			list: '1.3.6.1.2.1.25.4.2.1.2',
+			path: '1.3.6.1.2.1.25.4.2.1.4',
+			args: '1.3.6.1.2.1.25.4.2.1.5'
+		}
+	}
+
+
+	# Global defaults for instances of this monitor
+	#
+	configurability( 'arborist.snmp.processes' ) do
+		# Default list of processes to check for
+		setting :check, default: [] do |val|
+			Array( val )
+		end
+	end
+
+
+	### Return the properties used by this monitor.
+	###
+	def self::node_properties
+		return USED_PROPERTIES
+	end
+
+
+	### Class #run creates a new instance and immediately runs it.
+	###
+	def self::run( nodes )
+		return new.run( nodes )
+	end
+
+
+	### Perform the monitoring checks.
+	###
+	def run( nodes )
+		super do |host, snmp|
+			self.gather_processlist( host, snmp )
+		end
+	end
+
+
+	#########
+	protected
+	#########
+
+	### Collect running processes on +host+ from an existing (and open)
+	#### +snmp+ connection.
+	###
+	def gather_processlist( host, snmp )
+		config = self.identifiers[ host ].last || {}
+		errors = []
+		procs  = self.system =~ /windows\s+/i ? self.get_windows( snmp ) : self.get_procs( snmp )
+
+		self.log.debug "Running processes for host: %s: %p" % [ host, procs ]
+		self.results[ host ] = { count: procs.size }
+
+		# Check against what is running.
+		#
+		Array( config['processes'] || self.class.check ).each do |process|
+			process_r = Regexp.new( process )
+			found = procs.find{|p| p.match(process_r) }
+			errors << "'%s' is not running" % [ process ] unless found
+		end
+
+		self.results[ host ][ :error ] = errors.join( ', ' ) unless errors.empty?
+	end
+
+
+	### Parse OIDS and return an Array of running processes.
+	### Windows specific behaviors.
+	###
+	def get_windows( snmp )
+		oids = [ PROCESS[:windows][:path], PROCESS[:windows][:list], PROCESS[:windows][:args] ]
+		return snmp.walk( oids ).each_slice( 3 ). each_with_object( [] ) do |vals, acc|
+			path, process, args = vals[0][1], vals[1][1], vals[2][1]
+			next if path.empty?
+
+			process = "%s%s" % [ path, process ]
+			process << " %s" % [ args ] unless args.empty?
+			acc << process
+		end
+	end
+
+
+	### Parse OIDS and return an Array of running processes.
+	###
+	def get_procs( snmp )
+		oids = [ PROCESS[:netsnmp][:list], PROCESS[:netsnmp][:args] ]
+		return snmp.walk( oids ).each_slice( 2 ).each_with_object( [] ) do |vals, acc|
+			process, args = vals[0][1], vals[1][1]
+			next if process.empty?
+
+			process << " %s" % [ args ] unless args.empty?
+			acc << process
+		end
+	end
+
+end # class Arborist::Monitor::SNMP::Process
+

data/lib/arborist/snmp.rb

@@ -0,0 +1,35 @@
+# -*- ruby -*-
+#encoding: utf-8
+
+require 'loggability'
+require 'arborist'
+
+
+# Various monitoring checks using SNMP, for the Arborist monitoring toolkit.
+module Arborist::SNMP
+	extend Loggability
+
+	# Loggability API -- set up a log host for this library
+	log_as :arborist_snmp
+
+
+	# Package version
+	VERSION = '0.4.0'
+
+	# Version control revision
+	REVISION = %q$Revision: e0b7c95a154f $
+
+
+	### Return the name of the library with the version, and optionally the build ID if
+	### +include_build+ is true.
+	def self::version_string( include_build: false )
+		str = "%p v%s" % [ self, VERSION ]
+		str << ' (' << REVISION.strip << ')' if include_build
+		return str
+	end
+
+
+	require 'arborist/monitor/snmp'
+
+end # module Arborist::SNMP
+

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: arborist-snmp
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre20161005111600
+  version: 0.4.0
 platform: ruby
 authors:
-- Mahlon E. Smith
-- Michael Granger
+- Mahlon E. Smith <mahlon@martini.nu>
+- Michael Granger <ged@faeriemud.org>
 autorequire: 
 bindir: bin
 cert_chain:
@@ -13,7 +13,7 @@ cert_chain:
   -----BEGIN CERTIFICATE-----
   MIIDbDCCAlSgAwIBAgIBATANBgkqhkiG9w0BAQUFADA+MQ8wDQYDVQQDDAZtYWhs
   b24xFzAVBgoJkiaJk/IsZAEZFgdtYXJ0aW5pMRIwEAYKCZImiZPyLGQBGRYCbnUw
-  HhcNMTYwNjI5MjMzMzI2WhcNMTcwNjI5MjMzMzI2WjA+MQ8wDQYDVQQDDAZtYWhs
+  HhcNMTcxMTIyMjIyMTAyWhcNMTgxMTIyMjIyMTAyWjA+MQ8wDQYDVQQDDAZtYWhs
   b24xFzAVBgoJkiaJk/IsZAEZFgdtYXJ0aW5pMRIwEAYKCZImiZPyLGQBGRYCbnUw
   ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDpXGN0YbMVpYv4EoiCxpQw
   sxKdyhlkvpvENUkpEhbpnEuMKXgUfRHO4T/vBZf0h8eYgwnrHCRhAeIqesFKfoj9
@@ -24,52 +24,55 @@ cert_chain:
   AgMBAAGjdTBzMAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBRY8ea6
   +6kAaW7ukKph2/4MTAD8/TAcBgNVHREEFTATgRFtYWhsb25AbWFydGluaS5udTAc
   BgNVHRIEFTATgRFtYWhsb25AbWFydGluaS5udTANBgkqhkiG9w0BAQUFAAOCAQEA
-  EU39m2ZKYqAAu71bwjWl5zEAk0aE4ojMLIMWpWE6IwCr9FZVpC1B+LyEboWFljId
-  R0udISkfM+kQ3FRzmnwwQLaYJyhDPEWbQ1O6P6wHCaUQ23A1P++dZf8PWuZkS6Dn
-  C1q7Zq4EAZEBLUSK69iPP4jCLjIp3YBQ88D1/egA+hkrR/19m236PvhhaM9FTgQv
-  LtL61M3ZtlTanoXiNbXRXwRnODzvjFpQRiiBiazCDBYj8oYDsNj+qNw/iZlZlzw5
-  F6uYXeS4YCZP453ZcpgZkXo3F5RheTrkdf04DMwUpQPMKog9QmRSTlCxzH69kivQ
-  IfRp+58YwWwtAIQPZoY6Rg==
+  00FljTeSNaYUqJ59yLRA+i43wVNiO4ETQQu6fYQCPns12Sm90spOJb3SmTDkJ7CY
+  dixOQg5A3Et1LVS+Z/YfH1TAbb50oTWbZbTW2JknHS0hohq3UF1pvbkk1niZ26er
+  skJ352MUfcyaUkQyMmCjL/BpkDutYH5OCGh+FmK8+mH7SoC9Nr48WwH2prVdHs3y
+  OMWFgB33sXdj1XqOd2Rw1WPgAeMeDqWeIrRMpUhNZOwroaA1MAr60f9NIYxua/vx
+  n0YyneERGuHPSRZFgo72tGOqLpAlWnhPxRNqnayZmsg3hPPI87B6MTUI2UQ7VUdh
+  UrSf3b+cPoC8PNfjp8zsdw==
   -----END CERTIFICATE-----
-date: 2016-10-05 00:00:00.000000000 Z
+date: 2018-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: snmp
+  name: arborist
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: arborist
+  name: net-snmp2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: "\tThis library adds common SNMP support to Arborist monitors.\n"
-email:
-- mahlon@martini.nu
-- ged@faeriemud.org
+        version: '0.3'
+description: "\tThis library adds common SNMP resource support to Arborist monitors.\n"
+email: mahlon@martini.nu
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/arborist/monitor/snmp.rb
+- lib/arborist/monitor/snmp/cpu.rb
+- lib/arborist/monitor/snmp/disk.rb
+- lib/arborist/monitor/snmp/memory.rb
+- lib/arborist/monitor/snmp/process.rb
+- lib/arborist/snmp.rb
 homepage: http://bitbucket.org/mahlon/Arborist-SNMP
 licenses:
 - BSD-3-Clause
@@ -85,13 +88,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: Common SNMP support for Arborist
+summary: SNMP support for Arborist monitors
 test_files: []

checksums.yaml.gz.sig

@@ -1,4 +0,0 @@
-�d���v�b�
��0L�:!���������ܷ�6�
-\U`\0ףc�	x��r�8Y=�1��o���݋���G�D�����e�J"�%�ع��/
-s˲"��z�˴Ķ���JҺ�1pU�֬����_b#�V"A
-!€��S�y*�/|�m���`�겶�/#pR�x���[`�'�N�b�m��'X��2�Ju�:��I�G�OS�����XS��e��rgr�˻4�|�Q�n�[۬�ÑU���

metadata.gz.sig

@@ -1,2 +0,0 @@
-��U�ޥ�w�����$A5��ڻ�^|�ܕ���bM�:�*��QmA���1-b��,T�Ԑt݃]ٖ<¨��L@�[�
��!���0�ݸ�*�M�e@"ǔ&m{�9N�4�?����ŗS~��+�}�t���*�	l���k��\���s�qlʈ������35&�*U>o"������
-*ׇ����)d}�!J�0Oʼn;[
ꓦk�{� E*qa\E�.��&���BC�*�}������$ʇ���h"l�gb@��r/v