qnotifier 0.6.2

data/Manifest

@@ -0,0 +1,21 @@
+Manifest
+Rakefile
+bin/qnotifier
+config/qnotifier_config.yml
+gem-public_cert.pem
+lib/command.rb
+lib/plugin.rb
+lib/qnotifier.rb
+lib/storage.rb
+lib/web_service.rb
+plugins/apache.rb
+plugins/iostat.rb
+plugins/mysql.rb
+plugins/network.rb
+plugins/nginx.rb
+plugins/passenger.rb
+plugins/processes.rb
+plugins/rails.rb
+plugins/ruby.rb
+plugins/system.rb
+plugins/urls.rb

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('qnotifier', '0.6.0') do |p|
+  p.description    = "The server side agent for the QNotifier monitoring system"
+  p.url            = "http://qnotifier.com/qnotifier_gem"
+  p.author         = "Gersham Meharg"
+  p.email          = "gersham@qnotifier.com"
+  p.ignore_pattern = ["var/*"]
+  p.runtime_dependencies = ["rest-client >=1.4.2", "json >=1.2.3", "elif >=0.1.0"]
+  p.development_dependencies = ["rest-client >=1.4.2", "json >=1.2.3", "elif >=0.1.0"]
+  p.executable_pattern = ["bin/*"]
+  p.install_message = "Qnotifier installed,  please register by running 'qnotifier -r CODE' in order to register this server."
+end

data/bin/qnotifier

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift( File.join( File.dirname(__FILE__), '../lib' ) )
+require "command"
+
+Qnotifier::Command.run(ARGV)
+

data/config/qnotifier_config.yml

@@ -0,0 +1,112 @@
+# qnotifier_config.yml file
+---
+# 
+# This is the configuration file for the Qnotifier Agent
+# It should live in /etc/qnotifier.config
+#
+# Note that this file is YML formatted, please respect the indents
+#
+
+#
+# General Settings
+#
+
+# Whether to resend alerts 
+resend_alerts: true
+# resend_alert_time: Resend alerts every X seconds
+resend_alert_time: 1 #14400 # Four hours
+
+# alert_email_address: if this is defined any alerts will be copied to this email address
+# Note that is in addition to the Qnotifier notifications
+#alert_email_address: user@domain.com
+
+#
+# PLUGINS
+#
+
+# Where to look for user generated plugins
+# To add your own plugin subclass the Qnotifier::Plugin class and put this in to this directory
+# You may add configuration parameters here based on the name of your plugin class
+plugin_directory: "/var/qnotifier"
+
+# The System Plugin must be enabled, this gives basic stats like load average, disk use, memory, etc
+System:
+    # use_load: either one_minute, five_minute or fifteen_minutes
+    use_load: five_minute     
+    # normalize_load: whether to divide the reported load by the number of CPUs in the system          
+    normalize_load: true
+    # Alert if the CPU is above this percent usage, 0 disables                
+    alert_cpu_threshold: 10
+    # Alert if the memory is above this percent usage, 0 disables             
+    alert_memory_threshold: 10
+    # Alert if the memory is above this percent usage, 0 disables          
+    alert_load_threshold: 1.0
+    # Alert if the memory is above this percent usage, 0 disables
+    alert_disk_threshold: 90
+    # Partitions which to monitor for free disk space
+    partitions: 
+        - "/"
+    
+# The Apache built-in plugin
+Apache:
+    # Enabled, set to either true or false
+    enabled: false
+    monitor_url: "http://localhost/foo"
+    username: "username"
+    password: "password"
+    
+# The IOStat built-in plugin
+Iostat:
+    # Enabled, set to either true or false
+    enabled: false
+    
+# The MySQL built-in plugin
+Mysql:
+    # Enabled, set to either true or false
+    enabled: false
+    username: "username"
+    password: "password"
+
+# The Network Interface built-in plugin  
+Network:
+    # Enabled, set to either true or false
+    enabled: false
+    interfaces: 
+        - eth0
+
+# The Nginx built-in plugin
+Nginx:
+    # Enabled, set to either true or false
+    enabled: false
+    username: "username"
+    password: "password"
+ 
+# The Passenger Phusion built-in plugin   
+Passenger:
+    # Enabled, set to either true or false
+    enabled: false
+ 
+# The Process List built-in plugin   
+Processes:
+    # Enabled, set to either true or false
+    enabled: false
+  
+# The Rails built-in plugin  
+Rails:
+    # Enabled, set to either true or false
+    enabled: false
+    log_file: "/var/www/rails/log/production.log"
+
+# The Ruby built-in plugin
+Ruby:
+    enabled: true
+    list_gems: true
+
+#
+# Other settings that you generally will not need to modify
+#
+
+# The API End Point in which to send our pings
+#api_endpoint: "http://ping.qnotifier.com"
+api_endpoint: "http://localhost:4567"
+    

data/gem-public_cert.pem

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDODCCAiCgAwIBAgIBADANBgkqhkiG9w0BAQUFADBCMRAwDgYDVQQDDAdnZXJz
+aGFtMRkwFwYKCZImiZPyLGQBGRYJcW5vdGlmaWVyMRMwEQYKCZImiZPyLGQBGRYD
+Y29tMB4XDTEwMDMxNzE4MjAwOFoXDTExMDMxNzE4MjAwOFowQjEQMA4GA1UEAwwH
+Z2Vyc2hhbTEZMBcGCgmSJomT8ixkARkWCXFub3RpZmllcjETMBEGCgmSJomT8ixk
+ARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMS8vIaSE0eA
+DfL3OqRwmY+b3ueQ+cfm2nxU1J+TE7yFFGiv+bk4z4YMtHtbqsGxlmL4HZKW7Ur/
+RrS7+d+fVTskoRC7t9g6mRoww/4+fTgmX25g7YLe4vuiSBkBeBMXBt5Vd3ombU9F
+b0CrguX2a2ffYxnF/RlrXnhsU2VywZry+qz1NJglaCa+qb0S0W3BnvoB8T+MxNOM
+7feKF/HvWRCM7DdHyqXqHFqMBIWJlCC7MFV4kQVW/a8b49VC5Dgmz6QVWcPqQ8cl
+GK35UW+1WZXRB5Mhv5HBAQQqzLut46pxbUJ3qIpibtp1ltgyu81ZIRAwKIWx0YNv
+lP5V85hTZ1ECAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUn3O2jt+12CmU
+t1GEK8NZRNRbzqwwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQBb5gk8
+OyfuloScbz/oHOopNmSc+o/s/5MvyrslPYDZA0WGR/63Q4Wl6l/tFFPwuAZH1KAI
+MtLf7mVDdijHQf3Q6e+DicNRRQrl1w3s2m4PHyPiFUmXULzWHbMc3OK4LdM+1f5q
+oZvsRrAAz6esBChxfdpuNCsP9Eu3j9MIWHy4KPTNuqOFyI+p3YVW2+SHeN4gBCyV
+b7VZHIY+1kKjmMYXPeG9xlXaxLABhS1iN66tAyg66l6u6vuLt5Rdh1RUIY534Edq
+ciUZJrPp/am/m0FtGWggbAohDKjiKRL0E6OCFQ7wSCTUPKoB9MbIJkKSGFo6ExWe
+wu7A8rLN6CU0SfWf
+-----END CERTIFICATE-----

data/lib/command.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+require "optparse"
+require "qnotifier"
+
+module Qnotifier
+  class Command
+    
+    def self.parse_options(argv)
+      options = {}
+      
+      op = OptionParser.new do |opts|
+        
+        opts.banner = "\nQnotifier is an agent for the Qnotifer server reporting and alerting system"
+        opts.separator "See http://qnotifier.com for details."
+        opts.separator "\nUsage:"
+        
+        opts.on("-r", "--register CODE", String, "Register agent with code.") do |register_code|
+          qnotifier = Qnotifier::Process.new
+          qnotifier.debug = true if @debug
+          qnotifier.register(register_code)
+          exit
+        end
+        opts.on("-v", "--version", "Displays the agent version") do |version|
+          puts "Qnotifier Agent Version: #{Qnotifier::VERSION}"
+          exit
+        end
+        opts.on("-d", "--debug", "Run in debug mode") do |debug|
+          @debug = true
+        end
+        opts.on("-h", "--help", "Shows this help") do 
+          puts opts
+          exit
+        end
+        opts.separator "\n"
+      end
+      
+      begin
+        op.parse!(argv)
+        @usage = op.to_s
+      rescue OptionParser::InvalidOption
+         puts op
+         exit
+      rescue OptionParser::MissingArgument
+        puts op
+        exit
+      end
+      options
+    end
+    
+    def self.run(argv)
+      argv.push("--help") if argv.first == 'help'
+      options = parse_options(argv)
+      qnotifier = Qnotifier::Process.new
+      qnotifier.debug = true if @debug
+      qnotifier.run
+    end
+  end
+end
+

data/lib/plugin.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+require "storage"
+
+# Subclass this to create a new plugin
+# Note that plugins only get 30 seconds to run and do their thing
+module Qnotifier
+  class Plugin
+      
+    attr_accessor :reports
+    attr_accessor :alerts
+    attr_accessor :stats    
+    attr_accessor :config
+    attr_accessor :alert_count
+     
+    # The run method, do not override
+    def run
+      @class_name = self.class.to_s.split("::").last
+      @alert_count = 0
+      
+      # Read the options from the global config and mix them in to the defaults for this plugin      
+      if @config[@class_name]
+        @options = @defaults.update(@config[@class_name])
+      else
+        @options = @defaults
+      end
+      
+      # Only run this plugin if it's enabled
+      return unless @options["enabled"]
+      
+      Qnotifier.log.debug("Plugin #{@class_name} running")
+      main
+    end
+    
+    # You'll need to override this in your subclass
+    def main
+      Qnotifier.log.error("You must implement the main method in the plugin: #{self.class.name}")
+    end
+    
+    # Log something to console
+    # Log levels: log.info, log.warn, log.error, log.fatal, log.unknown    
+    def log
+      return Qnotifier.log
+    end
+    
+    # Alert is an alert to the adminstrators that something requires looking at
+    # Severity should usually be 3
+    def alert(name, message, severity = 3)
+      @alerts = {@class_name => []} unless @alerts
+      @alert_count += 1
+      # Only send the alert if we haven't already
+      if Qnotifier::Storage.get("AlertTime_#{@class_name}-#{name}")
+        # Check to see if we need to resend the alert
+        if @config["resend_alerts"] and Qnotifier::Storage.get("AlertTime_#{@class_name}-#{name}") < Time.now - @config["resend_alert_time"]
+          add_alert(name, message, severity)
+        else
+          Qnotifier.log.debug("Already sent alert: #{message}")
+        end
+      else 
+        add_alert(name, message, severity)
+      end
+    end
+    
+    # Add the alert to the outbound queue
+    def add_alert(name, message, severity)
+          	
+      if severity == 1 # emergency
+        log.fatal message
+      elsif severity == 2 # critical
+        log.error message
+      elsif severity == 3 # alert
+        log.error message
+      elsif severity == 4 # error
+        log.error message
+      elsif severity == 5 # warn
+        log.warn message
+      elsif severity == 6 # clear
+        log.info message
+      end
+      data = [name, message, severity]
+      @alerts[@class_name].push(data)
+      Qnotifier::Storage.put("AlertTime_#{@class_name}-#{name}", Time.now)
+    end
+    
+    # Alert is no longer needed as the value has crossed back over the threshold value
+    def reset_alert(name, message)
+      @alerts = {@class_name => []} unless @alerts
+      if Qnotifier::Storage.get("AlertTime_#{@class_name}-#{name}")
+        log.warn message
+        Qnotifier::Storage.delete("AlertTime_#{@class_name}-#{name}")
+        data = [name, message, 6] # Clear 
+        @alerts[@class_name].push(data)
+      end
+    end
+    
+    # Report is an ongoing data point for graphing and realtime reporting for this server
+    def report(key, value)
+      @reports = {@class_name => []} unless @reports
+      @reports[@class_name].push([key, value])
+    end
+    
+    # Stat is a one time statistic about this server, it doesn't get tracked and graphed
+    def stat(key, value)
+      @stats = {@class_name => {}} unless @stats
+      @stats[@class_name].merge!(key => value.to_s)
+    end
+    
+    # Store this value for later retrieval
+    def put(key, value)
+      Qnotifier::Storage.put(key, value)
+    end
+    
+    # Retrieve this value
+    def get(key)
+      Qnotifier::Storage.get(key)
+    end    
+    
+    # Delete the value
+    def delete(key)
+      Qnotifier::Storage.delete(key)
+    end
+  end
+end

data/lib/qnotifier.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+require "yaml"
+require "timeout"
+require "logger"
+require "plugin"
+require "web_service"
+require "storage"
+
+module Qnotifier
+  VERSION = "0.7.0".freeze
+
+  def self.log
+    unless @logger
+      begin
+        @logger = Logger.new("/var/log/qnotifier.log","monthly") 
+      rescue Exception => e 
+        puts "Error starting logging - using stdout (#{e.message})"
+        @logger = Logger.new($stdout) 
+      end
+    end
+    return @logger
+  end
+      
+  class Process
+    
+    attr_accessor :debug
+    
+    def initialize
+      Qnotifier::Storage.restore
+      
+      @alerts = {}
+      @reports = {}
+      @stats = {}
+      @alert_count = 0
+    end
+    
+    def start_logging
+      # Logging
+      if @debug
+        puts "Starting in debug mode"
+        Qnotifier.log.level = Logger::DEBUG 
+      else
+        Qnotifier.log.level = Logger::INFO 
+      end
+    end
+    
+    def run
+      start_logging
+      load_config
+      
+      last_run = Qnotifier::Storage.get("last_run")
+      
+      if Qnotifier::Storage.get("server_disabled_pings")
+        Qnotifier.log.fatal "Disabled by the Qnotifer API, please re-register (qnotifier --register key) this agent to enable. Exiting."
+        exit
+      end
+                  
+      # Start up
+      Qnotifier.log.info "Running#{", last run: #{last_run}" if last_run}"
+      Qnotifier::Storage.put("last_run", Time.now) unless @debug
+      unless @debug
+        if last_run and (Time.now - last_run) < 120
+          message = "Starting too frequently, please run every 5 minutes (use debug mode to override)\nLast start up: #{last_run}"
+          puts message
+          Qnotifier.log.fatal message
+          exit
+        end
+      end
+      
+      unless @config["api_key"]
+        error_message =  "Missing API Key, please register this agent first."
+        puts error_message
+        Qnotifier.log.fatal error_message
+        exit
+      end
+      
+      # Load the built in plugins
+      Dir[File.dirname(__FILE__) + '/../plugins/*.rb'].each do |file| 
+        process_plugin_file(file)
+      end
+      
+      # Load the user plugins
+      Dir[@config["plugin_directory"] + '/*.rb'].each do |file| 
+        process_plugin_file(file)
+      end
+            
+      # Send the alerts, reports and stats to the API
+      webservice = Qnotifier::WebService.new
+      webservice.config = @config
+      webservice.send_alerts(@alerts)
+      webservice.send_reports_stats(@reports, @stats, @alert_count)
+      
+      Qnotifier::Storage.save
+      
+      # Done, clean up and save
+      Qnotifier::Storage.save
+    end
+    
+    def process_plugin_file(file)
+      return unless file =~ /\.rb/
+      require file
+      class_name = "Qnotifier::#{File.basename(file, ".rb").split(/[^a-z0-9]/i).map{|w| w.capitalize}.join}"
+      begin
+        plugin = eval(class_name).new
+      rescue
+        Qnotifier.log.error "Couldn't process the plugin file #{file}"
+        return
+      end
+      plugin.config = @config
+      unless plugin.class.superclass.name == "Qnotifier::Plugin"
+        Qnotifier.log.fatal "Attempted to load a non Qnotifier::Plugin plugin subclass at #{file} - make sure this directory only includes Qnotifier::Plugin subclasses"
+        return
+      end
+      begin
+        Timeout.timeout 30 do
+          plugin.run
+        end
+      rescue RuntimeError => e 
+        Qnotifier.log.error "#{class_name} Plugin Error: #{e.message}"
+      rescue Errno::ENOENT => e
+        Qnotifier.log.error "#{class_name} Plugin Error: #{e.message}" 
+      end
+      @alerts.merge!(plugin.alerts) if plugin.alerts
+      @reports.merge!(plugin.reports) if plugin.reports
+      @stats.merge!(plugin.stats) if plugin.stats
+      @alert_count += plugin.alert_count
+    end
+    
+    def register(code)
+      
+      start_logging
+      load_config
+            
+      if @config["api_key"]
+        Qnotifier.log.error "Server already registered.  You should not keep registering the server, you only need to do this once."
+      end
+      
+      webservice = Qnotifier::WebService.new
+      webservice.config = @config
+      api_key = webservice.register_server(code)
+      
+      save_api_key(api_key)
+      
+    end
+    
+    def save_api_key(api_key)
+      return unless api_key
+      @config["api_key"] = api_key
+      begin
+        File.open(File.dirname(__FILE__) + "/../var/api_key", 'w') {|f| f.write(api_key) }
+      rescue Exception => e
+        Qnotifier.log.fatal "Can't save API Key #{e.message}"
+      end
+    end
+    
+    def load_config
+      
+      # Make the var dir if it doesn't exist
+      var_dir = File.dirname(__FILE__) + "/../var"
+      FileUtils.mkdir_p var_dir
+      
+      # Load from /etc/qnotifier_config.yml if the file is there
+      begin
+        @config = YAML::load(File.open('/etc/qnotifier_config.yml'))
+      rescue Exception => e
+        Qnotifier.log.error "Can't open /etc/qnotifier_config.yml (loading default config and copying it to /etc/qnotifier_config.yml)"
+        begin
+          default_config_file = File.dirname(__FILE__) + "/../config/qnotifier_config.yml"
+          @config = YAML::load(File.open(default_config_file))
+          `cp #{default_config_file} /etc/qnotifier_config.yml`
+        rescue Exception => e
+          Qnotifier.log.fatal "Can't open default config #{e.message}"
+          exit
+        end
+      end
+      
+      unless @config["api_key"]
+        begin
+          api_key_file = File.open(File.dirname(__FILE__) + "/../var/api_key")
+          while (line = api_key_file.readline)
+            @config["api_key"] = line
+          end
+        rescue EOFError
+        rescue Exception => e
+          Qnotifier.log.debug "Can't get API key, have you registered?"
+        end
+      end
+    end
+  end
+end

data/lib/storage.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env
+require "yaml"
+
+module Qnotifier
+  class Storage
+
+    @@stored_variables = {}
+    @@restored = false
+
+    def self.restore
+      begin
+        saved_variables = File.dirname(__FILE__) + "/../var/saved_variables.yml" 
+        @@stored_variables = YAML::load(File.open(saved_variables))
+      rescue Exception => e
+        Qnotifier.log.debug "Error loading stored variables file. #{e.message}"
+      end
+      @@restored = true
+    end
+
+    def self.get(key)
+      restore unless @@restored
+      if @@stored_variables[key]
+        return @@stored_variables[key]
+      else
+        return nil
+      end
+    end
+    
+    def self.put(key, value)
+      restore unless @@restored
+      @@stored_variables[key] = value
+    end
+    
+    def self.delete(key)
+      restore unless @@restored
+      @@stored_variables.delete(key)
+    end
+    
+    def self.save
+      begin
+        saved_variables = File.dirname(__FILE__) + "/../var/saved_variables.yml" 
+        File.open(saved_variables, "w") do |f|
+          f.write(YAML::dump(@@stored_variables))
+        end
+      rescue Exception => e
+        Qnotifier.log.error "Error saving stored variables file. #{e.message}"
+      end
+    end
+  end
+end

data/lib/web_service.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+require 'rest_client'
+require 'json'
+require "storage"
+
+module Qnotifier
+  class WebService
+    
+    attr_accessor :config
+    
+    def initialize
+      
+      RestClient.proxy = ENV['http_proxy']
+    end
+        
+    def send_alerts(alerts)
+      
+      return if alerts.empty?
+      Qnotifier.log.debug "Sending #{alerts.count} alerts"
+
+      # Hostname
+      unless @config["hostname"]
+        @hostname = `hostname`.strip
+      else
+        @hostname = @config["hostname"]
+      end
+
+      message = {"api_key" => @config["api_key"], 
+                 "api_version" => "1.0",
+                 "agent_version" => Qnotifier::VERSION,
+                 "hostname" => @hostname,
+                 "alerts" => alerts}.to_json
+      
+      begin 
+        resource = RestClient::Resource.new(@config["api_endpoint"],
+                :timeout => 30, 
+                :headers => { :user_agent => "Qnotifier-#{Qnotifier::VERSION}" })
+        response = resource["/send_alert"].post(message, :content_type => 'application/json')
+        
+        if response.code == 200
+          Qnotifier.log.debug "Server Response: HTTP #{response.code} #{response.body}"
+        else
+          Qnotifier.log.warn "Server Response: HTTP #{response.code} #{response.body}"
+        end
+        
+      rescue Exception => e
+        Qnotifier.log.error "Sending Alerts: Can't connect to #{@config["api_endpoint"]} - #{e.message}"
+        if e.message == "HTTP status code 402"
+          # The server doesn't want to hear from us any more, disable pinging
+          Qnotifier::Storage.put("server_disabled_pings", Time.now)
+          Qnotifier.log.error "Server has asked us to disable pings"
+        end
+      end
+    end
+    
+    def send_reports_stats(reports, stats, alert_count)
+      
+      return if reports.empty? and stats.empty?
+      Qnotifier.log.debug "Sending Reports and Stats"
+      
+      # Hostname
+      unless @config["hostname"]
+        @hostname = `hostname`.strip
+      else
+        @hostname = @config["hostname"]
+      end
+      
+      message = {"api_key" => @config["api_key"], 
+                 "api_version" => "1.0",
+                 "agent_version" => Qnotifier::VERSION,
+                 "hostname" => @hostname,
+                 "stats" => stats,
+                 "alert_count" => alert_count,
+                 "reports" => reports}.to_json
+            
+      begin 
+        resource = RestClient::Resource.new(@config["api_endpoint"],
+                :timeout => 30, 
+                :headers => { :user_agent => "Qnotifier-#{Qnotifier::VERSION}" })
+        response = resource["/update_server"].post(message, :content_type => 'application/json')
+        
+        if response.code == 200
+          Qnotifier.log.debug "Server Response: HTTP #{response.code} #{response.body}"
+        else
+          Qnotifier.log.warn "Server Response: HTTP #{response.code} #{response.body}"
+        end
+        
+      rescue Exception => e
+        Qnotifier.log.error "Sending Reports/Stats: Can't connect to #{@config["api_endpoint"]} - #{e.message}"
+        if e.message == "HTTP status code 402"
+          # The server doesn't want to hear from us any more, disable pinging
+          Qnotifier::Storage.put("server_disabled_pings", Time.now)
+          Qnotifier.log.error "Server has asked us to disable pings"
+        end
+      end
+    end
+    
+    def register_server(temp_key)
+      return if temp_key.empty?
+      Qnotifier.log.info "Registering Server"
+            
+      message = {"temp_key" => temp_key, "hostname" => `hostname`.strip}.to_json
+            
+      begin 
+        resource = RestClient::Resource.new(@config["api_endpoint"],
+                :timeout => 30, 
+                :headers => { :user_agent => "Qnotifier-#{Qnotifier::VERSION}" })
+        response = resource["/register_server"].post(message, :content_type => 'application/json')
+        
+        if response.code == 200 and response.body
+          Qnotifier.log.debug "Registration Request Response: HTTP #{response.code} #{response.body}"
+          puts "OK, the server has been successfully registered."
+          puts "You now need to call this script from cron every 5 minutes, add to root's crontab (sudo crontab -e):"
+          puts "*/5 * * * * qnotifier"
+          return response.body
+        else
+          Qnotifier.log.warn "Registration Request Response: HTTP #{response.code} #{response.body}"
+        end
+        
+      rescue Exception => e
+        if e.message == "Bad Request"
+          puts "Can\'t find that key to register the server, please check it and try again. The key may have expired."
+          Qnotifier.log.error "Can\'t find that key to register the server, please check it and try again.  The key may have expired."
+        else
+          Qnotifier.log.error "Registering Server: Can't connect to #{@config["api_endpoint"]} - #{e.message}"
+        end
+      end
+      
+      return nil
+    end
+  end
+end

data/plugins/apache.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+module Qnotifier
+  class Apache < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+      }
+    end
+    
+    def main
+    end
+  end
+end

data/plugins/iostat.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+module Qnotifier
+  class Iostat < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+      }
+    end
+    
+    def main
+    end
+  end
+end

data/plugins/mysql.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+module Qnotifier
+  class Mysql < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+      }
+    end
+    
+    def main
+    end
+  end
+end

