webstats 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Brenton Fletcher (http://i.bloople.net i@bloople.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.textile

@@ -0,0 +1,81 @@
+h1. Webstats
+
+Webstats is a server and clients that monitors your servers performance (CPU usage, memory usage, disk usage, disk activity, url load time) and allows you to get notifications on your computer when the server is having problems, as well as showing (http://kimag.es/share/91090734.png) the current performance stats for the server on a web page.
+
+Webstats has 2 components: the _server_ and one or more _clients_.
+
+h2. Server
+
+The server runs on the computer whose performance you want to monitor; the server application's job is to (1) monitor the computer's performance and (2) report these performance statistics through a webserver that the server application runs.
+
+See Installation below for install instructions.
+
+The server application executes in the background and starts a tiny webserver on port 9970. You can view the performance stats for your server by going to http://<server's hostname>:9970/, for example if my server was under the domain name bloople.net, I would go to http://bloople.net:9970/. The statistics on this page automatically update every 5 seconds. You may need to open port 9970 if you have a firewall on your server. Note that the various clients get their data via the webserver the server application runs, just like the built-in stats page.
+
+The statistic provided by the server application are:
+
+* CPU usage and load average
+* Memory (RAM) usage, with free, free - buffers, and total counts
+* Disk usage by mount point
+* Disk activity for reads and writes
+* URL monitoring, to load URL's you specify to ensure they work
+
+The server application will warn you of any of these statistics indicate a problem on the server - for example if you've have < 5MB free RAM for the last 12 seconds, that indicates a potential problem on your server that needs looking at. If you're looking at the performance statistics web page, the warnings will be presented by higlighting the perf stat that's causing the warning; when you're using a client application, it will present warnings to you as it sees fit.
+
+You can configure at what thresholds the warnings get generated, as well as the URL's to monitor, by editing ~/.webstats. This file is generated the first time you run webstats, so it's pre-filled with sensible defaults; but you can change them as you see fit.
+
+You can prevent public access to your webstats by invoking the server application with a single argument (e.g. <code>ruby webstats.rb <password to use></code>). Then, when you visit the webstats, you'll be prompted for a username and password; the username is always 'webstats', and the password is the password specified just above.
+
+The server application requires Linux kernel 2.6+, will not work in *BSD or OS X; the server application requires only Ruby; it does not rely on rubygems or any external libraries that aren't included with Ruby; the server application uses very little RAM, approximately 10MB.
+
+All the client applications depend on the server application being run to work.
+
+h2. Clients
+
+If all you want to do is be able to view the performance statistics for your server in a web browser, then you don't need to use any of these clients; going to http://&lt;server's hostname&gt;:9970/ will do just fine. But if you want to have Growl or email notification when something goes wrong, without having to look at a web page all the time, then you'll want one of the client applications that come with Webstats.
+
+There are currently two client applications available:
+
+* An email notifier; documentation is available in clients/email_notifier/README.textile
+* A Growl notifier; documentation is available in clients/growl_notifier/README.textile
+
+The notifiers that ship with Webstats can be started in 2 ways; if you have installed webstats via rubygems, run:
+
+<pre><code>~$ webstats_<notifier_name></code></pre>
+
+For example, to run the email notifier, you can run webstats_email_notifier. If you installed webstats outside of rubygems, first change directory into the directory containing webstats, then run:
+<pre><code>~/webstats$ ruby clients/<notifier_name>/<notifier_name>.rb</code></pre>
+
+Many notifiers can also be run on the server, in the same ruby process as teh webstats server itself. To do this, change any settings as required by the documentation for the notifier, then add the notifier name (e.g. email_notifier) to the list of clients under webstats > clients in the ~/.webstats file
+
+h2. Installation
+
+You can now install webstats using rubygems; this saves you a bit of hassle. To install webstats on the server via rubygems, ensure github gems are in your gems sources; then run:
+<pre><code>~$ sudo gem install bloopletech-webstats</code></pre>
+
+To run the server application, run:
+<pre><code>~$ webstats</code></pre>
+
+The server application will start in the background.
+
+If you don't want to use rubygems, then follow the below instructions:
+To install the server app, ssh into the computer you want to monitor. then run:
+<pre><code>~$ git clone git://github.com/bloopletech/webstats.git
+~$ cd webstats
+~/webstats$ cd server/data_providers
+~/webstats/server/data_providers$ ruby extconf.rb
+~/webstats/server/data_providers$ make
+</code></pre>
+
+To run the server app, ssh into the computer you want to monitor. then run:
+<pre><code>~$ cd webstats
+~/webstats$ ruby server/webstats.rb
+</code></pre>
+
+h2. Todo
+
+* More client applications.
+* Extend server to work on *BSD (including OS X).
+* Make webstats server optionally install itself to run at boot.
+* Make client applications optionally install themselves at boot, where suitable.
+* (Maybe) Move all server code into it's own module and make code work without running the web server, so you can use it to just grab stats in your own code.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+      s.name = %q{webstats}
+      s.version = "0.1.0"
+
+      s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+      s.authors = ["Brenton Fletcher"]
+      s.date = Date.today.strftime("%Y-%m-%d")
+      s.description = s.summary = %q{Monitor server CPU/Memory/Disk Usage/URL Loading, so that you can view those statistics on a web page, as well as providing an interface to client prorams to read those statistics.}
+      s.email = %q{i@bloople.net}
+      s.files = Dir['**/*'].reject { |fn| fn =~ /(\.o|\.so|\.bundle|Makefile|\.gem)$/ }
+      s.executables = ['webstats', 'webstats_growl_notifier', 'webstats_email_notifier']
+      s.extensions = ["server/data_providers/extconf.rb"]
+      s.has_rdoc = false
+      s.homepage = %q{http://github.com/bloopletech/webstats}
+      s.require_paths = [""]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 10
+:patch: 5

data/bin/webstats

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../server/webstats'

data/bin/webstats_email_notifier

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../clients/email_notifier/email_notifier'

data/bin/webstats_growl_notifier

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/../clients/growl_notifier/growl_notifier'

data/clients/email_notifier/README.textile

@@ -0,0 +1,13 @@
+h1. Email notifier for Webstats
+
+The email notifier montiors one or more servers and emails you whenever the server is in danger or could be in danger soon - for example, running out of hard drive space.
+
+h2. Usage
+
+Run the notifier by running webstats_email_notifier or ruby <webstats_install_dir>/clients/email_notifier/email_notifier.rb on the terminal.
+
+It'll create a template of the settings you'll need to change in ~/.webstats_client - you'll need to set the recipient address for the emails, you may need to change the mail server settings - you can supply these settings: address, port, domain, username, password, authentication (one of :plain, :login, or :cram_md5).
+
+You'll also need to add some URL's for the email notifier to monitor - these are the URL's who statistics will be monitored. You will be notified when there is a warning or danger situation for a URL, as well as if one of the URL's can not be loaded. The URL's should the the hostnames of the servers you want to monitor, along with the correct port number (e.g. http://bloople.net:9970/).
+
+Once that's done, run the notifier again and it will begin monitoring.

data/clients/email_notifier/email_notifier.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/../simple_notifier'
+daemonize!
+
+class EmailNotifier < SimpleNotifier
+  def initialize(settings = {}, read_config = true)
+    @name = 'email_notifier'
+    @no_settings_message = "Please edit ~/.webstats_clients and add some URLs to monitor and an email address to notfiy on"
+    
+    super({ 'recipient' => '', 'mail_server' => { 'address' => 'localhost', 'domain' => 'localhost', 'port' => 25 } }.merge(settings), read_config)
+  end
+
+  private
+  def send_mail(subject, message)
+    sm = @settings[:mail_server]
+
+    msg = <<END_OF_MESSAGE
+From: Webstats Email Notifier <#{@settings[:recipient]}>
+To: #{@settings[:recipient]} <#{@settings[:recipient]}>
+Subject: #{subject}
+Date: #{Time.now.rfc2822}
+Message-Id: <#{Time.now.to_i}.#{rand(10000000)}@#{sm[:domain]}>
+
+#{message}
+END_OF_MESSAGE
+
+    Net::SMTP.start(sm[:address], sm[:port], sm[:domain], sm[:username], sm[:password], sm[:authentication]) { |smtp| smtp.send_message msg, @settings[:recipient], @settings[:recipient] }
+  end
+
+  def failed_url(url, password, exception)
+    send_mail("Webstats Notification - Cannot load Webstats data", "Could not load #{url}#{!password.nil? ? " with password #{password}" : ""}, error was #{exception.message}. Will try again in 60 seconds.")
+    sleep(60)
+    true
+  end
+
+  def notify
+    messages = []
+    has_warnings = has_dangers = false
+
+    @settings[:urls].each do |url|
+      if !url[:bad].empty? and (url[:changed] or url[:time_past])
+        has_warnings = !url[:warnings].empty?
+        has_dangers = !url[:dangers].empty?
+
+        title = []
+        title << "Danger" if has_dangers
+        title << "Warnings" if has_warnings
+        title = title.join(" & ")
+
+        warnings_text = !url[:warnings].empty? ? "Warnings for #{url[:bad].select { |(k, v)| v['status'] == 'warning' }.map { |(k, v)| url[:meta_info][k]['in_sentence'] }.join(", ")}." : nil
+        danger_text = !url[:dangers].empty? ? "Dangerous situation for #{url[:bad].select { |(k, v)| v['status'] == 'danger' }.map { |(k, v)| url[:meta_info][k]['in_sentence'] }.join(", ")}." : nil
+
+        host = URI.parse(url[:url]).host
+        messages << "#{title} for #{host}\n#{"-" * (title.length + host.length + 5)}\n\n#{[danger_text, warnings_text].compact.join("\n")}\n\nCheck statistics online at #{url[:url]}"
+      end
+    end
+
+    title = []
+    title << "Danger" if has_dangers
+    title << "Warnings" if has_warnings
+
+    send_mail("Webstats Notification - #{title.join(" & ")}", messages.join("\n\n\n")) unless messages.empty?
+  end
+end
+
+s = EmailNotifier.new()
+s.start

data/clients/growl_notifier/Growl.rb

@@ -0,0 +1,125 @@
+### Copyright
+#
+# Copyright 2004 Thomas Kollbach <dev@bitfever.de>
+# 
+# Released under the BSD license.
+#
+### Description
+#
+# A ruby class that enables posting notifications to the Growl daemon.
+# See <http://growl.info> for more information.
+# 
+# Requires RubyCocoa (http://www.fobj.com/rubycocoa/) and Ruby 1.8
+# (http://ruby-lang.org).
+#
+### Versions
+# 
+# v0.1- 25.11.2004 - Initial version, this is less more then a ruby translation of 
+#                    the python bindings
+#
+# TODO: transform this into a ruby-module, so it is usable as a mixin
+#       for ruby-scripts
+#
+### Usage
+#
+# Here is a short example how to use this in a script
+#
+#    n = GrowlNotifier.new('bla',['Foo'],nil,OSX::NSWorkspace.sharedWorkspace().iconForFileType_('unknown'))
+#    n.register()
+#
+#    n.notify('Foo', 'Test Notification', 'Blah blah blah')   
+#
+###
+
+require 'osx/cocoa'
+
+$priority = {"Very Low" => -2,
+             "Moderate" => -1,
+             "Normal"   =>  0,
+             "High"     =>  1,
+             "Emergency"=>  2
+             }
+             
+
+class GrowlNotifier
+#    A class that abstracts the process of registering and posting
+#    notifications to the Growl daemon.
+#
+#    `appName': The name of the application
+#    `notifications': an array of notifications - default is an empty array
+#
+#    `defaultNotifications': optional - defaults to the value of
+#    `notifications'  
+#    `appIcon' is also optional but defaults to a senseless icon so 
+#    so you are higly encouraged to pass it along.
+#
+
+    def initialize(appName='GrowlNotifier', notifications=[], defaultNotifications=nil, appIcon=nil)
+        @appName = appName
+        @notifications = notifications
+        @defaultNotifications = defaultNotifications
+        @appIcon = appIcon       
+    end #initialize
+    
+    def register
+        if @appIcon == nil  then
+            @appIcon = OSX::NSWorkspace.sharedWorkspace().iconForFileType_("txt") 
+        end
+        if @defaultNotifications == nil then
+            @defaultNotifications = @notifications
+        end
+        
+        regData = {
+            'ApplicationName'=>@appName,
+            'AllNotifications'=> OSX::NSArray.arrayWithArray(@notifications),
+            'DefaultNotifications'=> OSX::NSArray.arrayWithArray(@defaultNotifications),
+            'ApplicationIcon'=> @appIcon.TIFFRepresentation
+                  }
+                  
+        dict = OSX::NSDictionary.dictionaryWithDictionary(regData)
+        notifyCenter = OSX::NSDistributedNotificationCenter.defaultCenter
+        
+        notifyCenter.postNotificationName_object_userInfo_deliverImmediately_("GrowlApplicationRegistrationNotification", nil, dict, true)
+    end #register
+
+    def notify(noteType, title, description, icon=nil, appIcon=nil, sticky=false, priority=nil)
+#        Post a notification to the Growl daemon.
+#
+#        `noteType' is the name of the notification that is being posted.
+#        `title' is the user-visible title for this notification.
+#        `description' is the user-visible description of this notification.
+#        `icon' is an optional icon for this notification.  It defaults to
+#            `@applicationIcon'.
+#        `appIcon' is an optional icon for the sending application.
+#        `sticky' is a boolean controlling whether the notification is sticky.
+
+ 
+       @notifications << noteType
+       if icon == nil then icon = @appIcon end
+       
+       notification = {'NotificationName'=> noteType,
+             'ApplicationName'=> @appName,
+             'NotificationTitle'=> title,
+             'NotificationDescription'=> description,
+             'NotificationIcon'=> icon.TIFFRepresentation()}
+       
+       unless appIcon == nil 
+            notification['NotificationAppIcon'] = appicon.TIFFRepresentation
+       end     
+       
+       if sticky 
+            notification['NotificationSticky'] = OSX::NSNumber.numberWithBool_(true) 
+       end
+            
+       unless priority == nil 
+            notification['NotificationPriority'] = OSX::NSNumber.numberWithInt_(priority)
+       end
+            
+       d = OSX::NSDictionary.dictionaryWithDictionary_(notification)
+       
+       notCenter = OSX::NSDistributedNotificationCenter.defaultCenter()
+       notCenter.postNotificationName_object_userInfo_deliverImmediately_('GrowlNotification', nil, d, true)
+       
+    end #notify
+end #class growlnotifier
+

data/clients/growl_notifier/README.textile

@@ -0,0 +1,13 @@
+h1. Growl notifer for Webstats
+
+The Growl notifier runs in the background and monitors the server; if the server goes under high CPU load for more than a few seconds, or if the server is nearly out of memory, you'll get a Growl notification saying what the problem is. This way, you can just set and forget, knowing that Webstats will report any problems.
+
+Thy works on OS X only, with RubyCocoa installed. 
+
+.h2 Usage
+
+Run the notifier by running webstats_growl_notifier or ruby <webstats_install_dir>/clients/growl_notifier/growl_notifier.rb on the terminal.
+
+The first time you run the growl notifier, it will create a template of the settings you need to edit at ~/.webstats_clients; you must edit this file to set the URL's for the growl notifier to monitor. The URL's should the the hostnames of the servers you want to monitor, along with the correct port number (e.g. http://bloople.net:9970/).
+
+Once you've edited the configuration file to add your URL's, run the notifier again; the Growl notifier will then run in the background and notify you od any warnings or danger situations on the server.

data/clients/growl_notifier/growl_notifier.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../simple_notifier'
+daemonize!
+require File.dirname(__FILE__) + '/Growl.rb'
+
+class WGrowlNotifier < SimpleNotifier
+  def initialize(settings = {}, read_config = true)
+    @name = "growl_notifier"
+    @no_settings_message = "Please edit ~/.webstats_clients and add some URLs to monitor"
+
+    @g = GrowlNotifier.new("Webstats", ['Webstats Notification'], nil, OSX::NSWorkspace.sharedWorkspace().iconForFileType_('unknown'))
+    @g.register
+    
+    super(settings, read_config)
+  end
+  
+  private
+  def failed_url(url, password, exception)
+    @g.notify "Webstats Notification", "Cannot load Webstats data", "Could not load #{url}#{!password.nil? ? " with password #{password}" : ""}, error was #{exception.message}. Will try again in 60 seconds."
+    sleep(60)
+    true
+  end
+
+  def notify
+    @settings[:urls].each do |url|
+     if !url[:bad].empty? and (url[:changed] or url[:time_past])
+       title = []
+       title << "Danger" unless url[:dangers].empty?
+       title << "Warnings" unless url[:warnings].empty?
+       title = title.join(" & ") + " for host #{URI.parse(url[:url]).host}"
+
+       warnings_text = !url[:warnings].empty? ? "Warnings for #{url[:bad].select { |(k, v)| v['status'] == 'warning' }.map { |(k, v)| url[:meta_info][k]['in_sentence'] }.join(", ")}." : nil
+       danger_text = !url[:dangers].empty? ? "Dangerous situation for #{url[:bad].select { |(k, v)| v['status'] == 'danger' }.map { |(k, v)| url[:meta_info][k]['in_sentence'] }.join(", ")}." : nil
+
+       @g.notify "Webstats Notification", title, [danger_text, warnings_text].compact.join(" "), nil, nil, true, (!url[:dangers].empty? ? 2 : 1)
+     end
+   end
+  end
+end
+
+s = WGrowlNotifier.new()
+s.start

data/clients/simple_notifier.rb

@@ -0,0 +1,106 @@
+require 'yaml'
+require 'net/http'
+require 'uri'
+require 'thread'
+require 'time'
+require 'net/smtp'
+
+def daemonize!
+  return if $DAEMONIZE == false
+  if $DEBUG
+    Thread.abort_on_exception
+  else
+    if (pid = fork)
+      Signal.trap('HUP', 'IGNORE')
+      Process.detach(pid)
+      exit
+    end
+  end
+end
+
+class Hash
+  alias_method :undecorated_get, :[] unless method_defined?(:undecorated_get)
+  def [](key)
+    undecorated_get(key) or undecorated_get(key.is_a?(String) ? key.to_sym : key.to_s)
+  end
+end
+
+class SimpleNotifier
+  def initialize(settings = {}, read_config = true)
+    @name ||= "notifier"
+    @default_settings ||= {}
+    
+    if read_config
+      config_file_path = File.expand_path("~/.webstats_clients")
+
+      @settings = {}
+
+      if File.exists?(config_file_path)
+        @settings = YAML.load(IO.read(config_file_path))
+        @settings ||= {}
+      end
+    
+      unless @settings.key?(@name)
+        @settings[@name] = { 'urls' => [{ 'url' => 'http://localhost:9970/', 'password' => nil }] }.merge(@default_settings).merge(settings)
+        File.open(config_file_path, "w") { |f| YAML.dump(@settings, f) }
+
+        puts @no_settings_message
+        exit
+      end
+    
+      @settings = @settings[@name]
+    else
+      @settings = settings
+    end
+  end
+
+  def start
+    @settings[:urls].each do |url|
+      url[:mutex] = Mutex.new
+      Thread.new do
+        url[:mutex].synchronize { url.merge!({ :meta_info => make_request(URI.join(url[:url], "information"), url[:password]), :last_time => 0 }) }
+      end
+    end
+
+    while(true)
+      threads = []
+      @settings[:urls].each do |url|
+        threads << Thread.new do
+          url[:mutex].synchronize do
+            url[:data] = make_request(URI.join(url[:url], "update"), url[:password])
+            url[:bad] = url[:data].sort { |a, b| b[1]['importance'].to_f <=> a[1]['importance'].to_f }.select { |(k, v)| !v['status'].nil? && v['status'] != '' }
+            url[:last_warnings] = url[:warnings] || []
+            url[:warnings] = url[:bad].select { |(k, v)| v['status'] == 'warning' }
+            url[:has_warnings]= !url[:warnings].empty?
+            url[:last_dangers] = url[:dangers] || []
+            url[:dangers] = url[:bad].select { |(k, v)| v['status'] == 'danger' }
+            url[:has_dangers] = !url[:dangers].empty?
+            url[:changed] = (!url[:warnings].empty? || !url[:dangers].empty?) && (!url.key?(:changed) or (url[:warnings].length > url[:last_warnings].length) or (url[:dangers].length > url[:last_dangers].length))
+            url[:time_past] = url[:last_time] != 0 && (Time.now - url[:last_time]) > 60
+            url[:last_time] = Time.now if url[:changed] || url[:last_time].nil? || url[:time_past]
+          end
+        end
+      end
+      threads.each { |t| t.join }
+      notify
+      sleep(10)
+    end
+  end
+
+  private
+  def make_request(url, password)
+    while(true)
+      begin
+        Net::HTTP.start(url.host, url.port) { |http|
+          http.read_timeout = http.open_timeout = 15
+          req = Net::HTTP::Get.new(url.request_uri)
+          req.basic_auth 'webstats', password unless password.nil?
+          return YAML.load(http.request(req).body)
+        }
+      rescue Exception => e
+        return nil unless failed_url(url, password, e)
+      end
+    end
+  end
+end
+

data/server/data_providers/cpu_info.rb

@@ -0,0 +1,74 @@
+class DataProviders::CpuInfo
+  def initialize(settings)
+    @settings = self.class.default_settings.merge(settings)
+
+    @readings = []
+    @mutex = Mutex.new
+
+    @thread = Thread.new do
+      last_time = last_user = last_nice = last_system = last_idle = last_iowait = 0
+      first_time = true
+      while(true)
+        time = (Time.new.to_f * 1000).to_i
+
+        user, nice, system, idle, iowait, crap = IO.readlines("/proc/stat").first.split(' ', 6).map { |i| i.to_i }
+
+        if first_time
+          first_time = false
+        else
+          temp_user = (user - last_user)
+          temp_nice = (nice - last_nice)
+          temp_system = (system - last_system)
+          temp_idle = (idle - last_idle)
+          temp_iowait = (iowait - last_iowait)
+
+          @mutex.synchronize do
+            @readings.unshift((temp_user + temp_nice + temp_system) / (temp_idle.to_f < 1 ? 1 : temp_idle.to_f))
+            @readings.pop while @readings.length > 5
+          end
+        end
+        last_user = user
+        last_nice = nice
+        last_system = system
+        last_idle = idle
+        last_iowait = iowait
+        last_time = time
+        sleep(@settings[:update_rate])
+      end
+    end
+  end  
+    
+  def get
+    out = { :usage => 0 }
+    @mutex.synchronize do
+      unless @readings.empty?
+        out[:usage] = @readings.first
+        out[:status] = 'warning' unless @readings.detect { |r| out[:usage] < @settings[:usage_warning_level] }
+        out[:status] = 'danger' unless @readings.detect { |r| out[:usage] < @settings[:usage_danger_level] }
+      end
+    end
+    out[:loadavg_1], out[:loadavg_5], out[:loadavg_15] = IO.readlines("/proc/loadavg").first.split(' ', 4).map { |v| v.to_f }
+    out
+  end
+
+  def renderer
+    information.merge({ :contents => %{
+sc.innerHTML = "<div class='major_figure'><span class='title'>Usage</span><span class='figure'>" + data_source['usage'] + "</span><span class='unit'>%</span></div>" + 
+"<div class='major_figure'><span class='title'>Load average</span><span class='figure'>" + data_source['loadavg_1'] +
+"</span><span class='unit'>1m</span><span class='divider'>/</span><span class='figure'>" + data_source['loadavg_5'] +
+"</span><span class='unit'>5m</span><span class='divider'>/</span><span class='figure'>" + data_source['loadavg_15'] + "</span><span class='unit'>15m</span></div>";
+} })
+  end
+
+  def self.default_settings
+    { :update_rate => 2.5, :usage_warning_level => 95, :usage_danger_level => 99.5 }
+  end
+
+  def information
+    { :name => "CPU Info", :in_sentence => 'CPU load', :importance => 100 }
+  end
+
+  def kill
+    @thread.kill
+  end
+end

data/server/data_providers/disk_activity.rb

@@ -0,0 +1,52 @@
+class DataProviders::DiskActivity
+  def initialize(settings)
+    @settings = self.class.default_settings.merge(settings)
+
+    @reads_sec = 0
+    @writes_sec = 0
+
+    @thread = Thread.new do
+      last_time = last_reads = last_writes = 0
+      first_time = true
+      while(true)
+        time = (Time.new.to_f * 1000).to_i
+
+        reads, writes = IO.readlines("/proc/diskstats").map { |l| parts = l.split; [parts[5].to_i, parts[9].to_i] }.inject([0, 0]) { |sum, vals| [sum[0] + vals[0], sum[1] + vals[1]] }
+
+        if first_time
+          first_time = false
+        else
+          @reads_sec = ((reads - last_reads) / ((time - last_time).to_f / 1000.0)) * 512
+          @writes_sec = ((writes - last_writes) / ((time - last_time).to_f / 1000.0)) * 512
+        end
+        last_reads = reads
+        last_writes = writes
+        last_time = time
+        sleep(@settings[:update_rate])
+      end
+    end
+  end
+
+  def get
+    { :reads => @reads_sec / 1024.0 / 1024.0, :writes => @writes_sec / 1024.0 / 1024.0 }
+  end
+
+  def renderer
+    information.merge({ :contents => %{
+sc.innerHTML = "<div class='major_figure'><span class='title'>Reads</span><span class='figure'>" + data_source['reads'] + "</span><span class='unit'>mb/s</span></div>" +
+"<div class='major_figure'><span class='title'>Writes</span><span class='figure'>" + data_source['writes'] + "</span><span class='unit'>mb/s</span></div>";
+} })
+  end
+
+  def self.default_settings
+    { :update_rate => 2.5 }
+  end
+
+  def information
+    { :name => "Disk Activity", :in_sentence => "Disk Activity", :importance => 70 }
+  end
+
+  def kill
+    @thread.kill
+  end
+end

data/server/data_providers/disk_usage.c

@@ -0,0 +1,29 @@
+#include <ruby.h>
+#include <sys/statvfs.h>
+
+static VALUE get_disk_usage(VALUE self, VALUE mount_point)
+{
+   char* mount_point_str = RSTRING(mount_point)->ptr;
+
+   VALUE out_hash = rb_hash_new();
+   rb_hash_aset(out_hash, rb_str_new2("free"), Qnil);
+   rb_hash_aset(out_hash, rb_str_new2("total"), Qnil);
+
+   struct statvfs result;
+
+   if(statvfs(mount_point_str, &result) == 0)
+   {
+      rb_hash_aset(out_hash, rb_str_new2("free"), LL2NUM((long long)result.f_bavail * (long long)result.f_frsize));
+      rb_hash_aset(out_hash, rb_str_new2("total"), LL2NUM((long long)result.f_blocks * (long long)result.f_frsize));
+   }
+
+   return out_hash;
+}
+
+void Init_disk_usage()
+{
+   VALUE mDataProviders = rb_const_get(rb_cObject, rb_intern("DataProviders"));
+   VALUE cDiskUsage = rb_const_get(mDataProviders, rb_intern("DiskUsage"));
+   
+   rb_define_method(cDiskUsage, "get_disk_usage", get_disk_usage, 1);
+}

data/server/data_providers/disk_usage.rb

@@ -0,0 +1,54 @@
+class DataProviders::DiskUsage
+  def initialize(settings)
+    @settings = self.class.default_settings.merge(settings)
+  end
+
+  def get
+    out = { :mounts => [] }
+
+    mtab = IO.readlines("/etc/mtab").sort_by { |l| l.split[1] }
+    mtab.map do |mp|
+      parts = mp.split
+      next unless parts[3].split(",").detect { |p| p == "rw" }
+      du = get_disk_usage(parts[1])
+      out[:mounts] << [parts[1], du] unless du['total'] == 0 or (du['total'] > 5242880 && ((du['total'] - du['free']) <= 1048576))
+    end
+
+    out[:mounts].map do |mp|
+      mp[1]['free'] /= (1024.0 * 1024)
+      mp[1]['total'] /= (1024.0 * 1024)
+      out[:status] = "warning" if mp[1]['free'] < @settings[:warning_threshold] and mp[1]['total'] > @settings[:warning_minimum_mount_point_size] and out[:status] != 'danger'
+      out[:status] = "danger" if mp[1]['free'] < @settings[:danger_threshold] and mp[1]['total'] > @settings[:danger_minimum_mount_point_size]
+    end
+
+    out
+  end
+
+  def renderer
+    information.merge({ :contents => %{
+var temp = "";
+for(var i = 0; i < data_source['mounts'].length; i++)
+{
+   var mpd = data_source['mounts'][i][1];
+   temp += "<div class='major_figure'><span class='title'>" + data_source['mounts'][i][0] + "</span><span class='figure'>" + mpd['free'] +
+    "</span><span class='unit'>mb free</span><span class='divider'>/</span><span class='figure'>" + mpd['total'] +
+     "</span><span class='unit'>mb total</span></div>";
+}
+
+sc.innerHTML = temp;
+} })
+  end
+
+  def self.default_settings
+    { :warning_threshold => 50, :danger_threshold => 10, :warning_minimum_mount_point_size => 100, :danger_minimum_mount_point_size => 20 }
+  end
+
+  def information
+    { :name => "Disk Usage by Mount Point", :in_sentence => "Disk Usage", :importance => 80 }
+  end
+
+  def kill
+  end
+end
+
+require File.dirname(__FILE__) + '/disk_usage.so'

data/server/data_providers/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+dir_config("c_extensions")
+
+create_makefile("disk_usage")

data/server/data_providers/mem_info.rb

@@ -0,0 +1,54 @@
+class DataProviders::MemInfo
+  def initialize(settings)
+    @settings = self.class.default_settings.merge(settings)
+
+    @readings = []
+    @mutex = Mutex.new
+
+    @thread = Thread.new do
+      while(true)
+        out = {}
+        out[:total], out[:free], out[:buffers], out[:cached] = IO.readlines("/proc/meminfo")[0..4].map { |l| l =~ /^.*?\: +(.*?) kB$/; $1.to_i / 1024.0 }
+        out[:free_total] = out[:free] + out[:buffers] + out[:cached]
+
+        @mutex.synchronize do
+          @readings.unshift(out)
+          @readings.pop while @readings.length > 5
+        end
+        sleep(@settings[:update_rate])
+      end
+    end
+  end
+
+  def get
+    out = { :total => 0, :free => 0, :buffers => 0, :cached => 0, :free_total => 0 }
+    @mutex.synchronize do
+      unless @readings.empty?
+        out = @readings.first.dup
+        out[:status] = 'warning' unless @readings.detect { |r| r[:free] > 5 }
+        out[:status] = 'danger' unless @readings.detect { |r| r[:free_total] > 1 }
+      end
+    end
+    out
+  end
+
+  def renderer
+    information.merge({ :contents => %{
+sc.innerHTML = "<div class='major_figure'><span class='title'>Free</span><span class='figure'>" + data_source['free'] + "</span><span class='unit'>mb</span></div>" +
+"<div class='major_figure'><span class='title'>Free -buffers/cache</span><span class='figure'>" + data_source['free_total'] + "</span><span class='unit'>mb</span></div>" +
+"<div class='major_figure'><span class='title'>Total</span><span class='figure'>" + data_source['total'] + "</span><span class='unit'>mb</span></div>";
+} })
+  end
+
+  def self.default_settings
+    { :update_rate => 2.5 }
+  end
+
+  def information
+    { :name => "Memory Info", :in_sentence => 'Memory Usage', :importance => 90 }
+  end
+
+  def kill
+    @thread.kill
+  end
+end

data/server/data_providers/url_monitor.rb

@@ -0,0 +1,71 @@
+require 'net/http'
+
+class DataProviders::UrlMonitor
+  def initialize(settings)
+    @settings = self.class.default_settings.merge(settings)
+
+    @readings = {}
+
+    @mutex = Mutex.new
+
+    @thread = Thread.new do
+      while(true)
+        @settings[:urls].sort.each do |url|
+          @mutex.synchronize { @readings[url] = { :response_time => -1, :works => (@readings.key?(url) && @readings[url][:works] == :failed ? :failed : :waiting) } }
+          duration = 0
+          works = :failed
+          begin
+            uri = URI.parse(url)
+            start = Time.now
+            Net::HTTP.start(uri.host, uri.port) { |http|
+              http.read_timeout = http.open_timeout = @settings[:danger_response_time_threshold]
+              raise Exception unless [200, 201, 202, 203, 204, 205, 206, 301, 302, 304].include? http.get(uri.path).code.to_i
+            }
+
+            duration = Time.now - start
+            works = :works
+          rescue Exception => e
+          end
+          @mutex.synchronize { @readings[url] = { :response_time => duration * 1000, :works => works } }
+        end
+        sleep(@settings[:update_rate])
+      end
+    end
+          
+  end
+
+  def get
+    out = {}
+    @mutex.synchronize { out[:urls] = @readings.to_a.sort_by { |e| e[0] } }
+    out[:urls].each do |(url, info)|
+      out[:status] = 'warning' if (info[:works] == :failed) or info[:response_time] > @settings[:warning_response_time_threshold] * 1000 and !out[:status] == 'danger'
+      out[:status] = 'danger' if (info[:works] == :failed) or info[:response_time] > @settings[:danger_response_time_threshold] * 1000
+    end
+    out
+  end
+
+  def renderer
+    information.merge({ :contents => %{
+var temp = "";
+for(var i = 0; i < data_source['urls'].length; i++)
+{
+   var ud = data_source['urls'][i][1];
+   temp += "<div class='major_figure'><span class='title'>" + data_source['urls'][i][0] + "</span><span class='figure'>" +
+    (ud['works'] == 'failed' ? 'Failed</span>' : (ud['works'] == 'waiting' ? 'Waiting</span>' : ud['response_time'] + "</span><span class='unit'>ms</span>")) + "</div>";
+}
+
+sc.innerHTML = temp;
+} })
+  end
+
+  def self.default_settings
+    { :update_rate => 30, :warning_response_time_threshold => 5, :danger_response_time_threshold => 15, :urls => ['http://localhost/'] }
+  end
+
+  def information
+    { :name => "URL Monitor", :in_sentence => "URL Monitor", :importance => 60 }
+  end
+
+  def kill
+  end
+end

data/server/webstats.rb

@@ -0,0 +1,269 @@
+#NO GEM DEPENDENCIES FTW
+require 'webrick'
+require 'yaml'
+
+if $DEBUG
+  Thread.abort_on_exception
+else
+  if (pid = fork)
+    Signal.trap('HUP', 'IGNORE')
+    Process.detach(pid)
+    exit
+  end
+end
+
+Thread.new do
+  while(true)
+    sleep(300)
+    GC.start
+  end
+end
+
+class NilClass
+  def to_json; "null"; end
+end
+
+class TrueClass
+  def to_json; "true"; end
+end
+
+class FalseClass
+  def to_json; "false"; end
+end
+
+class String
+  def underscore
+    self.gsub(/::/, '/').
+     gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+     gsub(/([a-z\d])([A-Z])/,'\1_\2').
+     tr("-", "_").
+     downcase
+  end
+  alias_method :to_json, :inspect
+end
+
+class Numeric
+  def formatted(precision = 1)
+    rounded_number = (Float(self) * (10 ** precision)).round.to_f / 10 ** precision
+    parts = ("%01.#{precision}f" % rounded_number).to_s.split('.')
+    parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
+    parts.join(".")
+  end
+  alias_method :to_json, :inspect
+end
+
+class Array
+  def formatted!
+    each_with_index do |v, i|
+      if v.is_a? Numeric
+        self[i] = v.formatted
+      elsif v.is_a? Hash or v.is_a? Array
+        self[i] = self[i].dup.formatted!
+      end
+    end
+  end
+
+  def symbolize_keys!
+    each_with_index { |v, i| self[i] = self[i].dup.symbolize_keys! if v.is_a? Hash }
+  end
+
+  def stringify_keys!
+    each_with_index { |v, i| self[i] = self[i].dup.stringify_keys! if v.is_a? Hash }
+  end
+
+  def to_json
+    "[#{map { |e| e.to_json }.join(', ')}]"
+  end
+end
+
+class Hash
+  def formatted!
+    each_pair do |k, v|
+      if v.is_a? Numeric
+        self[k] = v.formatted
+      elsif v.is_a? Hash or v.is_a? Array
+        self[k] = self[k].dup.formatted!
+      end
+    end
+  end
+  
+  def symbolize_keys!
+    keys.each { |key| self[key.to_sym] = delete(key) }
+    each_pair { |k, v| self[k] = self[k].dup.symbolize_keys! if v.is_a? Hash }
+  end
+
+  def stringify_keys!
+    keys.each { |key| self[key.to_s] = delete(key) }
+    each_pair { |k, v| self[k] = self[k].dup.stringify_keys! if v.is_a? Hash }
+  end
+
+  alias_method :undecorated_get, :[] unless method_defined?(:undecorated_get)
+  def [](key)
+    undecorated_get(key) or undecorated_get(key.is_a?(String) ? key.to_sym : key.to_s)
+  end
+
+  def to_json
+    arr = []
+    each_pair { |k, v| arr << "#{k.to_json}: #{v.to_json}" }
+    "{#{arr.join(', ')}}"
+  end
+end
+
+class Symbol
+  def to_json
+    to_s.inspect
+  end
+end
+
+module DataProviders
+  DATA_SOURCES_CLASSES = {}
+  DATA_SOURCES = {}
+  def self.preload
+    Dir.glob("#{File.dirname(__FILE__)}/data_providers/*.rb").each { |file| load file unless file =~ /extconf.rb$/ }
+    DataProviders.constants.each do |c|
+      c = DataProviders.const_get(c)
+      DATA_SOURCES_CLASSES[c.to_s.gsub(/^DataProviders::/, '').underscore] = c if c.is_a? Class
+    end
+  end
+  def self.setup(settings)
+    DATA_SOURCES_CLASSES.each_pair { |k, v| DATA_SOURCES[k] = v.new(settings[k]) }
+  end
+end
+
+DataProviders.preload
+
+WEBSTATS_PATH = File.expand_path("~/.webstats")
+
+$settings = {}
+
+if File.exists?(WEBSTATS_PATH)
+  $settings = YAML.load(IO.read(WEBSTATS_PATH)).symbolize_keys!
+else
+  $settings['webstats'] = { 'password' => nil, 'clients' => [] }
+  DataProviders::DATA_SOURCES_CLASSES.each_pair { |k, v| $settings[k.to_s] = v.default_settings.stringify_keys! }
+  File.open(WEBSTATS_PATH, "w") { |f| YAML.dump($settings, f) }
+end
+
+DataProviders.setup($settings)
+
+class Webstats < WEBrick::HTTPServlet::AbstractServlet
+  def do_GET(req, res)
+    WEBrick::HTTPAuth.basic_auth(req, res, "Webstats") { |u, p| u == 'webstats' and p == $settings[:webstats][:password] } unless $settings[:webstats][:password].nil?
+
+    body = ""
+    if req.path_info == '/'
+      body << <<-EOF
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+  <head>
+    <title>Webstats</title>
+    <style type="text/css">
+      * { margin: 0; padding: 0; font-family: "Lucida Grande", Helvetica, Arial, sans-serif; font-size: 100%; }
+      body { font-size: 95%; }
+      p { margin: 0 0 1em 0; }
+
+      h1 { margin: 1em; }
+      h1 span { font-size: 160%; font-weight: bold; }
+      .source .danger { background-color: #FF0D33; }
+      .source .warning { background-color: #F1FF28; }
+
+      .source { width: 500px; border: 1px solid #000000; margin: 1em; }
+      .source h2 { padding: 0 0.8em 0 0.8em; background-color: #C98300; }
+      .source h2 span { font-size: 130%; font-weight: bold; padding: 0.2em 0; display: block; }
+      .source .source_contents { padding: 0.8em; }
+      .source .title { padding-right: 0.5em; }
+      .source .major_figure { font-size: 130%; margin: 0.3em 0; }
+      .source .major_figure .figure { font-size: 120%; font-weight: bold; font-family: Georgia, serif; }
+      .source .major_figure .unit { font-family: Georgia, serif; font-size: 70%; }
+      .source .minor_figure { font-family: Georgia, serif; }
+      .source .divider { margin-left: 0.2em; margin-right: 0.2em; font-weight: normal; }
+    </style>
+    <script type="text/javascript">
+       var http = null;
+
+       function getLatest()
+       {
+          http.open("get", "/update", true);
+          http.send(null);
+       }
+
+       window.onload = function()
+       {
+          http = !!(window.attachEvent && !window.opera) ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
+
+          http.onreadystatechange = function()
+          {
+            if(http.readyState == 4)
+            {
+               var results = eval("(" + http.responseText + ")");
+               if(!results) return;
+EOF
+
+      DataProviders::DATA_SOURCES.each_pair do |k, v|
+        body << %{var data_source = results['#{k}']; var sc = document.getElementById('source_contents_#{k}'); sc.className = "source_contents " + (data_source['status'] ? data_source['status'] : ''); #{v.renderer[:contents]}\n}
+      end
+
+body << <<-EOF
+            }
+         };
+
+         window.setInterval("getLatest()", 5000);
+         getLatest();
+      }
+    </script>
+  </head>
+  <body id="body">
+    <div id="main">
+      <h1><span>Stats for #{req.host}</span></h1>
+EOF
+      DataProviders::DATA_SOURCES.sort { |a, b| b[1].information[:importance] <=> a[1].information[:importance] }.each do |(k, v)|
+        r = v.renderer
+        body << %{<div class="source" id="source_#{k}"><h2><span>#{r[:name]}</span></h2><div class="source_contents" id="source_contents_#{k}">Loading...</div></div>}
+      end
+
+      body << <<-EOF
+    </div>
+  </body>
+</html>
+EOF
+    elsif req.path_info == '/update'
+      out = {}
+      DataProviders::DATA_SOURCES.each_pair do |k, v|
+        out[k] = v.get.dup
+      end
+
+      out.formatted!
+
+      body << out.to_json
+    elsif req.path_info == '/information'
+      out = {}
+      DataProviders::DATA_SOURCES.each_pair { |k, v| out[k] = v.information }
+      body << out.to_json
+    end
+
+    res.body = body
+    res['Content-Type'] = "text/html"
+  end
+end
+
+threads = []
+
+s = WEBrick::HTTPServer.new(:Port => 9970, :Logger => WEBrick::Log.new(nil, 0), :AccessLog => WEBrick::Log.new(nil, 0))
+
+death = proc do
+  s.shutdown
+  DataProviders::DATA_SOURCES.each_pair { |k, v| v.kill }
+  threads.each { |t| t.kill }
+end
+trap("INT", death)
+trap("TERM", death)
+
+s.mount("/", Webstats)
+threads << Thread.new { s.start }
+
+if $settings['webstats'].key?(:clients) and !$settings['webstats'][:clients].nil?
+  $DAEMONIZE = false
+  $settings['webstats'][:clients].each { |name| threads << Thread.new { require "#{File.dirname(__FILE__)}/../clients/#{name}/#{name}.rb" } }
+end
+
+threads.first.join

data/webstats.gemspec

@@ -0,0 +1,57 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{webstats}
+  s.version = "0.10.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Brenton Fletcher"]
+  s.date = %q{2009-06-27}
+  s.description = %q{Monitor server CPU/Memory/Disk Usage/URL Loading, so that you can view those statistics on a web page, as well as providing an interface to client prorams to read those statistics.}
+  s.email = %q{i@bloople.net}
+  s.executables = ["webstats", "webstats_growl_notifier", "webstats_email_notifier"]
+  s.extensions = ["server/data_providers/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.textile"
+  ]
+  s.files = [
+    "LICENSE",
+    "README.textile",
+    "Rakefile",
+    "VERSION.yml",
+    "bin/webstats",
+    "bin/webstats_email_notifier",
+    "bin/webstats_growl_notifier",
+    "clients/email_notifier/README.textile",
+    "clients/email_notifier/email_notifier.rb",
+    "clients/growl_notifier/Growl.rb",
+    "clients/growl_notifier/README.textile",
+    "clients/growl_notifier/growl_notifier.rb",
+    "clients/simple_notifier.rb",
+    "server/data_providers/cpu_info.rb",
+    "server/data_providers/disk_activity.rb",
+    "server/data_providers/disk_usage.c",
+    "server/data_providers/disk_usage.rb",
+    "server/data_providers/extconf.rb",
+    "server/data_providers/mem_info.rb",
+    "server/data_providers/url_monitor.rb",
+    "server/webstats.rb",
+    "webstats.gemspec"
+  ]
+  s.homepage = %q{http://github.com/bloopletech/webstats}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = [""]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Monitor server CPU/Memory/Disk Usage/URL Loading, so that you can view those statistics on a web page, as well as providing an interface to client prorams to read those statistics.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: webstats
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Brenton Fletcher
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-25 00:00:00 +10:30
+default_executable: 
+dependencies: []
+
+description: Monitor server CPU/Memory/Disk Usage/URL Loading, so that you can view those statistics on a web page, as well as providing an interface to client prorams to read those statistics.
+email: i@bloople.net
+executables: 
+- webstats
+- webstats_growl_notifier
+- webstats_email_notifier
+extensions: 
+- server/data_providers/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- LICENSE
+- README.textile
+- Rakefile
+- VERSION.yml
+- bin/webstats
+- bin/webstats_email_notifier
+- bin/webstats_growl_notifier
+- clients/email_notifier/README.textile
+- clients/email_notifier/email_notifier.rb
+- clients/growl_notifier/Growl.rb
+- clients/growl_notifier/README.textile
+- clients/growl_notifier/growl_notifier.rb
+- clients/simple_notifier.rb
+- server/data_providers/cpu_info.rb
+- server/data_providers/disk_activity.rb
+- server/data_providers/disk_usage.c
+- server/data_providers/disk_usage.rb
+- server/data_providers/extconf.rb
+- server/data_providers/mem_info.rb
+- server/data_providers/url_monitor.rb
+- server/webstats.rb
+- webstats.gemspec
+has_rdoc: true
+homepage: http://github.com/bloopletech/webstats
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- ""
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Monitor server CPU/Memory/Disk Usage/URL Loading, so that you can view those statistics on a web page, as well as providing an interface to client prorams to read those statistics.
+test_files: []
+