tocsin 0.1.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp

data/Gemfile

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

data/README.md

@@ -0,0 +1,56 @@
+# Tocsin
+Tocsin is a library designed to simply the task of notifying interested parties about your site's operation. You may already be tracking errors through [New Relic](http://www.newrelic.com), but not all errors are created equal -- there are probably parts of your site where an exception occuring is significantly more of a problem than a bored URL surfer visiting random links and throwing 404s. Tocsin can help you be informed when these parts of your site break, or when important events happen.
+
+Currently, Tocsin works only in Rails 3, and supports notification via email.
+
+## Installation
+Add Tocsin to your Gemfile:
+<pre>
+gem 'tocsin'
+</pre>
+
+Update your bundle:
+<pre>
+bundle install
+</pre>
+
+Use the provided Rake task to generate the migration and model needed by Tocsin. (Angry at the lack of normalization? Install [lookup_by](https://github.com/companygardener/lookup_by/) and rewrite the migration and model to use it; Tocsin won't even notice.)
+<pre>
+rake tocsin:install
+</pre>
+
+Lastly, configure Tocsin to be useful. Create an initializer in `config/initializers/tocsin.rb` that looks something like this:
+<pre>
+Tocsin.configure do |c|
+  c.from_address = 'me@mysite.com'
+
+  c.notify 'you@gmail.com', :of => { :category => /user_registrations/ }, :by => :email
+  c.notify ['you@gmail.com', 'sales@mysite.com'], :of => { :category => /new_sales/ } # N.B. 'email' is the default nofifier.
+  c.notify 'ops@mysite.com', :of => { :severity => /critical/ } # Values in the :of hash should be regexes.
+end
+</pre>
+
+## Usage
+In anywhere you want to send yourself a notification:
+<pre>
+Tocsin.notify :category => :user_registrations,
+              :message => "User #{user.name} registered at #{Time.now}!"
+</pre>
+
+If you want to sound the alarm:
+<pre>
+begin
+  # ...
+rescue => e
+  Tocsin.raise_alert  e, :category => :user_registrations,
+                         :severity => :critical,
+                         :message => "An error occurred when a user tried to sign up!"
+end
+</pre>
+
+In any code you want to watch for explosions:
+<pre>
+Tocsin.watch! :category => :important_stuff, :severity => :critical, :message => "Error doing important stuff!" do
+  Important::Stuff.do!
+end
+</pre>

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/lib/tocsin.rb

@@ -0,0 +1,159 @@
+require "tocsin/version"
+require "tocsin/notifiers"
+require "tocsin/config"
+
+require "active_record/errors" 
+require 'logger'
+
+# Library for escalating and logging errors.
+module Tocsin
+  # Raise an alarm and escalate as configured in etc/tocsin.yml.
+  # @param [Exception] exception exception object if one was raised
+  # @option options :severity severity of this notication. Should be low,
+  # medium, high, critical, or notification (arbitrary, though)
+  # @option options :message any info attached to this notification
+  # @option options :category totally arbitrary, but escalation can be configured based on
+  # this field.
+  # @return [Tocsin::Alert] the created alert
+  def self.raise_alert(exception, options={})
+    urgent = options.delete(:now) || options.delete(:urgent) || options.delete(:synchronous)
+    alert  = alert_for(exception, options)
+
+    begin
+      urgent ? sound(alert) : queue(alert)
+    rescue => e
+      sound cannot_enqueue_alert(e)
+      sound alert
+    end
+
+    alert
+  end
+
+  # Synonyms for raise_alert when no exception is involved.
+  def self.notify(options)
+    self.raise_alert(nil, {:severity => "notification"}.merge(options))
+  end
+
+  def self.warn!(options)
+    self.raise_alert(nil, options)
+  end
+
+  # Watch the yielded block for exceptions, and log one if it's raised.
+  def self.watch(options={})
+    begin
+      yield
+    rescue => e
+      raise_alert(e, options)
+    end
+  end
+
+  # Same as watch, but re-raises the exception after catching it.
+  def self.watch!(options={})
+    begin
+      yield
+    rescue => e
+      raise_alert(e, options)
+      raise e
+    end
+  end
+
+  # Determine the recipients per notification method for a particular alert.
+  def self.recipients(alert)
+    # Each recipient group should look like (where the filter values are regexps):
+    # - category: .*
+    # severity: (critical|high)
+    # recipients:
+    # - rnubel@test.com
+    # notifier: email
+    return {} unless config.recipient_groups
+
+    recipients_per_notifier = config.recipient_groups.inject({}) do |rec_lists, group|
+      if alert_matches_group(alert, group)
+        notifier = group[:notifier] || Tocsin::Notifiers.default_notifier
+        rec_lists[notifier] ||= []
+        rec_lists[notifier] += group[:recipients]
+      end
+
+      rec_lists
+    end
+
+    recipients_per_notifier.each do |k, v| v.uniq!; v.sort! end # Filter duplicates and sort for sanity
+  end
+
+  def self.configure
+    @config = nil
+    yield config
+  end
+
+  def self.config
+    @config ||= Tocsin::Config.new
+  end
+
+  def self.queue
+    @queue ||= config.queue
+  end
+
+  def self.logger
+    @logger ||= config.logger
+  end
+
+  # Job to notify admins via email of a problem.
+  class NotificationJob
+    @queue = Tocsin.queue
+
+    # Look up the given alert and notify recipients of it.
+    def self.perform(alert_id)
+      Tocsin.sound(alert_id)
+    rescue ActiveRecord::RecordNotFound
+      Tocsin.logger.error { "Raised alert with ID=#{alert_id} but couldn't find that alert." }
+    end
+
+  end
+
+  private
+
+  def self.sound(alert)
+    alert = Tocsin::Alert.find(alert) unless alert.is_a?(Tocsin::Alert)
+    recipients = Tocsin.recipients(alert)
+
+    recipients.each do |notifier_key, recipient_list|
+      notifier = Tocsin::Notifiers[notifier_key]
+
+      if notifier && recipient_list.any?
+        notifier.notify(recipient_list, alert)
+        Tocsin.logger.info { "Notification sent to #{recipient_list.inspect} via #{notifier_key} for alert #{alert.id}." }
+      elsif recipient_list.empty?
+        Tocsin.logger.error { "No recipients associated with alert: \n #{alert.inspect}" }
+      elsif notifier.nil?
+        Tocsin.logger.error { "Raised alert with ID=#{alert.id} for unregistered notifier '#{notifier_key}'." }
+      end
+    end
+  end
+
+  def self.alert_for(exception, options = {})
+    alert = Tocsin::Alert.create(
+      :exception => exception && exception.to_s,
+      :backtrace => exception && exception.backtrace.join("\n"),
+      :severity => options[:severity].to_s || "",
+      :message => options[:message].to_s || "",
+      :category => options[:category].to_s || "uncategorized"
+    )
+  end
+
+  def self.queue(alert)
+    alert = Tocsin::Alert.find(alert) unless alert.is_a?(Tocsin::Alert)
+    Resque.enqueue(NotificationJob, alert.id)
+  end
+
+  def self.cannot_enqueue_alert(exception=nil)
+    logger.error "[Tocsin] Enqueuing alert job into Resque failed!"
+    alert_for exception, :severity => "critical",
+                         :message => "[Tocsin] Enqueuing alert job into Resque failed!",
+                         :category => "system"
+  end
+
+  def self.alert_matches_group(alert, group)
+    alert.category =~ Regexp.new(group[:category] || '.*') && 
+    alert.severity =~ Regexp.new(group[:severity] || '.*')
+  end
+end

data/lib/tocsin/config.rb

@@ -0,0 +1,32 @@
+module Tocsin
+  class Config
+    attr_accessor :logger, :queue, :recipient_groups, :from_address
+
+    # notify [r1, r2], :of => filters, :by => notifier 
+    def notify(recipients, parameters)
+      self.recipient_groups ||= []
+
+      recipients = [recipients] unless recipients.is_a? Array
+      filters   = parameters[:of] || {}
+      notifier  = parameters[:by] || Tocsin::Notifiers.default_notifier
+
+      group_config = { :recipients  => recipients,
+                       :notifier    => notifier}.merge(filters)
+      self.recipient_groups.push(group_config)
+    end
+
+    def queue
+      @queue ||= :high
+    end
+
+    def logger
+      @logger ||= Rails.logger
+    rescue NameError, NoMethodError => e
+      ok =  [ /^uninitialized constant .*Rails$/,
+              /^undefined method `logger'/
+            ].any?{|regex| e.message =~ regex }
+      raise unless ok
+      @logger ||= Logger.new($stderr)
+    end
+  end
+end

data/lib/tocsin/notifiers.rb

@@ -0,0 +1,23 @@
+module Tocsin
+  module Notifiers
+    def self.default_notifier
+      :email
+    end
+    
+    def self.notifiers
+      @notifiers ||= {}
+    end
+
+    def self.register!(key, notifier)
+      notifiers.store(key, notifier)
+    end
+
+    def self.[](key)
+      notifiers[key]
+    end
+  end
+end
+
+Dir[File.expand_path("../notifiers/*.rb", __FILE__)].each do |f|
+  require f
+end

data/lib/tocsin/notifiers/email_notifier.rb

@@ -0,0 +1,30 @@
+require 'mail'
+
+module Tocsin
+  module Notifiers
+    class EmailNotifier
+      def self.notify(recipients, alert)
+        _body = "
+Alert raised by Tocsin on your site:
+\n
+Message: #{alert.message}
+Category: #{alert.category}
+Severity: #{alert.severity}
+Exception: #{alert.exception}
+Backtrace: #{alert.backtrace}
+        ";
+
+        from_address = Tocsin.config.from_address || recipients.first
+
+        Mail.deliver do
+          from    from_address
+          to      recipients.join(", ")
+          subject "[Tocsin] [#{alert.severity}] #{alert.message} (#{alert.category})"
+          body    _body
+        end
+      end
+    end
+
+    register! :email, EmailNotifier
+  end
+end

data/lib/tocsin/rake.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'tocsin'))
+
+namespace :tocsin do
+  desc "Generate Tocsin::Alert model & migration"
+  task :generate do
+    if defined?(Rails)
+      puts `rails g model Tocsin::Alert exception:string message:string category:string severity:string backtrace:string --no-test-framework --skip`
+      puts "Run rake db:migrate to finish installation."
+    else
+      puts "Not using rails. Please create Tocsin::Alert manually"
+    end
+  end
+end

data/lib/tocsin/version.rb

@@ -0,0 +1,3 @@
+module Tocsin
+  VERSION = "0.1.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+require File.expand_path("../../lib/tocsin", __FILE__)
+
+RSpec.configure do |c|
+  c.mock_with :mocha
+end
+
+Mail.defaults do
+  delivery_method :test
+end
+
+class Tocsin::Alert
+  def id
+    1
+  end
+
+  def category
+  end
+
+  def severity
+  end
+
+  def self.create(*args)
+    self.new
+  end
+
+  def self.find(*args)
+    self.new
+  end
+
+  def self.logger
+    @logger ||= Logger.new($stdout)
+  end
+end
+
+class Resque
+  def self.enqueue(*args)
+  end
+end

data/spec/tocsin/notifiers/email_notifier_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Tocsin::Notifiers::EmailNotifier do
+  let(:alert) {
+    stub("Tocsin::Alert", :id => 1, :category => 'category', :severity => 'severity',
+                          :message => 'message', :exception => 'exception',
+                          :backtrace => 'backtrace')
+  }
+
+  describe "notifying" do
+    let(:origin_email) { "test@test.com" }
+
+    before {
+      Tocsin.configure do |c|
+        c.from_address = "test@test.com"
+      end
+    }
+
+    it "uses the Mail gem to send an alert" do
+      described_class.notify(["a@b.com"], alert)
+    end
+
+    describe "the sent email" do
+      let(:message) { Mail::TestMailer.deliveries.first }
+      let(:body) { message.body.decoded }
+
+      it "was sent" do
+        message.should_not be_nil
+      end
+
+      it "has a subject including the alert's message, severity and category" do
+        message.subject.should == "[Tocsin] [severity] message (category)"
+      end
+
+      it "has a body including all fields" do
+        body.should =~ /severity/
+        body.should =~ /message/
+        body.should =~ /category/
+        body.should =~ /exception/
+        body.should =~ /backtrace/
+      end
+
+      it "is from the configured origin email" do
+        message.from.should == [origin_email]
+      end
+    end
+  end
+
+  it "registers itself under the key :email" do
+    Tocsin::Notifiers[:email].should == described_class
+  end
+end

data/spec/tocsin/notifiers_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+# Fixture for testing notifiers.
+class DummyNotifier
+
+end
+
+describe Tocsin::Notifiers do
+  context "after a notifier has been registered with a key" do
+    before {
+      Tocsin::Notifiers.register! :dummy, DummyNotifier
+    }
+
+    it "can retrieve the notifier based on that key" do
+      Tocsin::Notifiers[:dummy].should == DummyNotifier
+    end
+  end
+end

data/spec/tocsin_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+
+describe Tocsin do
+  let(:alert_options) do
+    { :severity => :critical,
+      :message => "Raised by someone",
+      :category => :real_important_job   }
+  end
+
+  let(:recipient_groups) do
+    [ {:category => /.*/, :severity => /.*/, :recipients => ["x@y.com", "z@w.com"]},
+      {:category => /^test$/, :severity => /(high|low)/, :recipients => ["a@b.com", "z@w.com"], :notifier => :email},
+      {:category => /^test$/, :severity => /(high|low)/, :recipients => ["1234567890"], :notifier => :text_message}
+    ]
+  end
+
+  before do
+    Tocsin.configure do |c|
+      c.recipient_groups = recipient_groups
+      c.logger = Logger.new('/dev/null')
+    end
+  end
+
+  context "when an exception has already been rescued" do
+    it "raises an alert" do
+      Tocsin::Alert.expects(:create).returns(stub("alert", :id => 1))
+
+      begin
+        raise "Testing"
+      rescue => e
+        Tocsin.raise_alert(e, alert_options)
+      end
+    end
+  end
+
+  context "when considering a block of code which explodes" do
+    it "provides a watch method which raises an alert silently" do
+      Tocsin.expects(:raise_alert).with(is_a(Exception), has_entries(alert_options))
+
+      lambda {
+        Tocsin.watch(alert_options) do
+          raise "Testing"
+        end
+      }.should_not raise_error
+    end
+
+    it "provides a watch! method which both send an alert and re-raises the exception" do
+      Tocsin.expects(:raise_alert).with(is_a(Exception), has_entries(alert_options))
+
+      lambda {
+        Tocsin.watch!(alert_options) do
+          raise "Testing"
+        end
+      }.should raise_error
+    end
+  end
+
+  describe "being configured" do
+    it "wipes old configuration" do
+      Tocsin.configure do |c|
+        c.recipient_groups = []
+      end
+
+      Tocsin.configure { }
+      Tocsin.config.recipient_groups.should be_nil
+    end
+
+    describe "#recipient_groups=" do
+      it "can set the list of recipient groups directly" do
+        Tocsin.configure do |c|
+          c.recipient_groups = recipient_groups
+        end
+
+        Tocsin.config.recipient_groups.should == recipient_groups
+      end
+    end
+
+    describe "#notify" do
+      it "can create a notification group idiomatically" do
+        Tocsin.configure do |c|
+          c.notify ["rnubel@test.com"], :of => { :severity => /critical/ }, :by => :email
+        end
+
+        Tocsin.config.recipient_groups.should == [
+          { :severity => /critical/, :recipients => ["rnubel@test.com"], :notifier => :email }
+        ]
+      end
+
+      it "assumes email as the default notifier if not specified" do
+        Tocsin.configure do |c|
+          c.notify ["rnubel@test.com"], :of => { :severity => /critical/ }
+        end
+
+        Tocsin.config.recipient_groups.should == [
+          { :severity => /critical/, :recipients => ["rnubel@test.com"], :notifier => :email }
+        ]
+      end
+
+      it "converts a single recipient into an array of that single recipient" do
+        Tocsin.configure do |c|
+          c.notify "rnubel@test.com", :of => { :severity => /critical/ }, :by => :email
+        end
+
+        Tocsin.config.recipient_groups.should == [
+          { :severity => /critical/, :recipients => ["rnubel@test.com"], :notifier => :email }
+        ]
+      end
+
+      it 'has a default queue' do
+        Tocsin.configure { }
+        Tocsin.config.queue.should_not be_nil
+      end
+
+      it 'can be confgiured with a default from_address' do
+        Tocsin.configure do |c|
+          c.from_address = "webdude@example.net"
+        end
+        Tocsin.config.from_address.should == "webdude@example.net"
+      end
+    end
+  end
+
+  context "deciding what recipients apply to a given alert" do
+    context "when given a pattern matching only one group" do
+      it "returns the group in a hash with the notifier as the key" do
+        Tocsin.recipients(stub('alert', :category => "whee", :severity => "test")).should == { :email => ["x@y.com", "z@w.com"] }
+      end
+    end
+
+    it "should merge all groups which match the pattern" do
+      Tocsin.recipients(stub('alert', :category => "test", :severity => "high")).should == { :email => ["a@b.com", "x@y.com", "z@w.com"],
+                                                                                             :text_message => ["1234567890"] }
+    end
+  end
+
+  describe "synoynms for ::raise_alert" do
+    describe "::notify" do
+      it "calls raise_alert with notification as the default severity" do
+        Tocsin.expects(:raise_alert).with(nil, has_entries(:severity => "notification"))
+        Tocsin.notify({})
+      end
+    end
+
+    describe "::warn!" do
+      it "calls raise_alert with the same options as passed" do
+        opts = mock("options")
+        Tocsin.expects(:raise_alert).with(nil, opts)
+        Tocsin.warn!(opts)
+      end
+    end
+  end
+
+  context "when raising an alarm" do
+    let(:exception) do
+      begin
+        raise "Exception"
+      rescue => e
+        e
+      end
+    end
+
+    let(:alert) do
+      Tocsin.raise_alert(exception, alert_options)
+    end
+
+    describe "the created Tocsin::Alert object" do
+      it "is created with appropriate fields" do
+        Tocsin::Alert.expects(:create).with(has_entries(
+          :exception  =>  exception.to_s,
+          :backtrace  =>  exception.backtrace.join("\n"),
+          :severity   =>  alert_options[:severity].to_s,
+          :message    =>  alert_options[:message].to_s,
+          :category   =>  alert_options[:category].to_s
+        )).returns(stub("alert", :id => 1))
+        alert
+      end
+    end
+
+    it "should enqueue a notification job in Resque by default" do
+      Resque.expects(:enqueue).with(Tocsin::NotificationJob, is_a(Integer))
+      Tocsin.expects(:sound).never
+      alert
+    end
+
+    it "should sound an alert immediately when asked" do
+      Resque.expects(:enqueue).never
+      Tocsin.expects(:sound).once
+      alert_options[:urgent] = true
+      alert
+    end
+
+    it "does not explode if Resque.enqueue fails" do
+      Resque.expects(:enqueue).raises("Blah")
+
+      ## once for the original alert, once for queuing failure
+      Tocsin.expects(:sound).twice
+
+      expect { alert }.to_not raise_error
+    end
+
+  end
+
+  describe Tocsin::NotificationJob do
+    let(:alert) { stub("alert", :id => 5, :category => "test", :severity => "test", :message => "test", :exception => nil, :backtrace => nil) }
+    before { Mail::TestMailer.deliveries.clear }
+
+    it "locates the alert by id" do
+      Tocsin::Alert.expects(:find).with(5).returns(alert)
+      Tocsin::NotificationJob.perform(5)
+    end
+
+    it "uses the associated notifier to alert recipients" do
+      Tocsin::Alert.expects(:find).with(5).returns(alert)
+      Tocsin.expects(:recipients).with(alert).returns( :email => ["a@b.com"] )
+      Tocsin::Notifiers[:email].expects(:notify).with(["a@b.com"], alert)
+      Tocsin::NotificationJob.perform(5)
+    end
+
+    it 'will use the first email address as the sender when from_address is not present' do
+      Tocsin::Alert.expects(:find).with(5).returns(alert)
+      Tocsin.expects(:recipients).with(alert).returns( :email => ["a@b.com", "x@y.com"] )
+      Tocsin::NotificationJob.perform(5)
+
+      em = Mail::TestMailer.deliveries.first
+      em.from.should include("a@b.com")
+    end
+
+    it "should log an error for an unknown notifier" do
+      Tocsin::Alert.expects(:find).with(5).returns(alert)
+      Tocsin.expects(:recipients).returns({:raven => "Cersei"})
+      Tocsin.logger.expects(:error)
+      Tocsin::NotificationJob.perform(5)
+    end
+
+    context "empty recipient list" do
+      before do
+        Tocsin::Alert.expects(:find).with(5).returns(alert)
+        Tocsin.expects(:recipients).returns({:email => []})
+      end
+
+      after { Tocsin::NotificationJob.perform(5) }
+
+      it "should not attempt notification" do
+        Tocsin::Notifiers[:email].expects(:notify).never
+      end
+
+      it "should log an error" do
+        Tocsin.logger.expects(:error)
+      end
+    end
+
+    it "should not raise an exception if the alert isn't found (otherwise, possible recursion)" do
+      Tocsin::Alert.expects(:find).with(5).raises(ActiveRecord::RecordNotFound)
+      lambda {
+        Tocsin::NotificationJob.perform(5)
+      }.should_not raise_error
+    end
+  end
+end

data/tocsin.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tocsin/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tocsin"
+  s.version     = Tocsin::VERSION
+  s.authors     = ["Robert Nubel","Blake Thomas"]
+  s.email       = ["tocsin.gem@gmail.com"]
+  s.homepage    = "https://github.com/tocsin/tocsin"
+  s.summary     = %q{Notification and alert library for Rails-like projects.}
+  s.description = %q{Supports wrapping code that you want to be alerted of failures in, as well as sending notifications through the same mechanism.}
+
+  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"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "mocha"
+
+  s.add_runtime_dependency "rails", ">= 3.0.0"
+  s.add_runtime_dependency "resque"
+  s.add_runtime_dependency "mail"
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: tocsin
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Robert Nubel
+- Blake Thomas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-09 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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mail
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Supports wrapping code that you want to be alerted of failures in, as
+  well as sending notifications through the same mechanism.
+email:
+- tocsin.gem@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/tocsin.rb
+- lib/tocsin/config.rb
+- lib/tocsin/notifiers.rb
+- lib/tocsin/notifiers/email_notifier.rb
+- lib/tocsin/rake.rb
+- lib/tocsin/version.rb
+- spec/spec_helper.rb
+- spec/tocsin/notifiers/email_notifier_spec.rb
+- spec/tocsin/notifiers_spec.rb
+- spec/tocsin_spec.rb
+- tocsin.gemspec
+homepage: https://github.com/tocsin/tocsin
+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: Notification and alert library for Rails-like projects.
+test_files:
+- spec/spec_helper.rb
+- spec/tocsin/notifiers/email_notifier_spec.rb
+- spec/tocsin/notifiers_spec.rb
+- spec/tocsin_spec.rb
+has_rdoc: