srvmonitor 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+.yardoc

data/Gemfile

@@ -0,0 +1,5 @@
+source :rubygems
+
+gem 'mail', '2.3.0'
+gem 'net-ssh', '2.2.1'
+

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Vinicius Baggio Fuentes http://www.vinibaggio.net
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,7 @@
+# Srvconfig
+Based on outpost (https://github.com/vinibaggio/outpost)
+
+## License
+
+MIT License.
+

data/Rakefile

@@ -0,0 +1,27 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+
+require 'rake/testtask'
+
+require "srvmonitor/version"
+
+desc 'Default: run tests'
+task :default => :test
+
+desc 'Run tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Build a gem from gemspec'
+task :build do
+  system "gem build srvmonitor.gemspec"
+end
+
+desc 'Release new gem version'
+task :release => :build do
+  system "gem push srvmonitor-#{SrvMonitor::VERSION}.gem"
+end
+

data/lib/srvmonitor/application.rb

@@ -0,0 +1,83 @@
+module SrvMonitor
+  class Application
+    attr_reader :scout_klass, :scout_config, :scouts
+    attr_reader :servers, :reports, :name, :status
+
+    SERVER_OPTIONS = [:host, :method, :user, :password]
+
+    def self.create(&block)
+      self.new.tap do |application|
+        application.instance_eval(&block)
+      end
+    end
+
+    def initialize
+      @scouts = []
+      @reports = {}
+    end
+
+    def name(name)
+      @name = name
+    end
+
+    def scout(klass, args={})
+      @scout_klass = klass
+      @scout_config = args
+    end
+
+    def server(server, options={})
+      server_config = options.select{ |key, _| key if SERVER_OPTIONS.include?(key) }
+
+      config = options.delete_if{ |key, _| server_config.include?(key) }
+      config[:server] = server.clone(server_config)
+
+      @scouts << @scout_klass.new(@scout_config.merge config )
+    end
+
+    def servers(*args)
+      servers = args.find_all{ |r| r.is_a?(SrvMonitor::Server) }
+      options = args.find{ |r| r.is_a?(Hash) }
+      servers.each{ |r| server(r, options) }
+    end
+
+    # Reads reporting as:
+    #   report :up, :response_code => 200
+    #
+    # gets stored as:
+    #    {:response_code => 200} = up
+    def report(status, params)
+      @reports[params] = status
+    end
+
+    def run
+      puts "\n### Runing #{label}"
+      statuses = []
+      @scouts.each do |scout|
+        scout.run(@reports)
+        statuses << scout.status
+      end
+      @status = SrvMonitor::Report.summarize(statuses)
+    end
+
+    # Returns true if the last status is :up
+    def up?
+      @status == :up
+    end
+
+    # Returns true if the last status is :warning
+    def warning?
+      @status == :warning
+    end
+
+    # Returns true if the last status is :down
+    def down?
+      @status == :down
+    end
+
+    def label
+      @name || @scout_klass.to_s
+    end
+
+  end
+end
+

data/lib/srvmonitor/expectations/load_average.rb

@@ -0,0 +1,28 @@
+module SrvMonitor
+  module Expectations
+    # Module containing load_average matching expectations.
+    #
+    # It respond to the following rules:
+    # * less_than => If the load_average percent is less than the associated number
+    # * more_than => If the load_average percent is below than the associated number
+    module LoadAverage
+      LOAD_AVERAGE_MAPPING = {
+        :less_than => "<",
+        :more_than => ">",
+      }.freeze
+
+      # Installs the response time expectation
+      def self.extended(base)
+        base.expect :load_average, base.method(:evaluate_load_average)
+      end
+
+      # Method that will be used as an expectation to evaluate load average
+      def evaluate_load_average(scout, rules)
+        rules.all? do |rule, comparison|
+          scout.load_average.send(LOAD_AVERAGE_MAPPING[rule], comparison)
+        end
+      end
+    end
+  end
+end
+

data/lib/srvmonitor/expectations/response_body.rb

@@ -0,0 +1,37 @@
+module SrvMonitor
+  module Expectations
+    # Module containing response_body matching expectations. Extend your Scout
+    # with ResponseBody and it will gain response_body evaluation powers!
+    #
+    # It respond to the following rules:
+    # * match => If the response body matches the associated regular expression
+    # * not_match => If the response body does not match the associated regular
+    #   expression
+    # * equals => If the response body matches exactly the associated string
+    # * differs => If the response body differs in any way the associated
+    #   string.
+    module ResponseBody
+      # Installs the response body expectation
+      def self.extended(base)
+        base.expect :response_body, base.method(:evaluate_response_body)
+      end
+
+      # Method that will be used as an expectation to evaluate response body
+      def evaluate_response_body(scout, rules)
+        rules.all? do |rule, comparison|
+          case rule
+          when :match
+            scout.response_body =~ comparison
+          when :not_match
+            scout.response_body !~ comparison
+          when :equals
+            scout.response_body == comparison
+          when :differs
+            scout.response_body != comparison
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/srvmonitor/expectations/response_code.rb

@@ -0,0 +1,23 @@
+module SrvMonitor
+  module Expectations
+    # Module containing response_code logic. It is the simplest of all,
+    # it is a simple direct equality check. Extend your Scout to win instant
+    # response_code checking.
+    module ResponseCode
+      # Installs the response code expectation
+      def self.extended(base)
+        base.expect :response_code, base.method(:evaluate_response_code)
+      end
+
+      # Method that will be used as an expectation to evaluate response code
+      def evaluate_response_code(scout, response_code)
+        if response_code.is_a?(Array)
+          response_code.include?(scout.response_code)
+        else
+          scout.response_code == response_code.to_i
+        end
+      end
+    end
+  end
+end
+

data/lib/srvmonitor/expectations/response_time.rb

@@ -0,0 +1,30 @@
+module SrvMonitor
+  module Expectations
+    # Module containing response_time matching expectations. Extend your Scout
+    # with ResponseTime and it will evaluate timely expressions, all in
+    # milisseconds.
+    #
+    # It respond to the following rules:
+    # * less_than => If the response time is less than the associated number
+    # * more_than => If the response time is below than the associated number
+    module ResponseTime
+      RESPONSE_TIME_MAPPING = {
+        :less_than => "<",
+        :more_than => ">",
+      }.freeze
+
+      # Installs the response time expectation
+      def self.extended(base)
+        base.expect :response_time, base.method(:evaluate_response_time)
+      end
+
+      # Method that will be used as an expectation to evaluate response time
+      def evaluate_response_time(scout, rules)
+        rules.all? do |rule, comparison|
+          scout.response_time.send(RESPONSE_TIME_MAPPING[rule], comparison)
+        end
+      end
+    end
+  end
+end
+

data/lib/srvmonitor/expectations.rb

@@ -0,0 +1,5 @@
+require 'srvmonitor/expectations/load_average'
+require 'srvmonitor/expectations/response_code'
+require 'srvmonitor/expectations/response_body'
+require 'srvmonitor/expectations/response_time'
+

data/lib/srvmonitor/monitor.rb

@@ -0,0 +1,78 @@
+module SrvMonitor
+  class Monitor
+    attr_reader :applications, :wait, :forever, :alert, :notifier
+
+    def self.create(&block)
+      self.new.tap do |monitor|
+        monitor.instance_eval(&block)
+      end
+    end
+
+    def initialize
+      @applications = []
+      @wait = 5
+      @forever = true
+      @alert = {}
+    end
+
+    def applications(*args)
+      apps = args.find_all{ |r| r.is_a?(SrvMonitor::Application) }
+      options = args.find{ |r| r.is_a?(Hash) }
+      apps.each { |r| @applications << r }
+      @applications
+    end
+
+    def wait(seconds)
+      @wait = seconds
+    end
+
+    def forever(bol)
+      @forever = bol
+    end
+
+    def alert(args={})
+      @alert[:if] = args[:if] || :down
+      @alert[:attempts] = args[:attempts] || 1
+      @alert[:count] = 0
+    end
+
+    def notifier(notifier_klass, args={})
+      @notifier = notifier_klass.new(args)
+    end
+
+    def status
+      SrvMonitor::Report.summarize @applications.map(&:status)
+    end
+
+    def run
+      loop do
+        @applications.each(&:run)
+
+        unless @alert.empty?
+          @alert[:count] = 0 unless status == @alert[:if]
+
+          if status == @alert[:if]
+            if @alert[:count] < @alert[:attempts]
+              @alert[:count] += 1
+              sleep @wait
+              redo
+            else
+              notify!
+              @alert[:count] = 0
+            end
+          end
+        end
+
+        break unless @forever
+        sleep @wait
+      end
+    end
+
+    def notify!
+      return unless @notifier
+      @notifier.send(self)
+    end
+
+  end
+end
+

data/lib/srvmonitor/notifiers/mailer.rb

@@ -0,0 +1,102 @@
+begin
+  require 'mail'
+rescue LoadError => e
+  puts "Please install mail gem: gem install mail"
+  raise
+end
+
+module SrvMonitor
+  module Notifiers
+    # The Email notifier issues Outpost notifications to through email.  It
+    # uses the 'mail' gem send the emails. You can see mail's documentation
+    # in order to change how emails will be delivered:
+    # https://github.com/mikel/mail
+    #
+    # This requires the 'mail' gem to be installed.
+    class Mailer
+
+      # @param [Hash] Options to create an email notification.
+      # @option options [String] :delivery_method The smtp / sendmail
+      # @option options [String] :address The "smtp address"
+      # @option options [String] :port The smtp port
+      # @option options [String] :authentication The smtp authentication type
+      # @option options [String] :username The smtp username
+      # @option options [String] :password The smtp password
+      # @option options [Boolean] :enable_starttls_auto Enable smtp start tls
+
+      # @option options [String] :from The "from" email field
+      # @option options [String] :to Where e-mails will be delivered
+      # @option options [String] :subject The email's subject
+      # @option options [Array] :status The status to be reported
+      def initialize(options={})
+        @delivery_method = options[:delivery_method] || :sendmail
+        @address = options[:address]
+        @port = options[:port]
+        @username = options[:username]
+        @password = options[:password]
+        @authentication = options[:authentication] || :plain
+        @enable_starttls_auto = options[:enable_starttls_auto] || false
+        @from = options[:from] || options[:username]
+        @to = options[:to]
+        @subject = options[:subject] || 'SrvMonitor notification'
+        @status = [ options[:status] ].flatten if options[:status]
+
+        raise ArgumentError, 'You need to set :from and :to to send emails.' if @from.nil? || @to.nil?
+
+        if @delivery_method == :smtp && (@address.nil? || @port.nil? || @username.nil? || @password.nil?)
+          raise ArgumentError, 'You need to set :address, :port, :username, :password, :from and :to to send emails by smtp.'
+        end
+      end
+
+      # Issues a notification through email. This is a callback, called by
+      # an Outpost instance.
+      # @param [Outpost::Application, #read] outpost an instance of an outpost, containing
+      #   latest status, messages and reports that can be queried to build
+      #   a notification message.
+      def send(monitor)
+        smtp_connect! if @delivery_method == :smtp
+
+        mail         = Mail.new
+        mail.from    = @from
+        mail.to      = @to
+        mail.subject = @subject
+        mail.body    = build_message(monitor)
+
+        #mail.delivery_method @delivery_method
+
+        mail.deliver
+      end
+
+      private
+      def smtp_connect!
+        smtp_conn = Net::SMTP.new(@address, @port)
+        smtp_conn.enable_starttls if @enable_starttls_auto
+        smtp_conn.start(@address, @username, @password, @authentication)
+
+        Mail.defaults do
+          delivery_method :smtp_connection, { :connection => smtp_conn }
+        end
+      end
+
+      def build_message(monitor)
+        status = monitor.status.to_s
+
+        message = "System is #{status.upcase}!\n\n"
+
+        monitor.applications.each do |application|
+          application_message = ""
+
+          for scout in application.scouts
+            next if @status && !@status.include?(scout.status)
+            application_message += "\n#{scout.output}"
+          end
+
+          message += "### #{application.label} #{application_message}\n\n" if application_message.size > 0
+        end
+
+        message
+      end
+    end
+  end
+end
+

data/lib/srvmonitor/notifiers.rb

@@ -0,0 +1,2 @@
+require 'srvmonitor/notifiers/mailer'
+

data/lib/srvmonitor/report.rb

@@ -0,0 +1,24 @@
+module SrvMonitor
+  # Contain the status report of an Outpost execution. Holds the name,
+  # description and status of the reported item.
+  class Report
+    # Summarizes the list of statuses in a single status only.
+    # The logic is rather simple - it will return the lowest status
+    # present in the list.
+    #
+    # Examples:
+    #
+    # if passed [:up, :up, :up], will result on :up
+    #
+    # if passed [:up, :down, :up], will result on :down
+    #
+    # @params [Array] status_list a list of statuses to be analyzed
+    # @return [Symbol] the final status to be considered.
+    def self.summarize(status_list)
+      return :down if status_list.empty? || status_list.include?(:down)
+      return :warning if status_list.include?(:warning)
+      return :up
+    end
+  end
+end
+

data/lib/srvmonitor/scout.rb

@@ -0,0 +1,82 @@
+module SrvMonitor
+  class Scout
+
+    class << self
+      def expectations
+        @expectations ? @expectations.dup : {}
+      end
+
+      def expect(expectation, callable=nil, &callable_block)
+        callable ||= callable_block
+
+        if callable.respond_to?(:call)
+          @expectations ||= {}
+          @expectations[expectation] = callable
+        else
+          raise ArgumentError, 'Object must respond to method #call to be a valid expectation.'
+        end
+      end
+    end
+
+    attr_reader :server, :status
+
+    # Executes the Scout and go through all the registered expectations to find
+    # out all expectations that match and return the associated status.
+    #
+    # @return [Symbol] the current status of the Scout (:up, :down, :warning)
+    # @raise [NotImplementedError] raised when a configured expectation was not
+    #   registered in the Scout.
+    def run(reports={})
+      statuses = []
+      execute
+
+      unless reports.empty?
+        reports.each do |response_pair, status|
+          response_pair.each do |expectation, value|
+            if self.class.expectations[expectation].nil?
+              raise NotImplementedError, "expectation '#{expectation}' wasn't implemented by #{self.class.name}"
+            end
+
+            if self.class.expectations[expectation].call(self, value)
+              statuses << status
+            end
+          end
+        end
+      end
+
+      @status = SrvMonitor::Report.summarize(statuses)
+      puts output
+    end
+
+    # Called when the Scout must take action and gather all the data needed to be analyzed.
+    #
+    # @raise [NotImplementedError] raised when method is not overriden.
+    def options
+      raise NotImplementedError, 'You must implement the options method for Scout to work correctly.'
+    end
+
+    # Called when the Scout must take action and gather all the data needed to be analyzed.
+    #
+    # @raise [NotImplementedError] raised when method is not overriden.
+    def execute
+      raise NotImplementedError, 'You must implement the execute method for Scout to work correctly.'
+    end
+
+    # Called when the Scout must take action and gather all the data needed to be analyzed.
+    #
+    # @raise [NotImplementedError] raised when method is not overriden.
+    def output
+      raise NotImplementedError, 'You must implement the output method for Scout to work correctly.'
+    end
+
+    def remote?
+      @server && @server.remote?
+    end
+
+    def local?
+      @server.nil? || @server.local?
+    end
+
+  end
+end
+

data/lib/srvmonitor/scouts/load_average.rb

@@ -0,0 +1,48 @@
+require 'srvmonitor/expectations'
+
+module SrvMonitor
+  module Scouts
+    class LoadAverage < SrvMonitor::Scout
+      extend SrvMonitor::Expectations::LoadAverage
+
+      attr_reader :load_average
+      #report_data :load_average
+
+      # Configure the scout with given options.
+      # @param [Hash] Options to setup the scout
+      def initialize(options)
+        @server = options[:server]
+      end
+
+      def execute
+        case
+        when remote? then remote_exec
+        when local?  then local_exec
+        end
+      rescue
+        @load_average = nil
+      end
+
+      def output
+        st = "#{@status}\tload: #{@load_average}"
+        st = "[#{@server.name}]\t#{st}"
+        st
+      end
+
+      private
+        def local_exec
+          loadavg = File.open('/proc/loadavg').read
+          @load_average = loadavg.split(' ').first.to_f
+        end
+
+        def remote_exec
+          server.exec do |ssh|
+            loadavg = ssh.exec!('cat /proc/loadavg')
+            @load_average = loadavg.split(' ').first.to_f
+          end
+        end
+
+    end
+  end
+end
+

data/lib/srvmonitor/scouts/timed_http.rb

@@ -0,0 +1,80 @@
+require 'srvmonitor/expectations'
+require 'net/http'
+require 'timeout'
+
+module SrvMonitor
+  module Scouts
+    # Uses ruby's own Net:HTTP to send HTTP requests and evaluate response body, response time and response code.
+    class TimedHttp < SrvMonitor::Scout
+      extend SrvMonitor::Expectations::ResponseCode
+      extend SrvMonitor::Expectations::ResponseBody
+      extend SrvMonitor::Expectations::ResponseTime
+
+      attr_reader :response_code, :response_body, :response_time
+      #report_data :response_code, :response_body, :response_time
+
+      # Configure the scout with given options.
+      # @param [Hash] Options to setup the scout
+      # @option options [Number] :port The port that will be used to.
+      # @option options [String] :path The path that will be fetched from the host.
+      # @option options [String] :http_class The class that will be used to fetch the page, defaults to Net::HTTP
+      # @option options [Number] :timout
+      def initialize(options)
+        @port       = options[:port]       || 80
+        @path       = options[:path]       || '/'
+        @http_class = options[:http_class] || Net::HTTP
+        @timeout    = options[:timeout]    || 15
+        @server     = options[:server]
+        @host       = @server ? @server.host : options[:host] || '127.0.0.1'
+      end
+
+      def execute
+        previous_time = Time.now
+        Timeout::timeout(@timeout) do
+          case
+          when remote? then remote_exec
+          when local?  then local_exec
+          end
+        end
+      rescue Timeout::Error
+        @response_time = (Time.now - previous_time).round
+        @response_code = @response_body = nil
+      rescue SocketError, Errno::ECONNREFUSED
+        @response_code = @response_body = @response_time = nil
+      end
+
+      def output
+        st = "#{@status}\tresponse code: #{@response_code}  response time: #{@response_time.round}ms"
+        st = "[#{@server.name}]\t#{st}"
+        st
+      end
+
+      private
+        def local_exec
+          previous_time = Time.now
+          response = @http_class.get_response(@host, @path, @port)
+          @response_time = (Time.now - previous_time) * 1000 # Miliseconds
+          @response_code = response.code.to_i
+          @response_body = response.body
+        end
+
+        # Runs the scout, connecting to the host and getting the response code, body and time.
+        def remote_exec
+          server.exec do |ssh|
+            response = ssh.exec!("curl --write-out %{http_code}:%{time_total} --silent --output /dev/null #{ url }")
+            @response_code = response.split(':').first.to_i
+            @response_time = response.split(':').last.to_f * 1000
+            @response_body = ssh.exec!("curl #{ url }")
+          end
+        end
+
+        def url
+          url = @host
+          url+= ":#{@port}" if @port && @port!=80
+          url+= "/#{@path}" if @path
+          "http://#{url.gsub('//', '/')}"
+        end
+    end
+  end
+end
+

data/lib/srvmonitor/scouts.rb

@@ -0,0 +1,3 @@
+require 'srvmonitor/scouts/load_average'
+require 'srvmonitor/scouts/timed_http'
+

data/lib/srvmonitor/server.rb

@@ -0,0 +1,40 @@
+begin
+  require 'net/ssh'
+rescue LoadError => e
+  puts "Please install ssh gem: gem install net-ssh if you want remote access"
+end
+
+module SrvMonitor
+  class Server
+    attr_reader :name, :description, :host, :method, :user, :password
+
+    def initialize(options)
+      @name = options[:name]
+      @description = options[:description]
+      @host = options[:host] || '127.0.0.1'
+      @method = options[:method] || :local
+      @user = options[:user]
+      @password = options[:password]
+    end
+
+    def exec(&block)
+      if remote?
+        Net::SSH.start(@host, @user) { |ssh| block.call(ssh) }
+      end
+    end
+
+    def clone(args={})
+      config = { :name => @name, :description => @description, :host => @host, :method => @method, :user => @user }
+      Server.new config.merge(args)
+    end
+
+    def remote?
+      @method == :remote
+    end
+
+    def local?
+      @method == :local
+    end
+  end
+end
+

data/lib/srvmonitor/version.rb

@@ -0,0 +1,7 @@
+module SrvMonitor
+  PATCH = 1
+  MINOR = 0
+  MAJOR = 0
+  VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}".freeze
+end
+