data/plugins/network.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+module Qnotifier
+  class Network < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+      }
+    end
+    
+    def main
+    end
+  end
+end

data/plugins/nginx.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+module Qnotifier
+  class Nginx < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+      }
+    end
+    
+    def main
+    end
+  end
+end

data/plugins/passenger.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+module Qnotifier
+  class Passenger < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+      }
+    end
+    
+    def main
+    end
+  end
+end

data/plugins/processes.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+module Qnotifier
+  class Processes < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+      }
+    end
+    
+    def main
+    end
+  end
+end

data/plugins/rails.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+require "elif"
+
+module Qnotifier
+  class Rails < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+        :rails_log_file => "/var/www/rails/log/production.log"
+      }
+      patch_elif
+    end
+    
+    def main
+      puts "here"
+      #log_file = read_backwards_to_timestamp(@options[:rails_log_file], last_summary)
+    end
+    
+    def patch_elif
+      if Elif::VERSION < "0.2.0"
+        Elif.send(:define_method, :pos) do
+          @current_pos +
+          @line_buffer.inject(0) { |bytes, line| bytes + line.size }
+        end
+      end
+    end
+    
+    def read_backwards_to_timestamp(path, timestamp)
+      start = nil
+      Elif.open(path) do |elif|
+        elif.each do |line|
+          if line =~ /\AProcessing .+ at (\d+-\d+-\d+ \d+:\d+:\d+)\)/
+            time_of_request = Time.parse($1)
+            if time_of_request < timestamp
+              break
+            else
+              start = elif.pos
+            end
+          end
+        end
+      end
+
+      file = open(path)
+      file.seek(start) if start
+      file
+    end
+  end
+end

data/plugins/ruby.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+module Qnotifier
+  class Ruby < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+      }
+    end
+    
+    def main
+      # Ruby Info
+      ruby_info = [RUBY_VERSION, RUBY_RELEASE_DATE, RUBY_PATCHLEVEL, RUBY_PLATFORM]
+      stat("Ruby", "ruby %s (%s patchlevel %s) [%s]" % ruby_info)
+      
+      # Gems
+      gem_list = `gem list`.split("\n")
+      gems = []
+      if gem_list
+        for line in gem_list
+          next if line.match(/^[\*\n]/)
+          gems << line.strip
+        end
+        stat("Gems", gems.join(", "))
+      end
+    end
+  end
+end

data/plugins/system.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+module Qnotifier
+  class System < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+        "enabled" => true,
+        "use_load" => "five_minute",
+        "normalize_load" => true,
+        "alert_cpu_threshold" => 0,
+        "alert_memory_threshold" => 0,
+        "alert_load_threshold" => 2.0,
+        "alert_disk_threshold" => 0,
+        "partitions" => ["/"]
+      }
+      count_cpus
+    end
+    
+    def main
+      
+      # Uptime, Users and Load Average
+      uptime = `uptime`.strip
+      if uptime
+        if uptime =~ /load average(s*): ([\d.]+)(,*) ([\d.]+)(,*) ([\d.]+)\Z/        
+          load_one_minute = $2.to_f
+          load_five_minute = $4.to_f
+          load_fifteen_minute = $6.to_f
+         
+          if @options["normalize_load"]
+            load_one_minute = load_one_minute / @cpu_count
+            load_five_minute = load_five_minute / @cpu_count
+            load_fifteen_minute = load_fifteen_minute / @cpu_count
+          end
+          
+          case @options["use_load"]
+          when "one_minute"
+            load_average = load_one_minute
+          when "five_minute"
+            load_average = load_one_minute
+          else
+            load_average = load_one_minute
+          end
+        
+          report("Load", load_average)
+	  stat("Load", load_average)
+        
+          if @options["alert_load_threshold"] != 0 and load_average >= @options["alert_load_threshold"]
+            alert("load", "Load is at #{load_average} #{"(normalized)" if @options[:normalize_load]}")
+          else
+            reset_alert("load", "Load is now #{load_average}")
+          end
+        
+        else
+          raise "Unable to parse load averages"
+        end
+      
+        stat("Uptime", uptime)      
+      end
+    
+      # CPU 
+      vmstat = `vmstat | tail -1`
+      if vmstat 
+        vmstat = vmstat.split
+        if vmstat.size == 16
+          
+          cpu = "User: #{vmstat[12].to_i}%, System: #{vmstat[13].to_i}%, Idle: #{vmstat[14].to_i}%, Wait: #{vmstat[15].to_i}%"
+          cpu_percent = (100 - vmstat[14].to_i)
+          
+          stat("CPU", cpu)
+          report("CPU %", cpu_percent)
+                    
+          if @options["alert_cpu_threshold"] != 0 and cpu_percent >= @options["alert_cpu_threshold"]
+            alert("cpu", "CPU is at #{cpu_percent}%")
+          else
+            reset_alert("cpu", "CPU is now #{cpu_percent}%")
+          end
+
+        else
+          raise "Can't parse vmstat"
+        end
+      else
+        raise "Can't run vmstat, is it installed/supported?"
+      end
+      
+      # Disk
+      df = `df -Phl`
+      if df
+        df = df.split("\n")
+        for partition in @options["partitions"]
+          for line in df
+            if line =~ /#{partition}$/
+              items = line.split
+
+              disk = "Used: #{items[-2]} (#{items[-4]}), #{items[-3]} free"
+              stat("Disk #{partition}", disk) if partition == "/"
+              report("Disk #{partition} %", items[-2].delete("%").to_i)
+              
+              if @options["alert_disk_threshold"] != 0 and items[-2].delete("%").to_i >= @options["alert_disk_threshold"]
+                alert("partition-#{partition}", "Partition #{partition} is at #{items[-2]}")
+              else
+                reset_alert("partition-#{partition}", "Partition #{partition} is now #{items[-2]}")
+              end
+            end
+          end
+        end
+      else
+        raise "Can't run df -Phl"
+      end
+      
+      
+      # Uname
+      stat("Uname", `uname -srm`.strip)
+      
+      # Memory
+      meminfo = {}
+      `cat /proc/meminfo`.each_line do |line|
+        _, key, value = *line.match(/^(\w+):\s+(\d+)\s/)
+        meminfo[key] = value.to_i
+      end
+
+      memory = {}
+      unless meminfo.empty?
+        memory["Free"] = meminfo['MemFree'] / 1024
+        memory["Total"] = meminfo['MemTotal'] / 1024
+        memory_percent = ((memory["Total"] - memory["Free"]) / memory["Total"] * 100).to_i
+        memory["Percent"] = memory_percent
+        
+        stat("Memory", "Free: #{memory["Free"]}M, Total: #{memory["Total"]}M")
+        report("Memory %", memory_percent)
+
+        if @options["alert_memory_threshold"] != 0 and memory_percent >= @options["alert_memory_threshold"]
+          alert("memory", "Memory is at #{memory_percent}%")
+        else
+          reset_alert("memory", "Memory is now #{memory_percent}%")
+        end
+      else
+        raise "Can't get memory information from /proc/meminfo (is it supported by this OS?)"
+      end
+      
+      
+    end
+    
+
+    def count_cpus
+      if get("cpu_count")      
+        @cpu_count = get("cpu_count") 
+      else
+        cpu_count = `cat /proc/cpuinfo | grep "model name" | wc -l`.to_i
+        if cpu_count != 0
+          @cpu_count = cpu_count
+        else
+          @cpu_count = 1
+        end
+        put("cpu_count", @cpu_count)
+      end
+    end
+  end
+end

