servicemonitor 0.1.4 → 0.2.0

data/lib/MonitorType/Beanstalk.rb

@@ -1,45 +0,0 @@
-require "beanstalk-client"
-require "MonitorType/Threshold"
-
-#A Beanstalk class for checking how many msgs are in a Queue
-class MonitorType_Beanstalk<MonitorType_Threshold
-    
-    #Extract parameters
-    #
-    # @param [String] beanstalk Optional connection string. Default to local
-    # @param [String] queue Name of queue to monitor
-	def extractParams()
-        @connection_string = @params[:beanstalk] || "localhost:11300"
-
-        if @params[:queue].nil? then
-            string = "*** Beanstalk parameter missing, queue\n"
-            string = "#{string}*** :queue => <queue name>"
-            raise MonitorTypeParameterMissingError.new(string)
-        end
-        @queue = @params[:queue]
-        
-        @context_sentence = "Checking number of jobs in queue, #{@queue}"
-        
-	end
-    
-    def setup
-        @beanstalk = Beanstalk::Pool.new([@connection_string])
-    end
-    
-    
-	def getValue
-        count = 0
-        begin
-            tubeStats = @beanstalk.stats_tube(@queue)
-            count = tubeStats["current-jobs-ready"]
-            rescue Beanstalk::NotFoundError=>e
-        end
-        
-		return count
-	end
-end
-
-def beanstalk( params )
-    $a.add( MonitorType_Beanstalk.new( params ) )
-end
-

data/lib/MonitorType/Dir.rb

@@ -1,45 +0,0 @@
-require "MonitorType/Threshold"
-
-#A directory class for checking how many files are in a directory
-class MonitorType_Dir<MonitorType_Threshold
-
-    #Extract parameters
-    #
-    # @param [String] path Path to directory to check
-    def extractParams()
-        if @params[:path].nil? then
-            string = "*** Dir parameter missing, path\n"
-            string = "#{string}*** :path => <path to directory to be monitored>"
-            raise MonitorTypeParameterMissingError.new(string)
-        end
-        @path = @params[:path]
-
-        @context_sentence = "Checking number of files in, #{@path}"
-    end
-
-
-	def setup
-        inputDir = Dir.new( @path )
-		    @path = inputDir.path
-        @params[:dir] = inputDir
-
-        rescue Errno::ENOENT => e
-        string = "***** Directory does not exist, #{@path}.\n"
-        string = "#{string}***** Create the directory, #{@path}, and try again.\n"
-        string = "#{string}***** eg, mkdir #{@path}"
-        raise MonitorTypeExceptionHandled.new(string)
-        rescue Errno::ENOTDIR => e
-        string = "***** The specified path does not point to a directory, #{@path}.\n"
-        string = "#{string}***** Either repoint path to a directory, or remove, #{@path}, and create it as a directory.\n"
-        string = "#{string}***** eg, rm #{@path} && mkdir #{@path}"
-        raise MonitorTypeExceptionHandled.new(string)
-	end
-
-	def getValue
-		return Dir.glob( "#{@path}/*" ).length
-	end
-end
-
-def dir( params )
-    $a.add( MonitorType_Dir.new( params ) )
-end

data/lib/MonitorType/Drive.rb

@@ -1,50 +0,0 @@
-require "MonitorType/Threshold"
-require "sys/filesystem"
-include Sys
-
-class MonitorType_Drive<MonitorType_Threshold
-
-	def extractParams
-		if @params[:path].nil? then
-			string = "*** Drive parameter missing, drive\n"
-			string = "#{string}*** :drive => <name of the drive to be monitored>"
-			raise MonitorTypeParameterMissingError.new(string)
-		end
-		@path = @params[:path]
-
-		log "#{@process_name}", "result: #{(@process_name =~ /^(.*\[{1}.+\]{1}.*)$|^(\w+)$/) == 0}"
-
-		if @params[:min].nil? then
-			string = "*** Min parameter missing, min\n"
-			string = "#{string}*** :min => <the minimum amount of free space on the drive to be monitored>"
-			raise MonitorTypeParameterMissingError.new(string)
-		end
-
-  	log "*** Max value will be ignored, setting to nil" unless @params[:max].nil?
-  	@max = nil
-
-		@context_sentence = "Checking that available drive space is greater than min, #{@process_name}"
-	end
-
-	def setup
-		begin
-		#Check that the path exists
-		drive = Filesystem.stat(@path)
-
-		rescue=>e
-			string = "*** Unable to mount the specifed path\n"
-			string = "#{string}*** path: #{@path}\n"
-      string = "#{string}*** Please fix the error and run again\n"
-			raise MonitorTypeExceptionHandled.new("Unable to mount path: #{@path}")
-		end
-	end
-
-	def getValue
-		return ((Filesystem.stat(@path).blocks_available.to_f / Filesystem.stat(@path).blocks.to_f) * 100).round(2)
-	end
-
-end
-
-def process(params)
-	$a.add(MonitorType_Drive.new(params))
-end

