procmon 0.0.1

data/README

@@ -0,0 +1,44 @@
+Example of how to use Procmon
+
+require 'procmon'
+
+
+notifier = Proc.new do
+  puts "I NEED TO SEND OUT AN EMAIL"
+end
+
+notifier2 = Proc.new do
+  puts "I NEED TO SEND OUT AN SMS"
+end
+
+# action be be a Proc object. You can define whatever you want to do 
+Procmon.process("Mail") do |process|
+  process.checks :mem_usage, :above => 100.megabytes, :actions => [notifier, notifier2]
+end
+
+# You can specify a code block as well
+Procmon.process("Mail") do |process|
+  process.pid = 29124
+  process.checks :mem_usage, :above => 100.megabytes do
+    puts "I'm in your base"
+  end
+end
+
+# Using built-in email notifier
+NOTIFICATION_TARGET='ddao@example.com'
+Procmon.process("Mail") do |process|
+  process.checks :mem_usage, :above => 100.megabytes, :actions => [Procmon::Notifiers::Email]
+end
+
+# Would be nice if we can do this as well
+# Procmon.process("Mail") do |process|
+#  process.checks :mem_usage, :above => 100.megabytes do |action|
+#    action.perform(notifier)
+#    action.perform(Procmon::Notifiers::Email, 'someone@example.com')
+#  end
+#  process.checks :mem_usage, :above => 100.megabytes, :actions => [notifier, notifier2]
+#  process.checks :mem_usage, :above => 100.megabytes, :actions => [Procmon::Notifiers::Email]
+#end
+
+
+

data/lib/procmon/dsl/process_factory.rb

@@ -0,0 +1,41 @@
+module Procmon
+  class ProcessFactory
+    attr_reader :attributes, :name, :checks
+    def initialize(name, attributes, process_block)
+      @checks = {}
+      @name = name
+      @attributes = attributes
+      if process_block.arity == 0
+        instance_eval &process_block
+      else
+        instance_exec(self, &process_block)
+      end
+    end
+
+    def method_missing(name, *args)
+      if args.size == 1 && name.to_s =~ /^(.*)=$/
+        @attributes[$1.to_sym] = args.first
+      elsif args.size == 1
+        @attributes[name.to_sym] = args.first
+      elsif args.size == 0 && name.to_s =~ /^(.*)!$/
+        @attributes[$1.to_sym] = true
+      elsif args.empty? && @attributes.key?(name.to_sym)
+        @attributes[name.to_sym]
+      else
+        super
+      end
+    end
+
+    def checks(name, options = {}, &block)
+      if block
+        options[:actions] ||= []
+        options[:actions] << block
+      end
+      @checks[name] = options
+    end
+
+    def create_process
+      Process.new(@name, @checks, @attributes)
+    end    
+  end
+end

data/lib/procmon/dsl.rb

@@ -0,0 +1,7 @@
+module Procmon
+  def self.process(proc_name, options = {}, &block)
+    proc_fact = ProcessFactory.new(proc_name, options, block)
+    process = proc_fact.create_process
+    process.run_checks
+  end
+end

data/lib/procmon/notifiers/email.rb

@@ -0,0 +1,16 @@
+module Procmon
+  module Notifiers
+    class Email < Notifier
+      def self.notify(notification, target=nil)
+        if target.nil? && !defined?(NOTIFICATION_TARGET)
+          warn "Don't know where to send the notification"
+        elsif target.nil?
+          target = NOTIFICATION_TARGET
+        end
+
+        puts "Need to email #{target} the following"
+        puts notification
+      end
+    end
+  end
+end

data/lib/procmon/notifiers/notifier.rb

@@ -0,0 +1,9 @@
+module Procmon
+  module Notifiers
+    class Notifier
+      def self.notify
+        raise "Implement in subclass!"
+      end
+    end
+  end
+end

data/lib/procmon/notifiers.rb

@@ -0,0 +1,5 @@
+require 'procmon/notifiers/notifier'
+
+Dir["#{File.dirname(__FILE__)}/notifiers/*.rb"].each do |file|
+  require file
+end

data/lib/procmon/process.rb

