easymon 1.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70386bd8a4b34143d2913095deb4d60ef7f28f0c
+  data.tar.gz: a36cad6c25360f27cb0d7f10ca81eccaeecb1899
+SHA512:
+  metadata.gz: f7995dc4767abbf2dc5a4e124dcbf2be22b6bfc3957654352622b9faffc5e1af4446c7f4b3a3ef112a3115b9c1a7270eb71ba5df586d94c7065b9da2bbe4021b
+  data.tar.gz: 35afc40c57ff4304f0e8217e49b0b49ee5752e1762658ff95e147b7fab260a4905bb7331572e07cce1e78d2c2bfa20a1b0b21fd21cd33c26a7bcae7f1481c8a8

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 37signals
+
+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,231 @@
+# Easymon
+
+Easymon helps you monitor your application's availability.  It provides a simple
+way to test the availability of resources your application needs, like the
+application database, a memcached connection, or a redis instance.  These test
+results can be used by a load balancer to determine the general health and
+viability of the node your application is running on.
+
+It's packaged up as a rails engine for 3.1 and greater, and a plugin for 2.3 - 
+3.0.
+
+## History
+
+This gem extracts and modularizes the logic we had in our monitoring controllers
+and were copying back and forth between applications.
+
+## Installation
+
+Add to Gemfile and bundle!:
+
+````ruby
+gem 'easymon'
+````
+
+## Usage
+To get started, you'll need to add an initializer for this to do anything. 
+In `config/initializers/easymon.rb`:
+
+````ruby
+Easymon::Repository.add("application-database", Easymon::ActiveRecordCheck.new(ActiveRecord::Base))
+````
+
+This will register a check called `application-database` for use.
+
+Next, we need to add the routes to your application. Depending on the rails
+version, this is done one of two ways:
+
+### Rails 2.3.x & 3.0
+Add `Easymon.routes(map)` to your `config/routes.rb`.  This will put the Easymon
+routes under `/up`.  If you want Easymon mounted somewhere other than `/up`, use
+`Easymon.routes(map, "/monitoring")`.  That would put the Easymon paths under
+`/monitoring`.  For Rails 3.0, the default routes file does not provide `map`,
+so use `Easymon.routes(self)` instead.
+
+### Rails 3.1+
+Rails 3.1+ gives us mountable engines, so use the standard syntax, adding
+`mount Easymon::Engine => "/up"` to your `config/routes.rb`.
+
+
+Now, you can run your entire checklist by visiting `/up`, or wherever you have
+mounted the application.  If you want to just test the single check, go to
+`/up/application-database`, and only the check named `application-database` will
+be run.
+
+### Critical Checks
+If you have several services that are critical to your app, and others that
+are not, you can segregate those for health check purposes if you wish.
+Assuming your database and redis are critical, but memcached is not, again in
+`config/initializers/easymon.rb`:
+
+````ruby
+Easymon::Repository.add(
+  "application-database",
+  Easymon::ActiveRecordCheck.new(ActiveRecord::Base),
+  :critical
+)
+Easymon::Repository.add(
+  "redis",
+  Easymon::RedisCheck.new(
+    YAML.load_file(
+      Rails.root.join("config/redis.yml")
+    )[Rails.env].symbolize_keys
+  ),
+  :critical
+)
+Easymon::Repository.add(
+  "memcached",
+  Easymon::MemcachedCheck.new(Rails.cache)
+)
+````
+
+In addition to the main route `/up`, this will register four checks,
+individually available at:
+
+ * `/up/application-database`
+ * `/up/redis`
+ * `/up/memcached`
+ * `/up/critical` - Runs both the application-database and redis checks.
+
+## Included Checks
+
+ * ActiveRecord
+ * Redis
+ * Memcached
+ * Semaphore
+ * Traffic Enabled
+ * Split ActiveRecord
+ * Http
+
+### ActiveRecord
+`Easymon::ActiveRecordCheck` is a basic check that uses ActiveRecord to check
+the availability of your main database.  It's usually invoked as such:
+
+````ruby
+Easymon::ActiveRecordCheck.new(ActiveRecord::Base)
+````
+
+Internally, it compares `1 == klass.connection.select_value("SELECT 1=1").to_i`
+where klass is whatever class you passed to the check.  Usually this will be
+ActiveRecord::Base, but feel free to go crazy.
+
+### Redis
+`Easymon::RedisCheck` will check the availability of a Redis server, given an
+appropriate config hash.  Typically, we'll read the config off disk, but as long
+as you get a valid config hash, this will work:
+
+````ruby
+Easymon::RedisCheck.new(
+  YAML.load_file(Rails.root.join("config/redis.yml"))[Rails.env].symbolize_keys
+)
+````
+
+This is the most visually complex test to instantiate, but it's only because
+we're loading the config from disk and getting the config block that matches
+the Rails.env in one line.  As long as you pass a hash that can be used by
+Redis.new.
+
+### Memcached
+`Easymon::MemcachedCheck` is a basic check that will write and then read a key
+from the cache.  It expects a cache instance to check, so it could be as easy 
+as:
+
+````ruby
+Easymon::MemcachedCheck.new(Rails.cache)
+````
+
+### Semaphore
+`Easymon::Semaphore` checks for the presence of a file on disk relative to the
+Rails.root of the current application.
+
+````ruby
+check = Easymon::SemaphoreCheck.new("config/redis.yml")
+````
+
+This is mainly a check that gets subclassed by the next check.
+
+###Traffic Enabled
+`Easymon::TrafficEnabledCheck` is fairly specific, but when we want a server to
+accept traffic, we can place a file in the Rails.root, and the load balancers
+can use the result of this check to help decide whether or not to send traffic
+to the node.
+
+````ruby
+Easymon::TrafficEnabledCheck.new("enable-traffic")
+````
+
+###Split ActiveRecord
+`Easymon::SplitActiveRecordCheck` is the most complicated check, as it's not
+something you can use out of the gate. Here we pass a block so we get a fresh
+instance of `ActiveRecord::Base` or whatever other class we might be using to
+make a secondary database connection.
+
+For example, given the following other class:
+
+````ruby
+module Easymon
+  class Base < ActiveRecord::Base
+    def establish_connection(spec = nil)
+      if spec
+        super
+      elsif config = Easymon.database_configuration
+        super config
+      end
+    end
+    def database_configuration
+      env = "#{Rails.env}_slave"
+      config = YAML.load_file(Rails.root.join('config/database.yml'))[env]
+    end
+  end
+end
+````
+
+We would check both it and `ActiveRecord::Base` like so:
+
+````ruby
+check = Easymon::SplitActiveRecordCheck.new {
+  [ActiveRecord::Base.connection, Easymon::Base.connection]
+}
+Easymon::Repository.add("split-database", check)
+````
+
+### Http
+`Easymon::HttpCheck` will check the return status of a HEAD request to a URL. 
+Great for checking service endpoint availability! The following will make a 
+request to port 9200 on localhost, which is where you might have Elasticsearch 
+running:
+
+````ruby
+Easymon::HttpCheck.new("http://localhost:9200")
+````
+
+Typically, we'll read an elasticsearch config off disk, and use the URL like so:
+
+````ruby
+config = YAML.load_file(Rails.root.join("config/elasticsearch.yml"))[Rails.env].symbolize_keys
+Easymon::HttpCheck.new(config[:url])
+````
+
+## How to contribute
+
+Here's the most direct way to get your work merged into the project:
+
+1. Fork the project
+2. Clone down your fork
+3. Create a feature branch
+4. Add your feature + tests
+5. Document new features in the README
+6. Make sure everything still passes by running the tests
+7. If necessary, rebase your commits into logical chunks, without errors
+8. Push the branch up
+9. Send a pull request for your branch
+
+If you're going to make a major change ask first to maje sure it's in line with 
+the project goals.
+
+## Authors
+
+* [Nathan Anderson](mailto:andnat@gmail.com)
+
+## License
+See [LICENSE](LICENSE)