data/lib/MonitorType/FluidDb.rb

@@ -1,77 +0,0 @@
-require "FluidDb"
-require "MonitorType/Threshold"
-
-#A database class for checking a single number against a threshold.
-# For example,
-#  get the max timestamp from a table as a date.
-#  subtract this from now
-#  => check that the number is not greater than 2
-
-class MonitorType_FluidDb<MonitorType_Threshold
-
-    #Extract parameters
-    #
-    # @param [String] uri Connection string to db
-    # @param [String] sql SQL statement to gather a single value
-	def extractParams
-        if @params[:uri].nil? then
-            string = "*** FluidDb parameter missing, uri\n"
-            string = "#{string}*** :uri => <uri pointing to db to be monitored>"
-            raise MonitorTypeParameterMissingError.new(string)
-        end
-        begin
-            @uri = URI.parse( @params[:uri] )
-            rescue URI::InvalidURIError=>e
-            string = "*** FluidDb encountered an error while parsing the uri"
-            string = "#{string}*** uri: #{@params[:uri]}"
-            string = "#{string}*** Please fix the uri and run again"
-            raise MonitorTypeParameterMissingError.new(string)
-        end
-
-        if @params[:sql].nil? then
-            string = "*** FluidDb parameter missing, sql"
-            string = "#{string}*** :sql => <sql statement, producing a single column, single row which yeidls a number>"
-            raise MonitorTypeParameterMissingError.new(string)
-        end
-        @sql = @params[:sql]
-
-        @context_sentence = "Checking result of sql query, #{@sql}"
-
-	end
-
-    #Create the connection to the db, and get the value
-    #This ensures that all params are correct.
-	def setup
-
-        begin
-            @fluidDb = FluidDb.Db( @uri )
-            rescue Exception=>e
-            string = "*** FluidDb encountered an error while connecting to the db\n"
-            string = "#{string}*** Error: #{e.message}\n"
-            string = "#{string}*** uri: #{@uri}\n"
-            string = "#{string}*** Please fix the error and run again\n"
-            raise MonitorTypeExceptionHandled.new(string)
-        end
-
-        @params[:fluidDb] = @fluidDb
-	end
-
-	def getValue
-        begin
-            return @fluidDb.queryForValue( @sql, [] )
-            rescue Exception=>e
-            string = "*** FluidDb encountered an error while running the sql\n"
-            string = "#{string}*** sql: #{@sql}\n"
-            string = "#{string}*** Please fix the query and run again\n"
-            raise MonitorTypeExceptionHandled.new(string)
-        end
-	end
-
-        def teardown
-          @fluidDb.close
-	end
-end
-
-def fluiddb( params )
-    $a.add( MonitorType_FluidDb.new( params ) )
-end

data/lib/MonitorType/HttpGetJsonList.rb