data/lib/srvmonitor.rb

@@ -0,0 +1,11 @@
+# SrvMonitor definition
+require 'srvmonitor/server'
+require 'srvmonitor/report'
+require 'srvmonitor/application'
+require 'srvmonitor/monitor'
+# require 'srvmonitor/report'
+
+# Scouts
+require 'srvmonitor/scout'
+require 'srvmonitor/notifiers'
+

data/srvmonitor.gemspec

@@ -0,0 +1,20 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "srvmonitor/version"
+
+Gem::Specification.new do |s|
+  s.name        = "srvmonitor"
+  s.version     = SrvMonitor::VERSION.dup
+  s.description = "Server monitor."
+  s.summary     = "Server monitor."
+  s.author      = "Click Jogos"
+  s.email       = "clickjogos@clickjogos.com.br"
+  s.homepage    = "http://www.github.com/clickjogos/srvmonitor"
+
+  s.rubyforge_project = "srvmonitor"
+
+  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"]
+end
+

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: srvmonitor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Click Jogos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-12 00:00:00.000000000Z
+dependencies: []
+description: Server monitor.
+email: clickjogos@clickjogos.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- lib/srvmonitor.rb
+- lib/srvmonitor/application.rb
+- lib/srvmonitor/expectations.rb
+- lib/srvmonitor/expectations/load_average.rb
+- lib/srvmonitor/expectations/response_body.rb
+- lib/srvmonitor/expectations/response_code.rb
+- lib/srvmonitor/expectations/response_time.rb
+- lib/srvmonitor/monitor.rb
+- lib/srvmonitor/notifiers.rb
+- lib/srvmonitor/notifiers/mailer.rb
+- lib/srvmonitor/report.rb
+- lib/srvmonitor/scout.rb
+- lib/srvmonitor/scouts.rb
+- lib/srvmonitor/scouts/load_average.rb
+- lib/srvmonitor/scouts/timed_http.rb
+- lib/srvmonitor/server.rb
+- lib/srvmonitor/version.rb
+- srvmonitor.gemspec
+homepage: http://www.github.com/clickjogos/srvmonitor
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: srvmonitor
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Server monitor.
+test_files: []