data/plugins/urls.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+module Qnotifier
+  class Urls < Qnotifier::Plugin
+
+    def initialize
+      @defaults = {
+      }
+    end
+    
+    def main
+    end
+  end
+end

data/qnotifier.gemspec

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{qnotifier}
+  s.version = "0.6.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Gersham Meharg"]
+  s.date = %q{2010-03-17}
+  s.default_executable = %q{qnotifier}
+  s.description = %q{The server side agent for the QNotifier monitoring system.  This software will monitor local Linux system parameters and upload them to the Qnotifier servers where users can use iPhone/iPad applications to view those stats and recevie alerts.}
+  s.email = %q{gersham@qnotifier.com}
+  s.executables = ["qnotifier"]
+  s.extra_rdoc_files = ["bin/qnotifier", "lib/command.rb", "lib/plugin.rb", "lib/qnotifier.rb", "lib/storage.rb", "lib/web_service.rb"]
+  s.files = ["Manifest", "Rakefile", "bin/qnotifier", "config/qnotifier_config.yml", "gem-public_cert.pem", "lib/command.rb", "lib/plugin.rb", "lib/qnotifier.rb", "lib/storage.rb", "lib/web_service.rb", "plugins/apache.rb", "plugins/iostat.rb", "plugins/mysql.rb", "plugins/network.rb", "plugins/nginx.rb", "plugins/passenger.rb", "plugins/processes.rb", "plugins/rails.rb", "plugins/ruby.rb", "plugins/system.rb", "plugins/urls.rb", "qnotifier.gemspec"]
+  s.homepage = %q{http://qnotifier.com/qnotifier_gem}
+  s.post_install_message = %q{Qnotifier installed,  please register by running 'qnotifier -r CODE' in order to register this server.}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Qnotifier"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{qnotifier}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{The server side agent for the QNotifier monitoring system}
+  s.signing_key = "/Users/gersham/Sources/qanix-documents/qnotifier-gem-private_key.pem"
+  s.cert_chain  = ['gem-public_cert.pem']
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rest-client>, [">= 1.4.2"])
+      s.add_runtime_dependency(%q<json>, [">= 1.2.3"])
+      s.add_runtime_dependency(%q<elif>, [">= 0.1.0"])
+      s.add_development_dependency(%q<rest-client>, [">= 1.4.2"])
+      s.add_development_dependency(%q<json>, [">= 1.2.3"])
+      s.add_development_dependency(%q<elif>, [">= 0.1.0"])
+    else
+      s.add_dependency(%q<rest-client>, [">= 1.4.2"])
+      s.add_dependency(%q<json>, [">= 1.2.3"])
+      s.add_dependency(%q<elif>, [">= 0.1.0"])
+      s.add_dependency(%q<rest-client>, [">= 1.4.2"])
+      s.add_dependency(%q<json>, [">= 1.2.3"])
+      s.add_dependency(%q<elif>, [">= 0.1.0"])
+    end
+  else
+    s.add_dependency(%q<rest-client>, [">= 1.4.2"])
+    s.add_dependency(%q<json>, [">= 1.2.3"])
+    s.add_dependency(%q<elif>, [">= 0.1.0"])
+    s.add_dependency(%q<rest-client>, [">= 1.4.2"])
+    s.add_dependency(%q<json>, [">= 1.2.3"])
+    s.add_dependency(%q<elif>, [">= 0.1.0"])
+  end
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification 
+name: qnotifier
+version: !ruby/object:Gem::Version 
+  version: 0.6.2
+platform: ruby
+authors: 
+- Gersham Meharg
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDODCCAiCgAwIBAgIBADANBgkqhkiG9w0BAQUFADBCMRAwDgYDVQQDDAdnZXJz
+  aGFtMRkwFwYKCZImiZPyLGQBGRYJcW5vdGlmaWVyMRMwEQYKCZImiZPyLGQBGRYD
+  Y29tMB4XDTEwMDMxNzE4MjAwOFoXDTExMDMxNzE4MjAwOFowQjEQMA4GA1UEAwwH
+  Z2Vyc2hhbTEZMBcGCgmSJomT8ixkARkWCXFub3RpZmllcjETMBEGCgmSJomT8ixk
+  ARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMS8vIaSE0eA
+  DfL3OqRwmY+b3ueQ+cfm2nxU1J+TE7yFFGiv+bk4z4YMtHtbqsGxlmL4HZKW7Ur/
+  RrS7+d+fVTskoRC7t9g6mRoww/4+fTgmX25g7YLe4vuiSBkBeBMXBt5Vd3ombU9F
+  b0CrguX2a2ffYxnF/RlrXnhsU2VywZry+qz1NJglaCa+qb0S0W3BnvoB8T+MxNOM
+  7feKF/HvWRCM7DdHyqXqHFqMBIWJlCC7MFV4kQVW/a8b49VC5Dgmz6QVWcPqQ8cl
+  GK35UW+1WZXRB5Mhv5HBAQQqzLut46pxbUJ3qIpibtp1ltgyu81ZIRAwKIWx0YNv
+  lP5V85hTZ1ECAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUn3O2jt+12CmU
+  t1GEK8NZRNRbzqwwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQBb5gk8
+  OyfuloScbz/oHOopNmSc+o/s/5MvyrslPYDZA0WGR/63Q4Wl6l/tFFPwuAZH1KAI
+  MtLf7mVDdijHQf3Q6e+DicNRRQrl1w3s2m4PHyPiFUmXULzWHbMc3OK4LdM+1f5q
+  oZvsRrAAz6esBChxfdpuNCsP9Eu3j9MIWHy4KPTNuqOFyI+p3YVW2+SHeN4gBCyV
+  b7VZHIY+1kKjmMYXPeG9xlXaxLABhS1iN66tAyg66l6u6vuLt5Rdh1RUIY534Edq
+  ciUZJrPp/am/m0FtGWggbAohDKjiKRL0E6OCFQ7wSCTUPKoB9MbIJkKSGFo6ExWe
+  wu7A8rLN6CU0SfWf
+  -----END CERTIFICATE-----
+
+date: 2010-03-17 00:00:00 -07:00
+default_executable: qnotifier
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: elif
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.4.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: elif
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.0
+    version: 
+description: The server side agent for the QNotifier monitoring system.  This software will monitor local Linux system parameters and upload them to the Qnotifier servers where users can use iPhone/iPad applications to view those stats and recevie alerts.
+email: gersham@qnotifier.com
+executables: 
+- qnotifier
+extensions: []
+
+extra_rdoc_files: 
+- bin/qnotifier
+- lib/command.rb
+- lib/plugin.rb
+- lib/qnotifier.rb
+- lib/storage.rb
+- lib/web_service.rb
+files: 
+- Manifest
+- Rakefile
+- bin/qnotifier
+- config/qnotifier_config.yml
+- gem-public_cert.pem
+- lib/command.rb
+- lib/plugin.rb
+- lib/qnotifier.rb
+- lib/storage.rb
+- lib/web_service.rb
+- plugins/apache.rb
+- plugins/iostat.rb
+- plugins/mysql.rb
+- plugins/network.rb
+- plugins/nginx.rb
+- plugins/passenger.rb
+- plugins/processes.rb
+- plugins/rails.rb
+- plugins/ruby.rb
+- plugins/system.rb
+- plugins/urls.rb
+- qnotifier.gemspec
+has_rdoc: true
+homepage: http://qnotifier.com/qnotifier_gem
+licenses: []
+
+post_install_message: Qnotifier installed,  please register by running 'qnotifier -r CODE' in order to register this server.
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Qnotifier
+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: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: qnotifier
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: The server side agent for the QNotifier monitoring system
+test_files: []
+