@@ -1,58 +0,0 @@
-require "restclient"
-require "MonitorType/Threshold"
-
-#An http class for checking the length of a json list.
-# For example,
-#  Get the list of outstandinig errors
-#  => check that the number is not greater than 2
-
-class MonitorType_HttpGetJsonList<MonitorType_Threshold
-
-    #Extract parameters
-    #
-    # @param [String] uri Connection string to db
-    # @param [String] sql SQL statement to gather a single value
-	def extractParams
-        if @params[:uri].nil? then
-            string = "*** HttpGetJsonList parameter missing, uri\n"
-            string = "#{string}*** :uri => <uri pointing to url to be monitored>"
-            raise MonitorTypeParameterMissingError.new(string)
-        end
-
-        begin
-            @uri = URI.parse( @params[:uri] )
-            rescue URI::InvalidURIError=>e
-            string = "*** HttpGetJsonList encountered an error while parsing the uri"
-            string = "#{string}*** uri: #{@params[:uri]}"
-            string = "#{string}*** Please fix the uri and run again"
-            raise MonitorTypeParameterMissingError.new(string)
-        end
-
-				url = "#{@uri.scheme}://#{@uri.host}#{@uri.path}"
-        @context_sentence = "Checking size of json list returned from, #{url}"
-
-	end
-
-	def getValue
-        begin
-            content = RestClient.get( @uri.to_s )
-						list = JSON.parse( content )
-						raise MonitorTypeExceptionHandled.new( "Expected type, Array - Actual type, #{list.class.name}") unless list.class.name == "Array"
-						return list.length
-
-						rescue MonitorTypeExceptionHandled=>e
-							raise e
-
-            rescue Exception=>e
-            string = "*** HttpGetJsonList encountered an error while running the HTTP Get\n"
-            string = "#{string}*** uri: #{@uri}\n"
-            string = "#{string}*** Please fix the query and run again\n"
-
-            raise MonitorTypeExceptionHandled.new(string)
-        end
-	end
-end
-
-def httpgetjsonlist( params )
-    $a.add( MonitorType_HttpGetJsonList.new( params ) )
-end

data/lib/MonitorType/Process.rb

@@ -1,57 +0,0 @@
-require "MonitorType/Threshold"
-require "helper_functions"
-
-InvalidProcessNameError = Class.new(StandardError)
-
-#A class for checking if a Process is running in Unix based systems
-class MonitorType_Process<MonitorType_Threshold
-
-  #Extract parameters
-  #
-  # @param [String] :process_name THe name of the process to monitor
-  def extractParams
-  	if @params[:process_name].nil? then
-  		string = "*** Process Name parameter missing, process_name\n"
-  		string = "#{string}*** :process_name => <name of the process to be monitored>"
-  		raise MonitorTypeParameterMissingError.new(string)
-  	end
-  	@process_name = @params[:process_name]
-
-  	log "#{@process_name}", "result: #{(@process_name =~ /^(.*\[{1}.+\]{1}.*)$|^(\w+)$/) == 0}"
-
-  	unless (@process_name =~ /^(.*\[{1}.+\]{1}.*)$|^(\w+)$/) == 0 then
-  		string = "*** Process Name parameter doest not match the required pattern, #{@process_name}\n"
-  		string = "#{string}*** :process_name => <plain string, or a string with one or more characters enclosed in square brackets, i.e. 'foo', '[f]oo' or '[foo]'>"
-  		raise InvalidProcessNameError.new(string)
-  	end
-
-  	log "*** Min value will be ignored, setting to 1" unless (params[:min].nil? || params[:min] == 0)
-  	@min = 1
-
-  	log "*** Max value will be ignored, setting to nil" unless params[:max].nil?
-  	@max = nil
-
-  	@context_sentence = "Checking that process is running, #{@process_name}"
-  end
-
-  def setup
-  	self.sanitise
-  rescue MonitorTypeExceptionHandled => e
-  	puts e.message
-  	abort
-  end
-
-	def sanitise
-		#Ensure that the process name contains a single character surrounded by square brackets
-		@process_name = @process_name.insert(0,'[').insert(2,']') unless @process_name =~ /^.*\[.+\].*/
-	end
-
-  def getValue
-  	return `ps aux | grep #{@process_name}`.length
-  end
-
-end
-
-def process(params)
-	$a.add(MonitorType_Process.new(params))
-end

data/lib/MonitorType/Threshold.rb

@@ -1,50 +0,0 @@
-
-#A base class for checking a number against a min and/or max value
-class MonitorType_Threshold<MonitorType
-
-    #See super method for generic description
-	def initialize( params )
-        @min = params[:min] ||= 0
-        @max = params[:max]
-		super( params )
-	end
-
-    #Get the context dependent value which is to be checked
-    def getValue
-        raise "Method needs to be overridden"
-    end
-
-    def process
-        if @block.nil? then
-            value = self.getValue
-            else
-            value = @block.call( @params )
-            string = "value: #{value}\n"
-            puts string
-        end
-
-        self.check( value )
-    end
-
-    #Provides the means to check a value against thresholds
-	def check( value )
-        context_sentence = ""
-        unless @context_sentence.nil? then
-            context_sentence = "#{@context_sentence}\n"
-        end
-
-				url = ""
-				unless @url.nil? then
-					url = "\n\n#{@url}\n"
-				end
-
-        value = value.to_i
-        if !@min.nil? && value < @min then
-            self.alert( "#{context_sentence}Minimum threshold exceeded. Minimum: #{@min}, Actual: #{value}#{url}" )
-        end
-        if !@max.nil? && value > @max then
-            self.alert( "#{context_sentence}Maximum threshold exceeded. Maximum: #{@max}, Actual: #{value}#{url}" )
-        end
-
-	end
-end