data/Rakefile

@@ -0,0 +1,40 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Easymon'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/assets/javascripts/easymon/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require jquery
+//= require jquery_ujs
+//= require_tree .

data/app/assets/javascripts/easymon/checks.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/app/assets/stylesheets/easymon/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/app/assets/stylesheets/easymon/checks.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/controllers/easymon/application_controller.rb

@@ -0,0 +1,4 @@
+module Easymon
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/easymon/checks_controller.rb

@@ -0,0 +1,55 @@
+require_dependency "easymon/application_controller"
+
+module Easymon
+  class ChecksController < ApplicationController
+    rescue_from Easymon::NoSuchCheck do |e|
+      respond_to do |format|
+         format.any(:text, :html) { render :text => e.message, :status => :not_found }
+         format.json { render :json => e.message, :status => :not_found }
+      end
+    end
+    
+    def index
+      checklist = Easymon::Repository.all
+      checklist.check
+      
+      message = "No Checks Defined"
+      
+      response_status = checklist.response_status
+      message = checklist.to_s unless checklist.empty?
+      
+      unless checklist.empty?
+        # override response_status if we have a "critical" checklist
+        if checklist.include?("critical")
+          critical_checklist = checklist.fetch("critical")
+          response_status = critical_checklist.response_status
+          message = add_prefix(critical_checklist.success?, message)
+        else
+          message = add_prefix(checklist.success?, message)
+        end
+      end
+
+      respond_to do |format|
+         format.any(:text, :html) { render :text => message, :status => response_status }
+         format.json { render :json => checklist, :status => response_status }
+      end
+    end
+
+    def show
+      check = Easymon::Repository.fetch(params[:check])
+      result = Easymon::Result.new(check.check)
+      
+      message = "#{params[:check]}: #{result.message}"
+      
+      respond_to do |format|
+         format.any(:text, :html) { render :text => result.message, :status => result.response_status }
+         format.json { render :json => message, :status => result.response_status }
+      end
+    end
+
+    private
+      def add_prefix(result, message)
+        result ? "OK #{message}" : "DOWN #{message}"
+      end
+  end
+end

