skywatch 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in skywatch.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jeff Lindsay
+
+MIT License
+
+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.md

@@ -0,0 +1,175 @@
+# Skywatch (alpha)
+
+Simple alerting system that lets you define checks and alerts in any
+language that are then magically run on Heroku.
+
+NoOps! Polyglot! Free monitoring of anything!
+
+## Installation
+
+    $ gem install skywatch
+
+## Usage
+
+It's a fairly powerful tool. Run help to see a list of subcommands.
+
+    $ skywatch -h
+
+## What the hell is this amazing thing??
+
+Skywatch is a command-line utility that manages checking and alerting
+scripts used by a builtin watcher service. Skywatch deploys these
+scripts and service for you on Heroku where they can run and monitor
+anything from the cloud for free.
+
+The watcher service runs check scripts that can assert
+anything at any frequency. If a check script returns a non-zero exit status, 
+it will fire any enabled alert scripts, passing it the output of the
+check script and other useful data. Alert scripts can then act on this
+assertion failure, such as send email, SMS, or webhook.
+
+The check script will continue to run and potentially fail, but the
+alert script only runs once, if without error. Only until a reset signal
+is sent will it be ready to fire the alert again for any failed check
+script. In this way, alerts work like [clip
+indicators](http://help.adobe.com/en_US/audition/cs/using/WS58a04a822e3e5010548241038980c2c5-7f93.html)
+in the audio recording world. They turn on once any clipping happens and
+remain on until you manually reset them.
+
+You manage your scripts locally with the skywatch command, or by hand
+since they're just files in directories. When you want to deploy script
+changes, toggle enabled scripts, or reset the alert state, you can run a
+skywatch command and it will handle pushing changes to Heroku for you.
+
+## Getting Started
+
+The skywatch command manages a directory containing check scripts and
+alert scripts. You can make a new directory and let skywatch set this up
+for you:
+
+    $ mkdir my-watcher
+    $ cd my-watcher
+    $ skywatch init
+
+At this point, it will have you authenticate with your Heroku
+credentials if you haven't already. Grab a free account if you don't
+have one. 
+
+When you run `skywatch init` authenticated it will create some example
+alerts and checks for you, and deploy a Heroku app. None of the checks
+or alerts are enabled by default. See everything by just running
+`skywatch` from the directory:
+
+    $ skywatch
+      Checks for fathomless-crag-3169
+        example                  every 30s        disabled
+        skywatch_watchers        every 3600s      disabled
+      Alerts for fathomless-crag-3169
+        email            disabled
+
+Take a look at all the files in the directory. Checks and alerts are nothing
+more than scripts. Checks have a naming convention of `<interval>.<name>`,
+and enabling and disabling is just setting the execute bit on the
+scripts. There's nothing the `skywatch` command does that you can't
+easily do by hand. It just happens to be terribly convenient.
+
+    $ skywatch edit alert email
+
+This will open your editor and you can see the example email alert
+script is using SendGrid. In fact, when you ran `skywatch init`, you
+were set up with a free SendGrid starter addon for 600 emails a day. So
+let's try it by putting your email address in the `TO` variable of the
+script. Now enable the alert:
+
+    $ skywatch enable alert email
+
+Let's create a new check script in bash that fails so we can get the
+alert.
+
+    $ skywatch create check failure_test 30
+
+The last argument is the interval. Intervals are always in seconds. All
+this did was create a new file under the `checks` directory with a
+little bit of boiler plate. Let's replace its contents with this:
+
+    #!/usr/bin/env bash
+    echo "Oh no, a failed check."
+    exit 255
+
+Enable the check and then we'll deploy:
+
+    $ skywatch enable check failure_test
+    $ skywatch deploy
+
+It's going to move some files around and then deploy to Heroku. It keeps
+a staging directory called `.skywatch`, which is a Git repo used to push
+to Heroku. It automatically adds this to a `.gitignore` file, so you can
+version your scripts with Git and not worry about this implementation
+detail.
+
+Once it's finished, you might want to run monitor to see how it went and
+what's going on. This is just tailing the Heroku logs of the watcher
+service:
+
+    $ skywatch monitor
+
+You can run this whenever to see what it's doing. You'll probably see
+that it triggered the alert. Go check your email! That will be the only
+email you get, regardless of whether the check starts to work again and
+then fail again. No flapping. You have to manually reset:
+
+    $ skywatch reset
+
+This should cause another alert email within 30 seconds. And of course,
+you can tear everything down with destroy:
+  
+    $ skywatch destroy
+
+This destroys the Heroku app and the `.skywatch` directory. It doesn't
+touch your scripts at all. In fact, you can run `skywatch init` again if
+you'd like. 
+
+The source code to all this is terribly simple. The watcher service is
+only about 50 lines of Ruby. Everything else is just file operations.
+In fact, the little state it maintains is kept in file metadata. For how
+automated it is, skywatch has to be one of the simplest monitoring services
+ever.
+
+## Writing Check Scripts
+
+Check scripts are any executable script using the shebang to define the
+interpreter. Heroku has most common languages built-in to its Cedar
+stack, so feel free to use Python, Perl, Ruby, whatever. I like bash.
+
+The only conventions of check scripts are the interval-in-the-filename and that a non-zero exit status will fire the alerts. Any output of the check script will be piped into STDIN of the alert script, so try be verbose but not too
+verbose.
+
+If you're using bash, it's a good idea to use `set -e` so any failed
+subcommand will bubble up.
+
+## Writing Alert Scripts
+
+Like check scripts, alert scripts can be written in any language. Also,
+like check scripts, the exit status is important. If an alert script
+exit status is non-zero, it will run again with the next failure of the check
+script. 
+
+The alert script is given the output of the check script via STDIN. It's
+also given 2 arguments. The first is the name of the check script. The
+second is the exit status of the failed check script.
+
+The output of an alert script is ignored. It might be a good idea to log
+the output of failed alert scripts. You'd then be able to see it via
+`skywatch monitor`. Sounds like a contribution idea.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+
+task :test do
+  exec "bundle exec rspec spec"
+end

data/bin/skywatch

@@ -0,0 +1,231 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'commander/import'
+require 'highline/import'
+
+require 'skywatch'
+
+include Skywatch
+
+program :name, 'skywatch'
+program :version, Skywatch::VERSION
+program :description, 'Simple, Unix-oriented alerting system'
+default_command :all
+
+def display_check(check)
+  status = check.enabled? ? "'enabled', :green" : "'disabled', :red"
+  say "    %-24s %-16s %s" % [
+    check.name, "every #{check.interval}s", "<%= color #{status} %>"]
+end
+
+def display_alert(alert)
+  status = alert.enabled? ? "'enabled', :green" : "'disabled', :red"
+  say "    %-16s %s" % [
+    alert.name, "<%= color #{status} %>"]
+end
+
+def ensure_logged_in
+  if not logged_in?
+    say_warning "You're not logged into Heroku. Please login then try again"
+    login
+  end
+end
+
+command :init do |c|
+  c.syntax = 'skywatch init [name]'
+  c.description = 'Initializes skywatch in the current directory'
+  c.action do |args, options|
+    ensure_logged_in
+    init args.first
+    say_ok "Skywatch initialized as #{name}"
+  end
+end
+
+command :checks do |c|
+  c.syntax = 'skywatch checks'
+  c.description = 'Lists checks'
+  c.action do |args, options|
+    puts "  Checks for #{name}"
+    checks.each do |check|
+      display_check check
+    end
+  end
+end
+
+command :alerts do |c|
+  c.syntax = 'skywatch alerts'
+  c.description = 'Lists alerts'
+  c.action do |args, options|
+    puts "  Alerts for #{name}"
+    alerts.each do |alert|
+      display_alert alert
+    end
+  end
+end
+
+command :all do |c|
+  c.syntax = 'skywatch all'
+  c.description = 'Lists checks and alerts'
+  c.action do |args, options|
+    puts "  Checks for #{name}"
+    checks.each do |check|
+      display_check check
+    end
+    puts "  Alerts for #{name}"
+    alerts.each do |alert|
+      display_alert alert
+    end
+  end
+end
+
+command :'enable check' do |c|
+  c.syntax = 'skywatch enable check <name>'
+  c.description = 'Enable a check'
+  c.action do |args, options|
+    fail unless args.length > 0
+    check = check(args.first)
+    check.enable
+    display_check check
+  end
+end
+
+command :'disable check' do |c|
+  c.syntax = 'skywatch disable check <name>'
+  c.description = 'Disable a check'
+  c.action do |args, options|
+    fail unless args.length > 0
+    check = check(args.first)
+    check.disable
+    display_check check
+  end
+end
+
+command :'enable alert' do |c|
+  c.syntax = 'skywatch enable alert <name>'
+  c.description = 'Enable an alert'
+  c.action do |args, options|
+    fail unless args.length > 0
+    alert = alert(args.first)
+    alert.enable
+    display_alert alert
+  end
+end
+
+command :'disable alert' do |c|
+  c.syntax = 'skywatch disable alert <name>'
+  c.description = 'Disable an alert'
+  c.action do |args, options|
+    fail unless args.length > 0
+    alert = alert(args.first)
+    alert.disable
+    display_alert alert
+  end
+end
+
+command :'create alert' do |c|
+  c.syntax = 'skywatch create alert <name> [interpreter]'
+  c.description = 'Create an alert script. Default interpreter is bash'
+  c.action do |args, options|
+    fail unless args.length > 0
+    interpreter = args.length > 1 ? args[1] : 'bash'
+    alert = create_alert(args.first, interpreter)
+    display_alert alert
+  end
+end
+
+command :'create check' do |c|
+  c.syntax = 'skywatch create check <name> <interval> [interpreter]'
+  c.description = 'Create a check script. Default interpreter is bash'
+  c.action do |args, options|
+    fail unless args.length > 1
+    interpreter = args.length > 2 ? args[2] : 'bash'
+    check = create_check(args[0], args[1], interpreter)
+    display_check check
+  end
+end
+
+command :'edit alert' do |c|
+  c.syntax = 'skywatch edit alert <name>'
+  c.description = 'Open the alert script in an editor'
+  c.action do |args|
+    fail unless args.length > 0
+    if ENV['EDITOR'].to_s.empty?
+      puts "The EDITOR environment variable is not defined."
+    else
+      alert = alert(args.first)
+      exec "#{ENV['EDITOR']} #{alert.path}"
+    end
+  end
+end
+
+command :'edit check' do |c|
+  c.syntax = 'skywatch edit check <name>'
+  c.description = 'Open the check script in an editor'
+  c.action do |args|
+    fail unless args.length > 0
+    if ENV['EDITOR'].to_s.empty?
+      puts "The EDITOR environment variable is not defined."
+    else
+      check = check(args.first)
+      exec "#{ENV['EDITOR']} #{check.path}"
+    end
+  end
+end
+
+command :reset do |c|
+  c.syntax = 'skywatch reset'
+  c.description = 'Reset running check states'
+  c.action do
+    ensure_logged_in
+    reset
+  end
+end
+
+command :monitor do |c|
+  c.syntax = 'skywatch monitor'
+  c.description = 'Monitor the running checks'
+  c.action do
+    ensure_logged_in
+    monitor
+  end
+end
+
+command :deploy do |c|
+  c.syntax = 'skywatch deploy'
+  c.description = 'Deploy this skywatch'
+  c.action do
+    ensure_logged_in
+    deploy
+  end
+end
+
+command :destroy do |c|
+  c.syntax = 'skywatch destroy'
+  c.description = 'Destroy skywatch Heroku app and stage directory'
+  c.action do
+    ensure_logged_in
+    destroy
+  end
+end
+
+#command :'destroy alert' do |c|
+#  c.syntax = 'skywatch destroy alert <name>'
+#  c.description = 'Delete an alert script'
+#  c.action do |args, options|
+#    fail unless args.length > 0
+#    alert = alert(args.first)
+#    alert.destroy
+#    say "  Alert <%= color '#{alert.name}', :bold %> has been destroyed"
+#  end
+#end
+
+#command :'destroy check' do |c|
+#  c.syntax = 'skywatch destroy check <name>'
+#  c.description = 'Delete a check script'
+#  c.action do |args, options|
+#    fail unless args.length > 0
+#    check = check(args.first)
+#    check.destroy
+#    say "  Check <%= color '#{check.name}', :bold %> has been destroyed"
+#  end
+#end

data/lib/skywatch.rb

@@ -0,0 +1,3 @@
+require "skywatch/version"
+require "skywatch/tool"
+

data/lib/skywatch/builtin/alerts/email

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+TO=
+SUBJECT="[skywatch] $1"
+BODY=`echo -e "Failure with status $2:\n\n$(cat)"`
+set -e
+curl \
+  -X 'POST' \
+  -F "api_user=$SENDGRID_USERNAME" \
+  -F "api_key=$SENDGRID_PASSWORD" \
+  -F "to=$TO" \
+  -F "subject=$SUBJECT" \
+  -F "text=$BODY" \
+  -F "from=$TO" \
+  --silent --fail "https://sendgrid.com/api/mail.send.json"

data/lib/skywatch/builtin/checks/30.example

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -e
+curl --trace-ascii --silent --fail http://example.com

data/lib/skywatch/builtin/checks/3600.skywatch_watchers

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require "net/https"
+require "uri"
+require "json"
+
+uri = URI.parse("https://api.github.com/repos/progrium/skywatch")
+http = Net::HTTP.new(uri.host, uri.port)
+http.use_ssl = true
+http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+request = Net::HTTP::Get.new(uri.request_uri)
+
+response = http.request(request)
+repo = JSON.parse(response.body)
+
+if repo['watchers_count'] > 1000
+  raise "#{repo['watchers_count']} watchers!"
+end

data/lib/skywatch/tool.rb

@@ -0,0 +1,211 @@
+require 'fileutils'
+
+module Skywatch
+  include FileUtils
+
+  def init(name="")
+    fail if skywatch?
+    mkdir '.skywatch'
+    begin
+      cd '.skywatch' do
+        system "git init"
+        puts `heroku create #{name}`
+        fail if not $?.exitstatus.zero?
+        puts `heroku addons:add sendgrid:starter`
+        system "cp #{watcher_path}/* ."
+        system "bundle install > /dev/null 2>&1"
+      end
+      mkdir_p 'alerts'
+      if Dir['alerts/*'].empty?
+        system "cp #{builtin_path}/alerts/* alerts"
+      end
+      mkdir_p 'checks'
+      if Dir['checks/*'].empty?
+        system "cp #{builtin_path}/checks/* checks"
+      end
+      system "echo '.skywatch' >> .gitignore"
+      deploy
+      cd '.skywatch' do
+        system "heroku ps:scale watcher=1"
+      end
+    rescue
+      rm_rf '.skywatch'
+    end
+  end
+
+  def logged_in?
+    `heroku auth:token < /dev/null`
+    $?.exitstatus.zero?
+  end
+
+  def login
+    exec 'heroku auth:login'
+  end
+
+  def watcher_path
+    File.dirname(__FILE__)+"/watcher"
+  end
+
+  def builtin_path
+    File.dirname(__FILE__)+"/builtin"
+  end
+
+  def skywatch?
+    not Dir["./.skywatch"].empty?
+  end
+
+  def checks
+    fail unless skywatch?
+    Dir["./checks/*"].collect{|c| Check[c] }
+  end
+
+  def alerts
+    fail unless skywatch?
+    Dir["./alerts/*"].collect{|c| Alert[c] }
+  end
+
+  def check(name)
+    fail unless skywatch?
+    Check[Dir["./checks/*.#{name}"].first]
+  end
+
+  def alert(name)
+    fail unless skywatch?
+    Alert[Dir["./alerts/#{name}"].first]
+  end
+
+  def create_alert(name, interpreter)
+    fail unless skywatch?
+    fail if File.exist? "./alerts/#{name}"
+    File.open("./alerts/#{name}", 'w') do |f|
+      f.write "#!/usr/bin/env #{interpreter}\n"
+      if interpreter == 'bash'
+        f.write "set -e\n"
+      end
+      f.write "# Write your alert here"
+    end
+    alert(name)
+  end
+
+  def create_check(name, interval, interpreter)
+    fail unless skywatch?
+    fail if File.exist? "./checks/#{interval}.#{name}"
+    File.open("./checks/#{interval}.#{name}", 'w') do |f|
+      f.write "#!/usr/bin/env #{interpreter}\n"
+      if interpreter == 'bash'
+        f.write "set -e\n"
+      end
+      f.write "# Write your check here"
+    end
+    check(name)
+  end
+
+  def name
+    fail unless skywatch?
+    cd ".skywatch" do
+      if not File.exist? 'name'
+        name = `eval $(heroku apps:info -s | grep "^name=") && echo "$name"`.strip
+        File.open('name', 'w') {|f| f.write(name) }
+      end
+      @@name ||= File.read('name')
+    end
+    @@name
+  end
+
+  def reset
+    fail unless skywatch?
+    cd ".skywatch" do
+      puts `heroku restart`
+    end
+  end
+
+  def monitor
+    fail unless skywatch?
+    cd ".skywatch" do
+      exec "heroku logs -t -n 10"
+    end
+  end
+
+  def stage
+    fail unless skywatch?
+    cd '.skywatch' do
+      system 'git rm -f alerts/* > /dev/null 2>&1'
+      system 'git rm -f checks/* > /dev/null 2>&1'
+    end
+    mkdir_p '.skywatch/alerts'
+    mkdir_p '.skywatch/checks'
+    system 'cp alerts/* .skywatch/alerts'
+    system 'cp checks/* .skywatch/checks'
+    commit
+  end
+
+  def commit
+    fail unless skywatch?
+    cd '.skywatch' do
+      system 'git add .'
+      if not `git status`.include? "nothing to commit"
+        system 'git commit -m "skywatch commit"'
+      end
+    end
+  end
+
+  def deploy
+    stage
+    cd '.skywatch' do
+      puts `git push heroku master`
+    end
+  end
+
+  def destroy
+    fail unless skywatch?
+    puts `heroku apps:destroy -a #{name} --confirm #{name}`
+    rm_rf '.skywatch'
+  end
+
+  class Script
+    attr :path
+    attr :name
+
+    def self.[](path)
+      self.new(path)
+    end
+
+    def initialize(path)
+      @path = path
+      @name = File.basename(path)
+    end
+
+    def enabled?
+      File.executable? @path
+    end
+
+    def enable
+      chmod File.stat(@path).mode | 0700, @path
+    end
+
+    def disable
+      enable # since this is relative, force 0700
+      chmod File.stat(@path).mode & ~0100, @path
+    end
+
+    def destroy
+      rm @path
+    end
+  end
+
+  class Check < Script
+    attr :interval
+    
+    def initialize(path)
+      interval, name = File.basename(path).split('.', 2)
+      @path = path
+      @name = name
+      @interval = interval.to_i
+    end
+  end
+
+  class Alert < Script
+  end
+
+end
+

data/lib/skywatch/version.rb

@@ -0,0 +1,3 @@
+module Skywatch
+  VERSION = "0.0.1"
+end

data/lib/skywatch/watcher/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gem 'clockwork'

data/lib/skywatch/watcher/Procfile

@@ -0,0 +1 @@
+watcher: bundle exec clockwork watcher.rb

data/lib/skywatch/watcher/watcher.rb

@@ -0,0 +1,56 @@
+require 'clockwork'
+require 'fileutils'
+
+include Clockwork
+include FileUtils
+
+Clockwork.configure do |config|
+  config[:logger] = Logger.new(STDOUT)
+  config[:logger].level = Logger::ERROR
+end
+
+def mark_pass(check);     chmod File.stat(check).mode & ~0003, check; end 
+def mark_fail(check);     chmod File.stat(check).mode | 0007, check; end
+def mark_alerted(check);  chmod File.stat(check).mode | 0070, check; end
+def marked_alerted?(check)
+  `stat -c %A #{check} | sed 's/......\\(.\\).\\+/\\1/'` == "x\n"
+end
+def executables(glob)
+  Dir[glob].select {|path| File.executable? path }
+end
+
+mkdir_p 'output'
+mkdir_p 'checks'
+mkdir_p 'alerts'
+
+executables('checks/*').each do |check|
+  interval, name = File.basename(check).split('.', 2)
+
+  puts "loading check #{name} for every #{interval} seconds"
+  every interval.to_i.seconds, name do
+    
+    puts "checking #{name} (#{File.stat(check).mode.to_s(8)})"
+    `#{check} > output/#{name} 2>&1`
+
+    status = $?.exitstatus
+    if status.zero?
+      mark_pass check
+    else
+      puts "   #{name} check failed with status #{status}"
+      mark_fail check
+
+      if not marked_alerted? check
+        executables('alerts/*').each do |alert|
+          puts "   sending #{File.basename(alert)} alert for #{name}"
+          `cat output/#{name} | #{alert} #{name} #{status} > /dev/null 2>&1`
+          
+          if $?.exitstatus.zero?
+            mark_alerted check 
+          end
+        end
+      end
+
+    end
+  end # every
+
+end

data/skywatch.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'skywatch/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "skywatch"
+  gem.version       = Skywatch::VERSION
+  gem.authors       = ["Jeff Lindsay"]
+  gem.email         = ["progrium@gmail.com"]
+  gem.description   = %q{Simple alerting system that lets you define checks and alerts in any language that are then magically run on Heroku.}
+  gem.summary       = %q{Simple, polyglot alerting system}
+  gem.homepage      = "http://github.com/progrium/skywatch"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rspec", "~> 2.6"
+
+  gem.add_dependency "commander", "~> 4.1"
+  gem.add_dependency "heroku", "~> 2.33"
+  gem.add_dependency "bundler", "~> 1.2"
+end

data/spec/skywatch_spec.rb

@@ -0,0 +1,8 @@
+require 'skywatch'
+
+describe Skywatch do
+  it "runs" do
+    false.should eql(false)
+  end
+end
+

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: skywatch
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jeff Lindsay
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: heroku
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.33'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.33'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Simple alerting system that lets you define checks and alerts in any
+  language that are then magically run on Heroku.
+email:
+- progrium@gmail.com
+executables:
+- skywatch
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/skywatch
+- lib/skywatch.rb
+- lib/skywatch/builtin/alerts/email
+- lib/skywatch/builtin/checks/30.example
+- lib/skywatch/builtin/checks/3600.skywatch_watchers
+- lib/skywatch/tool.rb
+- lib/skywatch/version.rb
+- lib/skywatch/watcher/Gemfile
+- lib/skywatch/watcher/Procfile
+- lib/skywatch/watcher/watcher.rb
+- skywatch.gemspec
+- spec/skywatch_spec.rb
+homepage: http://github.com/progrium/skywatch
+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: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Simple, polyglot alerting system
+test_files:
+- spec/skywatch_spec.rb