data/lib/MonitorType.rb

@@ -1,119 +0,0 @@
-require 'parse-cron'
-
-#This is provided for reporting purposes.
-# It essentially indicates if an error case was expected
-#
-#The idea is to provide clear direction to the user to fix the error, but
-# not stop all monitors in case of a production issue.
-class MonitorTypeExceptionHandled<StandardError
-end
-
-class MonitorTypeParameterMissingError<MonitorTypeExceptionHandled
-end
-
-class MonitorTypeMustHaveNameError<MonitorTypeParameterMissingError
-end
-
-class MonitorTypeMustHaveSenderEmailAddressForEmailAlertError<MonitorTypeParameterMissingError
-end
-
-
-#Base class for Monitors
-#
-#Given that this is a DSL, it extracts named parameters from a hash in order to provide
-#more precise reporting of errors, without spewing syntax errors at a user
-class MonitorType
-
-    #Check that all required parameters have been passed in
-    #Make sure that any errors encountered are reported in a way that
-    # fixing the error is made easier
-    def initialize( params )
-        if params[:name].nil? then
-            string = "*** Monitor parameter missing, name"
-            string = "#{string}*** :name => <name of monitor>"
-            raise MonitorTypeMustHaveNameError.new(string)
-        end
-        @params = params
-        @block = params[:block] unless params[:block].nil?
-        @name = params[:name]
-        @email = params[:email]
-        @url = params[:url] unless params[:url].nil?
-
-        if !@email.nil? then
-            #Sender email address from ENV allows for a single sender across all alerts
-            #Checking params before ENV allows a particular entry to be different
-            if params[:email_sender].nil? then
-                if ENV["EMAIL_SENDER"].nil? then
-                    string = "*** Alert parameter missing, email_sender"
-                    string = "#[string}*** An email recipient has been specified for monitor, #{@name}, but no email sender has been specified"
-                    string = "#[string}*** :email_sender => <email of sender>"
-                    string = "#[string}*** or, a catch all environment variable"
-                    string = "#[string}*** EMAIL_SENDER=<email of sender>"
-
-                    raise MonitorTypeMustHaveSenderEmailAddressForEmailAlertError.new(string)
-                    else
-                    @sender_email = ENV["EMAIL_SENDER"]
-                end
-                else
-                @sender_email = params[:admin_email]
-            end
-        end
-
-        cron_string = params[:cron] || "0 1 * * *"
-        @cron = CronParser.new(cron_string)
-        @next = Time.now - 1
-
-        log "Loaded Monitor, #{@name}."
-    end
-
-    #Overload this method if any parameters should be checked in context
-    def extractParams
-    end
-
-    #Overload this method if any parameters should be checked in context
-    def setup
-    end
-
-    #Overload this method if any parameters should be checked in context
-    def teardown
-    end
-
-    #Check if the monitor has tripped
-    def process
-        raise "Method needs to be overridden"
-    end
-
-    #An extention of the main run loop.
-    #Each monitor is responsible for knowing when it should run, so this function
-    #is called pretty much continuosuly.
-    #
-    def run
-        if Time.now > @next then
-            begin
-                @next = @cron.next( Time.now )
-                log "Monitor, #{@name}, next run time, #{@next}"
-                self.extractParams
-                self.setup
-                self.process
-                self.teardown
-                rescue MonitorTypeExceptionHandled => e
-                self.alert( e.message )
-            end
-        end
-    end
-
-    #Called when a monitor has been tripped
-    #
-    # @param [String] string A description of the trip that occurred
-	def alert( string )
-        body = "#{@name} tripped.\n#{string}"
-        puts "*** "
-		if !@email.nil? then
-			Alert_Email.new( @sender_email, @email, body ).Send
-            puts "Emailed, #{@email}"
-            else
-            puts body
-		end
-	end
-
-end