@@ -0,0 +1,81 @@
+module Procmon
+  class Process
+    CONFIGURABLE_ATTRIBUTES = [
+      :pid_file,
+      :pid_command,
+      :pid
+    ]
+    attr_accessor *CONFIGURABLE_ATTRIBUTES
+    attr_accessor :name, :checks
+
+    def initialize(name, checks, options={})
+      @name = name
+      @checks = []
+
+      CONFIGURABLE_ATTRIBUTES.each do |attribute_name|
+        self.send("#{attribute_name}=", options[attribute_name]) if options.has_key?(attribute_name)
+      end
+
+      if @pid_command.nil? or @pid_command.empty?
+        @pid_command = "pidof"
+      end
+
+      if @pid.nil?
+        @pid = fetch_pid
+      end
+
+      checks.each do |name, opts|
+        self.add_check(name, opts)
+      end
+    end
+
+    def run_checks
+      @checks.each do |check|
+        value = check.run(pid)
+        condition_met = check.check(value)
+        perform_actions(check) if condition_met
+      end
+    end
+
+    def add_check(name, options)
+      self.checks << ProcessConditions[name].new(options)
+    end
+
+    def perform_actions(check)
+      return if check.actions.nil? or check.actions.empty?
+
+      check.actions.each do |action|
+        if action.kind_of?(Proc)
+          action.call(self, check)
+        elsif action.kind_of?(Class) && action.respond_to?('notify')
+          notification = ProcessNotification.new(self, check)
+          action.notify(notification)
+        else
+          warn "Don't know what to do for #{action}."
+        end
+      end
+    end
+
+    private
+    def fetch_pid
+      pid_from_command || pid_from_file
+    end
+
+    def pid_from_file
+      if pid_file
+        if File.exists?(pid_file)
+          str = File.read(pid_file)
+          str.to_i if str.size > 0
+        else
+          logger.warning("pid_file #{pid_file} does not exist or cannot be read")
+          nil
+        end
+      end
+    end
+
+    def pid_from_command
+      pid = %x{#{pid_command} #{@name}}.strip
+      (pid =~ /\A\d+\z/) ? pid.to_i : nil
+    end
+  end
+end

data/lib/procmon/process_conditions/mem_usage.rb

@@ -0,0 +1,55 @@
+module Procmon
+  module ProcessConditions
+    class MemUsage < ProcessCondition
+      MB = 1024 ** 2
+      FORMAT_STR = "%d%s"
+      MB_LABEL = "MB"
+      KB_LABEL = "KB"
+
+      attr_reader :actions
+
+      def initialize(options = {})
+        @options = options
+        @actions = options[:actions]
+        @below = options[:below]
+        @above = options[:above]
+        if @below && @above && @below < @above
+          raise "Invalid range for mem check condition"
+        elsif @below.nil? && @above.nil?
+          raise "Invalid range for mem check condition"
+        end
+      end
+
+      def run(pid)
+        # rss is on the 5th col
+        System.memory_usage(pid).to_f
+      end
+
+      def check(value)
+        if @below && @above
+          value.kilobytes < @below && value.kilobytes > @above
+        elsif @below
+          value.kilobytes < @below 
+        elsif @above
+          value.kilobytes > @above
+        end
+      end
+
+      def format_value(value)
+        if value.kilobytes >= MB
+          FORMAT_STR % [(value / 1024).round, MB_LABEL]
+        else
+          FORMAT_STR % [value, KB_LABEL]
+        end
+      end
+
+      def description
+        ret = "Memory usage is "
+        conditions = {}
+        conditions[:below] = @options[:below] if @options[:below]
+        conditions[:above] = @options[:above] if @options[:above]
+        ret += conditions.inspect
+      end
+    end
+  end
+end

data/lib/procmon/process_conditions/process_condition.rb

@@ -0,0 +1,25 @@
+module Procmon
+  module ProcessConditions
+    class ProcessCondition
+      def initialize(options = {})
+        @options = options
+      end
+
+      def run(pid)
+        raise "Implement in subclass!"
+      end
+
+      def check(value)
+        raise "Implement in subclass!"
+      end
+
+      def format_value(value)
+        value
+      end
+
+      def description
+        raise "Implement in subclass!"
+      end
+    end
+  end
+end

data/lib/procmon/process_conditions.rb

@@ -0,0 +1,12 @@
+module Procmon
+  module ProcessConditions
+    def self.[](name)
+      const_get(name.to_s.camelcase)
+    end
+  end
+end
+
+require "procmon/process_conditions/process_condition"
+Dir["#{File.dirname(__FILE__)}/process_conditions/*.rb"].each do |pc|
+  require pc
+end

data/lib/procmon/process_notification.rb

@@ -0,0 +1,14 @@
+module Procmon
+  class ProcessNotification
+    def initialize(process, check)
+      hostname = `hostname`.strip
+      @msg = ""
+      @msg += "Hostname: #{hostname}" + "\n"
+      @msg += "Process: #{process.name}" + "\n"
+      @msg += "Description: #{check.description}"
+    end
+    def to_s
+      @msg
+    end
+  end
+end

data/lib/procmon/system.rb

@@ -0,0 +1,38 @@
+module Procmon
+  # Copied from Bluepill code
+  module System
+    extend self
+
+    # The position of each field in ps output
+    IDX_MAP = {
+      :pid => 0,
+      :ppid => 1,
+      :pcpu => 2,
+      :rss => 3
+    }
+
+    def store
+      @store ||= Hash.new
+    end
+
+    def memory_usage(pid)
+      ps_axu[pid] && ps_axu[pid][IDX_MAP[:rss]].to_f
+    end
+
+    def ps_axu
+      # TODO: need a mutex here
+      store[:ps_axu] ||= begin
+        # BSD style ps invocation
+        lines = `ps axo pid,ppid,pcpu,rss`.split("\n")
+
+        lines.inject(Hash.new) do |mem, line|
+          chunks = line.split(/\s+/)
+          chunks.delete_if {|c| c.strip.empty? }
+          pid = chunks[IDX_MAP[:pid]].strip.to_i
+          mem[pid] = chunks
+          mem
+        end
+      end
+    end
+  end
+end

data/lib/procmon/version.rb

@@ -0,0 +1,3 @@
+module Procmon
+  VERSION = "0.0.1".freeze
+end

data/lib/procmon.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/numeric'
+require 'active_support/duration'
+
+require 'procmon/system'
+require 'procmon/process'
+require 'procmon/dsl'
+require 'procmon/dsl/process_factory'
+require 'procmon/process_conditions'
+require 'procmon/process_notification'
+require 'procmon/notifiers'

data/lib/test.rb

@@ -0,0 +1,36 @@
+require 'procmon'
+
+NOTIFICATION_TARGET='ddao@example.com'
+
+notifier = Proc.new do 
+  puts "I NEED TO SEND OUT AN EMAIL"
+end
+
+notifier2 = Proc.new do 
+  puts "I NEED TO SEND OUT AN EMAIL 2"
+end
+
+Procmon.process("Mail") do |process|
+  process.pid = 29124
+  process.checks :mem_usage, :above => 100.megabytes do
+    puts "I'm in your base"
+  end
+end
+
+Procmon.process("Mail") do |process|
+  process.checks :mem_usage, :above => 100.megabytes, :actions => [notifier, notifier2]
+end
+
+Procmon.process("Mail") do |process|
+  process.checks :mem_usage, :above => 100.megabytes, :actions => [Procmon::Notifiers::Email]
+end
+
+# Would be nice if we can do this
+# Procmon.process("Mail") do |process|
+#  process.checks :mem_usage, :above => 100.megabytes do |action|
+#    action.perform(notifier)
+#    action.perform(Procmon::Notifiers::Email, 'someone@eharmony.com')
+#  end
+#  process.checks :mem_usage, :above => 100.megabytes, :actions => [notifier, notifier2]
+#  process.checks :mem_usage, :above => 100.megabytes, :actions => [Procmon::Notifiers::Email]
+#end

data/procmon.gemspec

@@ -0,0 +1,24 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+
+require "procmon/version"
+
+Gem::Specification.new do |s|
+  s.name        = "procmon"
+  s.version     = Procmon::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Darren Dao"]
+  s.email       = ["darrendao@gmail.com"]
+  s.homepage    = "http://github.com/darrendao/procmon"
+  s.summary     = %q{A process monitor written in Ruby. Concepts and design are based on Bluepill and God, but with emphasis on simplicity and extensibility.}
+  s.description = %q{Procmon allows you to check on processes and then perform arbitary actions based on the result of the checks. For example, you can send notification when mem usage is too high, or you can restart a process if it's dead, etc. It is not meant to run as a daemon. It is designed to be invoked manually or via cron.}
+
+  s.add_dependency 'activesupport', '>= 3.0.0'
+  s.add_dependency 'i18n', '>= 0.5.0'
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths    = ["lib"]
+  s.extra_rdoc_files = ["README"]
+end
+

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: procmon
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Darren Dao
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-15 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.0
+    version: 
+description: Procmon allows you to check on processes and then perform arbitary actions based on the result of the checks. For example, you can send notification when mem usage is too high, or you can restart a process if it's dead, etc. It is not meant to run as a daemon. It is designed to be invoked manually or via cron.
+email: 
+- darrendao@gmail.com
+executables: 
+- placeholder
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- bin/placeholder
+- lib/procmon.rb
+- lib/procmon/.dsl.rb.swp
+- lib/procmon/dsl.rb
+- lib/procmon/dsl/process_factory.rb
+- lib/procmon/notifiers.rb
+- lib/procmon/notifiers/email.rb
+- lib/procmon/notifiers/notifier.rb
+- lib/procmon/process.rb
+- lib/procmon/process_conditions.rb
+- lib/procmon/process_conditions/mem_usage.rb
+- lib/procmon/process_conditions/process_condition.rb
+- lib/procmon/process_notification.rb
+- lib/procmon/system.rb
+- lib/procmon/version.rb
+- lib/test.rb
+- procmon.gemspec
+has_rdoc: true
+homepage: http://github.com/darrendao/procmon
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A process monitor written in Ruby. Concepts and design are based on Bluepill and God, but with emphasis on simplicity and extensibility.
+test_files: []
+