data/app/helpers/easymon/application_helper.rb

@@ -0,0 +1,4 @@
+module Easymon
+  module ApplicationHelper
+  end
+end

data/app/helpers/easymon/checks_helper.rb

@@ -0,0 +1,4 @@
+module Easymon
+  module ChecksHelper
+  end
+end

data/app/views/layouts/easymon/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Easymon</title>
+  <%= stylesheet_link_tag    "easymon/application", :media => "all" %>
+  <%= javascript_include_tag "easymon/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,6 @@
+# use `mount Easymon::Engine => "/up"` in the host application routes.rb
+if Gem::Version.new(Rails.version) >= Gem::Version.new('3.1')
+  Easymon::Engine.routes.draw do
+    Easymon.routes(self)
+  end
+end

data/lib/easymon.rb

@@ -0,0 +1,64 @@
+if Gem::Version.new(Rails.version) >= Gem::Version.new("3.0")
+  require "easymon/engine"
+end
+
+
+require "easymon/checklist"
+require "easymon/repository"
+require "easymon/result"
+
+require "easymon/checks/active_record_check"
+require "easymon/checks/split_active_record_check"
+require "easymon/checks/redis_check"
+require "easymon/checks/memcached_check"
+require "easymon/checks/semaphore_check"
+require "easymon/checks/traffic_enabled_check"
+require "easymon/checks/http_check"
+require "easymon/testing"
+
+module Easymon
+  NoSuchCheck = Class.new(StandardError)
+
+  def self.rails_version
+    Gem::Version.new(Rails.version)
+  end
+
+  def self.rails2?
+    Easymon.rails_version.between?(Gem::Version.new("2.3"), Gem::Version.new("3.0"))
+  end
+
+  def self.rails30?
+    Easymon.rails_version.between?(Gem::Version.new("3.0"), Gem::Version.new("3.1"))
+  end
+
+  def self.mountable_engine?
+    Easymon.rails_version > Gem::Version.new("3.1")
+  end
+
+  def self.routes(mapper, path = "/up")
+    if Easymon.rails2?
+      # Rails 2.3.x (anything less than 3, really)
+      $:.unshift File.expand_path(File.join(
+        File.dirname(__FILE__),
+        "..","app","controllers"))
+      require 'easymon/checks_controller'
+
+      mapper.instance_eval do
+        connect "#{path}", :controller => "easymon/checks", :action => "index"
+        connect "#{path}/:check", :controller => "easymon/checks", :action => "show"
+      end
+    elsif Easymon.rails30?
+      # Greater than 3.0, but less than 3.1
+      mapper.instance_eval do
+        get "#{path}" => 'easymon/checks#index'
+        get "#{path}/:check" => 'easymon/checks#show'
+      end
+    elsif Easymon.mountable_engine?
+      # Rails 3.1+
+      mapper.instance_eval do
+        get "/", :to => "checks#index"
+        get "/:check", :to => "checks#show"
+      end
+    end
+  end
+end