222 lines
6.2 KiB
Ruby
222 lines
6.2 KiB
Ruby
module NSCA
|
|
module PerformanceData
|
|
class TimeUnitExpected < Exception
|
|
end
|
|
|
|
class Base
|
|
extend Timeout
|
|
extend Benchmark
|
|
|
|
class <<self
|
|
attr_reader :label, :unit, :warn, :crit, :min, :max
|
|
def init *args
|
|
a, o = args, args.last.is_a?( Hash) ? args.pop : {}
|
|
@label, @unit = a[0]||o[:label], a[1]||o[:unit]
|
|
@warn, @crit = a[2]||o[:warn], a[3]||o[:crit]
|
|
@min, @max = a[4]||o[:min], a[5]||o[:max]
|
|
raise ArgumentError, "Label expected" unless @label
|
|
@label = @label.to_s
|
|
self
|
|
end
|
|
|
|
def measure &block
|
|
f = case unit.to_s.to_sym
|
|
when :s then 1
|
|
when :ms then 1000
|
|
else raise TimeUnitExpected, "Unit must be seconds (s) or miliseconds (ms) not (#{unit})"
|
|
end
|
|
exception = ::Class.new Timeout::Error
|
|
timeout = max
|
|
m = realtime do
|
|
begin
|
|
timeout timeout, exception, &block
|
|
rescue exception
|
|
end
|
|
end
|
|
new f * m
|
|
end
|
|
|
|
def to_sym() label.to_sym end
|
|
def to_h() {label: @label, unit: @unit, warn: @warn, crit: @crit, min: @min, max: @max } end
|
|
def to_a() [label, unit, warn, crit, min, max] end
|
|
def clone( opts = nil) ::Class.new( self).init opts ? to_h.merge( opts) : to_h end
|
|
end
|
|
|
|
attr_reader :value
|
|
def initialize( value) @value = value end
|
|
def label() self.class.label end
|
|
def unit() self.class.unit end
|
|
def warn() self.class.warn end
|
|
def crit() self.class.crit end
|
|
def min() self.class.min end
|
|
def max() self.class.max end
|
|
def to_a() [label, value, unit, warn, crit, min, max] end
|
|
def to_s() "'#{label.gsub /[\n'\|]/, ''}'=#{value}#{unit},#{warn},#{crit},#{min},#{max}" end
|
|
def to_sym() self.class.to_sym end
|
|
|
|
def to_h
|
|
{label: @label, value: @value, unit: @unit, warn: @warn, crit: @crit, min: @min, max: @max}
|
|
end
|
|
|
|
def return_code
|
|
if @value.nil? then 3
|
|
elsif crit <= @value then 2
|
|
elsif warn <= @value then 1
|
|
else 0
|
|
end
|
|
end
|
|
end
|
|
|
|
class <<self
|
|
def new( *args) ::Class.new( Base).init *args end
|
|
def create label, *args
|
|
cl = new label, *args
|
|
clname = NSCA::Helper.class_name_gen label
|
|
self.const_set clname, cl if clname
|
|
cl
|
|
end
|
|
end
|
|
end
|
|
|
|
module Check
|
|
class Base
|
|
attr_accessor :return_code, :status, :timestamp
|
|
attr_reader :perfdatas
|
|
|
|
def initialize return_code = nil, status = nil, perfdatas = nil, timestamp = nil
|
|
@perfdatas = {}
|
|
init return_code, status, perfdatas, timestamp || Time.now
|
|
end
|
|
|
|
def init return_code = nil, status = nil, perfdatas = nil, timestamp = nil
|
|
@return_code = return_code if return_code
|
|
@status = status if status
|
|
case perfdatas
|
|
when Hash
|
|
perfdatas.each &method( :[])
|
|
when Array
|
|
push *perfdatas
|
|
end
|
|
@timestamp = timestamp if timestamp
|
|
self
|
|
end
|
|
|
|
def [] perfdata_label
|
|
pd = @perfdatas[perfdata_label.to_sym]
|
|
pd && pd.value
|
|
end
|
|
|
|
def push *perfdatas
|
|
perfdatas.each {|perfdata| @perfdatas[perfdata.label.to_sym] = perfdata }
|
|
@perfdatas
|
|
end
|
|
|
|
def perfdata_for label
|
|
if label.is_a? PerformanceData::Base
|
|
label
|
|
else
|
|
label = label.to_sym
|
|
self.class.perfdatas[label] || PerformanceData::Base.new( label)
|
|
end
|
|
end
|
|
|
|
def []= perfdata_label, value
|
|
return push value if value.is_a? PerformanceData::Base
|
|
perfdata_label = perfdata_label.to_sym
|
|
@perfdatas[perfdata_label] = perfdata_for( perfdata_label).new value
|
|
end
|
|
|
|
def text
|
|
r = "#{status || ReturnCode.find(retcode)}"
|
|
r += " | #{perfdatas.each_value.map( &:to_s).join ' '}" unless perfdatas.empty?
|
|
r
|
|
end
|
|
|
|
def measure perfdata_label, &block
|
|
push perfdata_for( perfdata_label).measure( &block)
|
|
end
|
|
def send() NSCA::send self end
|
|
|
|
def ok( *args) init ReturnCode::OK, *args end
|
|
def warning( *args) init ReturnCode::WARNING, *args end
|
|
alias warn warning
|
|
def critical( *args) init ReturnCode::CRITICAL, *args end
|
|
alias crit critical
|
|
def unknown( *args) init ReturnCode::UNKNOWN, *args end
|
|
|
|
def determine_return_code
|
|
self.class.perfdatas.map do |label, pdc|
|
|
pd = @perfdatas[label]
|
|
pd ? pd.return_code : -1
|
|
end.max
|
|
end
|
|
|
|
def retcode
|
|
rc = return_code || determine_return_code
|
|
(0..3).include?(rc) ? rc : 3
|
|
end
|
|
|
|
def service() self.class.service end
|
|
def hostname() self.class.hostname end
|
|
def to_a() [timestamp, retcode, hostname, service, text] end
|
|
def to_h
|
|
{timestamp: timestamp, return_code: retcode, hostname: hostname, server: service, status: text}
|
|
end
|
|
|
|
def to_packet version = nil
|
|
version ||= PacketV3
|
|
version.new timestamp, retcode, hostname, service, text
|
|
end
|
|
|
|
class <<self
|
|
attr_reader :service, :hostname, :perfdatas
|
|
def init *args
|
|
a, o = args, args.last.is_a?( Hash) ? args.pop : {}
|
|
service, hostname = nil, perfdatas = nil
|
|
@service, @hostname, @perfdatas = a[0]||o[:service], a[1]||o[:hostname]||`hostname`.chomp, {}
|
|
perfdatas = a[2]||o[:perfdatas]
|
|
perfdatas.each {|pd| @perfdatas[pd.to_sym] = pd } if perfdatas
|
|
self
|
|
end
|
|
|
|
def ok( status = nil, perfdatas = nil) new.ok status, perfdatas end
|
|
def warning( status = nil, perfdatas = nil) new.warning status, perfdatas end
|
|
alias warn warning
|
|
def critical( status = nil, perfdatas = nil) new.warning status, perfdatas end
|
|
alias crit critical
|
|
def unknown( status = nil, perfdatas = nil) new.unknown status, perfdatas end
|
|
|
|
def to_a() [service, hostname, perfdatas.dup] end
|
|
def to_h() {service: service, hostname: hostname, perfdatas: perfdatas.values} end
|
|
def to_sym() "#{hostname}|#{service}".to_sym end
|
|
def clone( opts = nil) ::Class.new( self).init opts ? to_h.merge( opts) : to_h end
|
|
end
|
|
end
|
|
|
|
class <<self
|
|
def new service, hostname = nil, perfdatas = nil
|
|
cl = Class.new Base
|
|
cl.init service, hostname, perfdatas
|
|
cl
|
|
end
|
|
|
|
def create service, hostname = nil, perfdatas = nil
|
|
cl = new service, hostname, perfdatas
|
|
clname = NSCA::Helper.class_name_gen service.to_s
|
|
self.const_set clname, cl if clname
|
|
cl
|
|
end
|
|
end
|
|
end
|
|
|
|
module Checks
|
|
def perfdata( *params) NSCA::PerformanceData.new( *params) end
|
|
|
|
def check service, hostname, perfdatas = nil
|
|
perfdatas ||= []
|
|
perfdatas.map! {|cl| cl.is_a?( Symbol) ? const_get( cl) : cl }
|
|
NSCA::Check.new service, hostname, perfdatas
|
|
end
|
|
end
|
|
end
|