babysitter 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+.rvmrc
+.rspec
+*.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 babysitter.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Lonely Planet Online
+
+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,88 @@
+# Babysitter
+
+A ruby gem that uses [Fozzie](http://github.com/lonelyplanet/fozzie) to report progress on long-running tasks.
+When provided with a Logger it will output statistics of progress to the logs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem "babysitter"
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install babysitter
+
+## Use
+
+
+### Configuration
+
+    Babysitter.configure do |c|
+      c.logger = MyApp.logger
+    end
+
+The default logger does nothing, override if you want to see log output.
+
+### Amazon Simple Notification Service Integration
+
+Babysitter can also make use of Amazons Simple Notification Service to provide notifications of when exceptions occur.
+
+    Babysitter.configure do |c|
+      c.enable_simple_notification_service(
+        topic_arn: "my-topic-arn",
+        credentials: -> { 
+          access_key_id: "YOUR_ACCESS_KEY_ID",
+          secret_address_key: "YOUR_SECRET_ADDRESS_KEY",
+        }
+      )
+    end
+
+The credentials should be supplied as a Proc so that they are only requested when they are required. This supports the use of temporary
+credentials with IAM and prevents any credentials fetched at configuration time having expired at some point later when an error occurs.
+
+### Monitoring
+
+    monitor = Babysitter.monitor("statsd.bucket.name")
+    monitor.start("Workername: description") do |tracker|
+       things_to_do.each do |work|
+          do_some work
+          tracker.error(:badness,'Something bad happened') if something_bad?
+          tracker.warn(:suspicions,'Something supicious happenedd') if something_bad?
+          tracker.inc("Workername: {{count}} tasks completed", 1, counting: :things_to_do) # report progress here
+       end
+    end
+
+
+This will send statistics to StatsD in the supplied bucket name and will generate logs like this:
+
+
+    INFO -- : Start: statsd.bucket.name Matcher generating possible combinations
+    INFO -- : Done:  100 combinations generated
+    INFO -- : Rate:  20746.88796680498 combinations per second
+    INFO -- : End:   statsd.bucket.name 
+
+Logging statistics will incremented for bucket names
+
+    statsd.bucket.name.badness.errors
+    statsd.bucket.name.suspicions.warnings
+
+
+Any exceptions that occur will be logged nicely. Exceptions will abort the process.
+
+## Development
+
+    $ git clone git@github.com:lonelyplanet/babysitter.git
+    $ cd babysitter
+
+## 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

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/babysitter.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'babysitter/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "babysitter"
+  gem.version       = Babysitter::VERSION
+  gem.authors       = ["Nicolas Overloop", "Paul Grayson", "Andy Roberts", "Mike Wagg"]
+  gem.email         = ["noverloop@gmail.com", "paul.grayson@lonelyplanet.com", "coder@onesandthrees.com", "michael@guerillatactics.co.uk"]
+  gem.description   = %q{Babysits long-running processes and reports progress or failures}
+  gem.summary       = %q{Babysits long-running processes and reports progress or failures}
+  gem.homepage      = ""
+
+  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_dependency 'fozzie'
+  gem.add_dependency 'timecop'
+  gem.add_dependency 'aws-sdk'
+
+  gem.add_development_dependency 'awesome_print'
+  gem.add_development_dependency 'rspec'
+
+end

data/lib/babysitter.rb

@@ -0,0 +1,36 @@
+
+
+require_relative "babysitter/version"
+require_relative "babysitter/null_logger"
+require_relative "babysitter/configuration"
+require_relative "babysitter/logging"
+require_relative "babysitter/logger_with_stats"
+require_relative "babysitter/tracker"
+require_relative "babysitter/monitor"
+require_relative "babysitter/counter"
+require_relative "babysitter/exception_notifiers"
+require 'fozzie'
+
+module Babysitter
+
+  def self.monitor(*args)
+    Monitor.new(*args)
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+  def self.logger
+    configuration.logger
+  end
+
+  def self.exception_notifiers
+    configuration.exception_notifiers
+  end
+
+end

data/lib/babysitter/configuration.rb

@@ -0,0 +1,22 @@
+module Babysitter
+
+  class Configuration
+
+    attr_writer :logger
+    attr_reader :exception_notifiers
+
+    def initialize
+      @exception_notifiers = []
+    end
+
+    def logger
+      @logger ||= NullLogger.new
+    end
+
+    def enable_simple_notification_service(opts = {})
+      @exception_notifiers << ExceptionNotifiers::SimpleNotificationService.new(opts)
+    end
+
+  end
+
+end

data/lib/babysitter/counter.rb

@@ -0,0 +1,60 @@
+module Babysitter
+  class Counter
+    include Logging
+
+    attr_reader :count, :log_every, :template, :logged_count, :stat_name, :counting
+
+    attr_accessor :template
+
+    def initialize(log_every, opts)
+      @count = 0
+      @logged_count = 0
+      @log_every = log_every
+      @stat_name = opts.delete(:stat_name)
+      @counting = opts.delete(:counting)
+      @timer_start = Time.now
+    end
+
+    def inc( template, amount=1, opts={} )
+      @template = template
+      new_counting = opts.delete(:counting)
+      @counting = new_counting unless new_counting.nil?
+      log_this_time = block_number(@count) != block_number(@count + amount)
+      @count += amount
+      log_counter_messsage if log_this_time
+    end
+
+    def block_number(count)
+      count / @log_every
+    end
+
+    def final_report?
+      !(template.nil? or template.empty?) && count != logged_count
+    end
+
+    def log_counter_messsage
+      logger.info( "Done:  #{template.gsub("{{count}}", count.to_s)}" )
+      send_progress_stats(count - logged_count)
+
+      rate = (count - logged_count).to_f / (Time.now - @timer_start)
+      logger.info( "Rate:  #{rate} #{counting} per second" )
+      send_rate_stats(rate)
+
+      @logged_count = count
+      @timer_start = Time.now
+    end
+
+    def send_rate_stats(rate)
+      Stats.gauge stat_name+[counting, :rate], rate unless stat_name.nil?
+    end
+
+    def send_progress_stats(progress)
+      Stats.count stat_name+[counting, :progress], progress unless stat_name.nil?
+    end
+
+    def send_total_stats
+      Stats.gauge stat_name+[counting, :total], count
+    end
+
+  end
+end

data/lib/babysitter/exception_notifiers.rb

@@ -0,0 +1 @@
+require_relative "exception_notifiers/simple_notification_service"

data/lib/babysitter/exception_notifiers/simple_notification_service.rb

@@ -0,0 +1,42 @@
+require 'aws-sdk'
+
+module Babysitter
+  module ExceptionNotifiers
+    class SimpleNotificationService
+      def initialize(opts = {})
+        @topic_arn = opts.delete(:topic_arn)
+        @get_credentials = opts.delete(:credentials)
+        raise ArgumentError, "topic_arn is required." if @topic_arn.nil?
+        raise ArgumentError, "credentials is required and must be a Proc." if @get_credentials.nil? || !@get_credentials.is_a?(Proc)
+
+        validate_topic
+      end
+
+      def notify(subject, msg)
+        topic.publish(msg, subject: sanitise_subject(subject))
+      end
+
+      private
+
+      def sns
+        AWS::SNS.new(@get_credentials.call)
+      end
+
+      def topic
+        sns.topics[@topic_arn]
+      end
+
+      def sanitise_subject(subject)
+        sanitised = /\s*([^\x00-\x1F]*)/.match(subject)[1]
+
+        return "(no subject)" if sanitised.empty?
+        return sanitised[0..96] + "..." if sanitised.size > 100
+        sanitised
+      end
+
+      def validate_topic
+        topic.display_name
+      end
+    end
+  end
+end

data/lib/babysitter/logger_with_stats.rb

@@ -0,0 +1,43 @@
+module Babysitter
+  class LoggerWithStats
+    include Logging
+
+    attr_accessor :stat_name_prefix
+
+    STATS_SUFFIX_BY_METHOD = { warn: :warnings, error: :errors, fatal: :fatals }
+
+    def initialize(stat_name_prefix) 
+      @stat_name_prefix = stat_name_prefix 
+    end
+
+    def method_missing(meth, *opts)
+      unless %w{ info debug error fatal}.include?(meth.to_s)
+        super
+        return
+      end
+      stats_suffix_from_method(meth).tap{ |suffix| increment(suffix) if suffix }
+      logger.send(meth, *opts)
+    end
+
+    def warn(*opts)
+      increment(stats_suffix_from_method(:warn))
+      logger.warn(*opts)
+    end
+
+    private
+
+    def stats_suffix_from_method(meth)
+      STATS_SUFFIX_BY_METHOD[meth]
+    end
+
+    def increment(stat_name_suffix)
+      Stats.increment full_stat_name(stat_name_suffix)
+    end
+
+    def full_stat_name(stat_name_suffix)
+      stat_name_prefix + [stat_name_suffix]
+    end
+
+  end
+
+end

data/lib/babysitter/logging.rb

@@ -0,0 +1,9 @@
+module Babysitter
+  module Logging
+
+    def logger
+      Babysitter.logger
+    end
+
+  end
+end

data/lib/babysitter/monitor.rb

@@ -0,0 +1,57 @@
+module Babysitter
+  class Monitor
+    include Logging
+
+    attr_accessor :stat_name
+
+    def initialize(stat_name=nil)
+      @stat_name = convert_stat_name_to_array(stat_name)
+    end
+
+    def start(msg=nil, log_every=100, &blk)
+      raise ArgumentError, "Stats bucket name must not be blank" if stat_name.nil? or stat_name.empty?
+      log_msg = format_log_message(msg)
+      tracker = Tracker.new(log_every, stat_name)
+      logger.info "Start: #{log_msg}"
+
+      begin
+        result = Stats.time_to_do stat_name+[:overall] do
+          blk.call(tracker)
+        end
+      rescue Exception => e
+        tracker.final_report rescue nil
+        log_exception_details(log_msg, e)
+        raise
+      end
+
+      tracker.send_total_stats
+      tracker.final_report
+      logger.info "End:   #{log_msg}"
+      result
+    end
+
+    def completed(msg)
+      logger.info "Done:  #{msg}"
+    end
+
+    private
+
+    def format_log_message(msg)
+      log_msg = stat_name.join('.')
+      [log_msg,msg].compact.join(' ')
+    end
+
+    def convert_stat_name_to_array(stat_name)
+      stat_name.is_a?(Array) ? stat_name : stat_name.split('.') unless stat_name.nil? or stat_name.empty?
+    end
+
+    def log_exception_details(msg, exception)
+      lines = ["Aborting: #{msg} due to exception #{exception.class}: #{exception}"]
+      lines.concat(exception.backtrace) if exception.backtrace
+
+      lines.each { |line| logger.error(line) }
+      Babysitter.exception_notifiers.each { |notifier| notifier.notify(exception.class.name, lines.join("\n")) }
+    end
+  end
+
+end

data/lib/babysitter/null_logger.rb

@@ -0,0 +1,11 @@
+module Babysitter
+
+  class NullLogger
+
+    def method_missing( *args )
+      self
+    end
+
+  end
+
+end

data/lib/babysitter/tracker.rb

@@ -0,0 +1,52 @@
+module Babysitter
+  class Tracker
+    include Logging
+
+    attr_reader :counting, :stat_name, :counter
+    attr_accessor :log_every
+
+    def initialize(log_every, stat_name=nil)
+      @stat_name = stat_name
+      @counting = :iterations
+      @log_every = log_every
+      @counter = Counter.new(log_every, stat_name: stat_name, counting: counting)
+    end
+
+    def inc(*args)
+      counter.inc(*args)
+    end
+
+    def count
+      counter.count
+    end
+
+    def final_report
+      counter.log_counter_messsage if counter.final_report?
+    end
+
+    def warn(topic_name, message)
+      logger_with_stats_for(topic_name).warn(message)
+    end
+
+    def error(topic_name, message)
+      logger_with_stats_for(topic_name).error(message)
+    end
+
+    def send_total_stats
+      counter.send_total_stats
+    end
+
+    def logger_with_stats_for(topic_name)
+      @loggers ||= {}
+      @loggers[topic_name] ||= LoggerWithStats.new(stats_prefix_for_topic(topic_name))
+    end
+
+    private
+
+    def stats_prefix_for_topic(topic_name)
+      stat_name+[topic_name] 
+    end
+
+  end
+
+end

data/lib/babysitter/version.rb

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

data/spec/lib/babysitter/configuration_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Babysitter
+  describe Configuration do
+    context 'when initialized' do
+
+      let (:null_logger) { double( 'null logger' ) }
+
+      it 'has a default logger set to a new NullLogger' do
+        NullLogger.should_receive(:new).and_return( null_logger )
+        subject.logger.should === null_logger
+      end
+
+      it 'has no exception notifiers' do
+        subject.exception_notifiers.should be_empty
+      end
+
+    end
+
+    describe 'enabling Amazon simple notification service integration' do
+      let (:sns_exception_notifier) { double }
+      let (:valid_params) { { 
+        arbritary_key: "some-value",
+        topic_arn: "my-topic-arn" 
+      } }
+
+      before :each do
+        Babysitter::ExceptionNotifiers::SimpleNotificationService.stub(:new).and_return(sns_exception_notifier)
+      end
+
+      it 'adds an exception notifier' do
+        subject.enable_simple_notification_service(valid_params)
+
+        subject.exception_notifiers.should_not be_empty
+        subject.exception_notifiers.first.should eql(sns_exception_notifier)
+      end
+
+      it 'configures the exception notifier' do
+        ExceptionNotifiers::SimpleNotificationService.should_receive(:new).with(hash_including(valid_params))
+
+        subject.enable_simple_notification_service(valid_params)
+      end
+    end
+
+  end
+end

data/spec/lib/babysitter/exception_notifiers/simple_notification_service_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+module Babysitter
+  module ExceptionNotifiers
+    describe SimpleNotificationService do
+      subject { SimpleNotificationService.new(valid_opts) }
+      let(:get_credentials_lambda) { -> {
+        {
+          access_key_id: 'an-access-key-id',
+          secret_access_key: 'a-secret-address-key',
+        }
+      } }
+      let(:valid_opts) { {
+        credentials: get_credentials_lambda,
+        topic_arn: 'my-topic-arn'
+      } }
+      let(:sns) { double :sns, topics: { 'my-topic-arn' => topic } }
+      let(:topic) { double :topic, publish: nil, display_name: "A topic" }
+      before :each do
+        AWS::SNS.stub(:new).and_return(sns)
+      end
+
+      it 'requires a topic_arn' do
+        valid_opts.delete :topic_arn
+        -> { subject }.should raise_error(ArgumentError, /topic_arn/)
+      end
+
+      it "requires credentials" do
+        valid_opts.delete :credentials
+        -> { subject }.should raise_error(ArgumentError, /credentials/)
+      end
+
+      it 'requires a block to retrieve AWS credentials' do
+        valid_opts[:credentials] = {}
+        -> { subject }.should raise_error(ArgumentError, /credentials/)
+      end
+
+      it 'uses the options passed to configure the credentials for sns' do
+        AWS::SNS.should_receive(:new).with(get_credentials_lambda.call)
+        subject
+      end
+
+      it 'validates the topic by checking it has a display name' do
+        topic.should_receive(:display_name)
+        subject
+      end
+
+      describe '.notify' do
+        let(:message) { "the message" }
+        let(:notification_subject) { "the subject" }
+
+        it 'again uses the options passed to configure the credentials for sns' do
+          AWS::SNS.should_receive(:new).with(get_credentials_lambda.call).twice
+          subject.notify(notification_subject, message)
+        end
+
+        it 'publishes to the topic specified' do
+          topic.should_receive(:publish)
+
+          subject.notify(notification_subject, message)
+        end
+
+        it 'publishes the message' do
+          topic.should_receive(:publish).with(message, hash_including(subject: notification_subject))
+
+          subject.notify(notification_subject, message)
+        end
+
+        it "shortens the subject to 100 characters if necessary" do
+          shortened_subject = 97.times.map { "x" }.join + "..."
+          original_subject = 101.times.map { "x" }.join
+
+          topic.should_receive(:publish).with(message, hash_including(subject: shortened_subject))
+
+          subject.notify(original_subject, message)
+        end
+
+        it "strips control characters" do
+          expected_subject = "this is the subject"
+          original_subject = "#{expected_subject}"
+          32.times.each { |code| original_subject << code.chr }
+
+          topic.should_receive(:publish).with(message, hash_including(subject: expected_subject))
+
+          subject.notify(original_subject, message)
+        end
+
+        it "strips leading whitespace" do
+          expected_subject = "this is the subject"
+          original_subject = "  #{expected_subject}"
+
+          topic.should_receive(:publish).with(message, hash_including(subject: expected_subject))
+
+          subject.notify(original_subject, message)
+        end
+
+        it "handles empty subject" do
+          topic.should_receive(:publish).with(message, hash_including(subject: "(no subject)"))
+
+          subject.notify("", message)
+        end
+      end
+    end
+  end
+end

data/spec/lib/babysitter/monitor_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+module Babysitter
+  describe Monitor do
+    before(:each) do
+      Stats.stub!(:count).with(anything, anything)
+      Stats.stub!(:gauge).with(anything, anything)
+    end
+
+    context 'when initialized with a dot separated bucket name' do
+
+      subject{ Monitor.new(bucket_name) }
+      let(:bucket_name) { 'my.splendid.bucket.name' }
+      let(:start_block) { Proc.new{ block_result } }
+      let(:block_result) { double('block result').as_null_object }
+      let(:logger)       { double('logger').as_null_object }
+
+      describe '#completed' do
+        it 'logs a done message' do
+          Monitor.any_instance.stub(:logger).and_return(logger)
+          logger.should_receive(:info).with("Done:  the completed thing")
+          subject.completed('the completed thing')
+        end
+      end
+
+      describe '#start' do
+
+        it 'yields to the block, returning the result' do
+          subject.start(&start_block).should === block_result
+        end
+
+        it 'calls Stats.time_to_do with the bucket name' do
+          expected_stat = bucket_name.split('.')+[:overall]
+          Stats.should_receive(:time_to_do).with(expected_stat)
+          subject.start(&start_block)
+        end
+
+        it 'calls logger.info with start message' do
+          Monitor.any_instance.stub(:logger).and_return(logger)
+          logger.should_receive(:info).with("Start: #{bucket_name}")
+          subject.start(&start_block)
+        end
+
+        it 'calls logger.info with end message' do
+          Monitor.any_instance.stub(:logger).and_return(logger)
+          logger.should_receive(:info).with("End:   #{bucket_name}")
+          subject.start(&start_block)
+        end
+
+        context 'when the start method is given a message' do
+          it 'calls logger.info with start message' do
+            Monitor.any_instance.stub(:logger).and_return(logger)
+            logger.should_receive(:info).with("Start: #{bucket_name} special message")
+            subject.start('special message', &start_block)
+          end
+
+          it 'calls logger.info with end message' do
+            Monitor.any_instance.stub(:logger).and_return(logger)
+            logger.should_receive(:info).with("End:   #{bucket_name} special message")
+            subject.start('special message', &start_block)
+          end
+        end
+
+        context 'when the block increments the counter twice, each with a count of 5, and identifies counted objects' do
+          let(:start_block_two_increments) do
+            Proc.new do |counter|
+              2.times{ counter.inc('incrementing by {{count}} things', 5, counting: :things) }
+            end
+          end
+
+          it 'calls Stats.count with bucket name plus counted objects, and a count of 10' do
+            expected_bucket_name = bucket_name.split('.') + [:things, :total]
+            Stats.should_receive(:gauge).with(expected_bucket_name, 10)
+            subject.start(&start_block_two_increments)
+          end
+
+          it 'calls logger.info with each done message once' do
+            Counter.any_instance.stub(:logger).and_return(logger)
+            [5,10].each { |inc| logger.should_receive(:info).with( "Done:  incrementing by #{inc} things").once }
+            subject.start('short message', 5, &start_block_two_increments)
+          end
+        end # context 'when the block increments the counter twice, each with a count of 5, and identifies counted objects'
+
+        context 'when the block increments the counter 7 times, with no amount specified, and no name for counted objects' do
+          let(:start_block_seven_increments) do
+            Proc.new do |counter|
+              7.times{ counter.inc('incrementing by {{count}} things') }
+            end
+          end
+
+          it 'calls Stats.count with bucket name plus iterations, and a count of 7' do
+            expected_bucket_name = bucket_name.split('.') + [:iterations, :total]
+            Stats.should_receive(:gauge).with(expected_bucket_name, 7)
+            subject.start(&start_block_seven_increments)
+          end
+
+          it 'calls logger.info with each done message once' do
+            Counter.any_instance.stub(:logger).and_return(logger)
+            [5,7].each { |inc| logger.should_receive(:info).with( "Done:  incrementing by #{inc} things").once }
+            subject.start('short message', 5, &start_block_seven_increments)
+          end
+        end # context 'when the block increments the counter 7 times, with no amount specified, and no name for counted objects'
+
+        context 'when logging every 10th call, and the block increments the counter 7 times, each with a count of 9, and identifies counted objects' do
+          let(:start_block_three_increments) do
+            Proc.new do |counter|
+              7.times{ counter.inc('incrementing by {{count}} things', 9, counting: :things) }
+            end
+          end
+
+          it 'calls logger.info with increments 18,27,36,45,54,63' do
+            Counter.any_instance.stub(:logger).and_return(logger)
+            [18,27,36,45,54,63].each { |inc| logger.should_receive(:info).with( "Done:  incrementing by #{inc} things").once }
+            subject.start('short message', 10, &start_block_three_increments)
+          end
+        end # context 'when logging every 10th call, and the block increments the counter 7 times, each with a count of 9, and identifies counted objects' do
+
+        context "when the block logs a warning" do 
+          let(:start_block_with_warning) do
+            Proc.new do |monitor|
+              monitor.warn(:my_warning_bucket, 'my warning message')
+            end
+          end
+          before(:each) do
+            Babysitter.stub(:logger).and_return(logger)
+            logger.stub!(:warn)
+            Stats.stub!(:increment)
+          end
+
+          it 'calls logger.info with the warning message' do
+            logger.should_receive(:warn).with( "my warning message")
+            subject.start(&start_block_with_warning)
+          end
+
+          it 'calls Stats.count with warning bucket name' do
+            expected_bucket_name = bucket_name.split('.') + [:my_warning_bucket, :warnings]
+            Stats.should_receive(:increment).with(expected_bucket_name)
+            subject.start(&start_block_with_warning)
+          end
+        end
+
+        context "when the block logs an error" do 
+          let(:start_block_with_error) do
+            Proc.new do |monitor|
+              monitor.error(:my_error_bucket, 'my error message')
+            end
+          end
+          before(:each) do
+            Babysitter.stub(:logger).and_return(logger)
+            logger.stub!(:error)
+            Stats.stub!(:increment)
+          end
+
+          it 'calls logger.error with the error message' do
+            logger.should_receive(:error).with( "my error message")
+            subject.start(&start_block_with_error)
+          end
+
+          it 'calls Stats.count with error bucket name' do
+            expected_bucket_name = bucket_name.split('.') + [:my_error_bucket, :errors]
+            Stats.should_receive(:increment).with(expected_bucket_name)
+            subject.start(&start_block_with_error)
+          end
+        end
+
+        context 'when the block raises an error' do
+          let(:error) { RuntimeError.new(error_message) }
+          let(:backtrace) { 3.times.map { |i| "Line #{i}"} }
+          let(:error_message) { 'A big fat error' }
+          let(:expected_message) { "Aborting: #{bucket_name} due to exception RuntimeError: #{error_message}" }
+          let(:start_block_with_error) { Proc.new { raise error } }
+          before(:each) do
+            error.stub(:backtrace).and_return(backtrace)
+            Babysitter.stub(:logger).and_return(logger)
+            Babysitter.stub(:exception_notifiers).and_return(2.times.map { double notify: nil  })
+            logger.stub!(:error)
+            Stats.stub!(:increment)
+          end
+
+          it 'calls logger.error with the exeption details' do
+            logger.should_receive(:error).with(expected_message)
+            backtrace.each do |line|
+              logger.should_receive(:error).with(/\w*#{line}/)
+            end
+
+            begin
+              subject.start(&start_block_with_error)
+            rescue
+            end
+          end
+          
+          it 'calls each exception notifier with the exception details' do
+            message = [expected_message].concat(backtrace).join("\n")
+
+            Babysitter.exception_notifiers.each do |exception_notifier|
+              exception_notifier.should_receive(:notify).with('RuntimeError', message)
+            end
+
+            begin
+              subject.start(&start_block_with_error)
+            rescue
+            end
+          end
+        end
+
+        context 'when the block increments 2 times at intervals of 2 seconds' do
+          let(:start_block_for_timing) do
+            Proc.new do |counter|
+              2.times do
+                Timecop.travel(Time.now+2) # move on 2 seconds
+                counter.inc('doing increment',1)
+              end
+            end
+          end
+          before(:each) { Timecop.travel(Time.now) }
+          after(:each)  { Timecop.return           }
+
+          it 'calculates a rate close to 0.5 per second' do
+            Counter.any_instance.should_receive(:send_rate_stats) do |rate|
+              rate.should be_within(0.01).of(0.5)
+            end
+            subject.start(&start_block_for_timing)
+          end
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/lib/babysitter/tracker_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+module Babysitter
+  describe Tracker do
+
+    subject{ Tracker.new(log_interval, stat_bucket_prefix) }
+    let(:log_interval) { 5 }
+    let(:stat_bucket_prefix) { [:my, :stat, :bucket, :prefix] }
+    let(:logger) { double('boring old vanilla babysitter logger') }
+    before(:each) do
+      Babysitter.stub(:logger).and_return(logger)
+    end
+
+    describe '#logger_with_stats_for' do
+
+      it 'returns the same logger when passed the same symbol twice' do
+        l1 = subject.logger_with_stats_for(:lodgings)
+        l2 = subject.logger_with_stats_for(:lodgings)
+        l1.should be_equal(l2)
+      end
+
+      it 'returns different loggers when passed different symbols' do
+        l = subject.logger_with_stats_for(:lodgings)
+        p = subject.logger_with_stats_for(:places)
+        l.should_not be_equal(p)
+      end
+
+    end # describe '#logger_with_stats' do
+
+    describe 'logger returned by logger_with_stats_for(some_topic)' do
+      subject{ Tracker.new(log_interval, stat_bucket_prefix).logger_with_stats_for(some_topic) }
+      let(:some_topic) { :some_topic }
+      let(:text_of_the_message) {'the message we want in the logs'}
+
+      { warn: :warnings, error: :errors, fatal: :fatals }.each do |message_type, stats_bucket_suffix|
+        describe "##{message_type}" do
+          before(:each) do
+            logger.stub(message_type)
+            Stats.stub!(:increment)
+          end
+
+          it 'logs the message' do
+            logger.should_receive(message_type).with(text_of_the_message)
+            subject.send(message_type, text_of_the_message)
+          end
+
+          it 'sends the stats' do
+            expected_stats_bucket = stat_bucket_prefix + [some_topic, stats_bucket_suffix] 
+            Stats.should_receive(:increment).with(expected_stats_bucket) 
+            subject.send(message_type, text_of_the_message)
+          end
+        end
+
+      end
+
+      [:info, :debug].each do |message_type|
+        describe "##{message_type}" do
+          before(:each) do
+            logger.stub(message_type)
+            Stats.stub!(:increment)
+          end
+
+          it 'logs the message' do
+            logger.should_receive(message_type).with(text_of_the_message)
+            subject.send(message_type, text_of_the_message)
+          end
+
+          it 'sends no stats' do
+            Stats.should_not_receive(:increment)
+            subject.send(message_type, text_of_the_message)
+          end
+        end
+
+      end
+
+    end # describe 'logger returned by logger_with_stats_for(:something)' do
+
+  end
+end
+
+

data/spec/lib/babysitter_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Babysitter do
+
+  describe '.monitor' do
+    it 'returns an instance of Monitor' do
+      Babysitter.monitor.should be_an_instance_of(Babysitter::Monitor)
+    end
+  end
+
+  describe '.configuration' do
+    it 'returns an instance of Configuration' do
+      Babysitter.configuration.should be_an_instance_of(Babysitter::Configuration)
+    end
+
+    it 'returns the same instance every time' do
+      c = Babysitter.configuration
+      Babysitter.configuration.should eql(c)
+    end
+  end
+
+  describe '.configure' do
+    describe 'object yielded to block' do
+      it 'is the unique configuration object' do
+        Babysitter.configure do |c|
+          c.should eql(Babysitter.configuration)
+        end
+      end
+    end
+  end
+
+  describe '.logger' do
+    let(:configured_logger) { double('configured logger').as_null_object }
+
+    it 'returns the logger from the configuration' do
+      Babysitter::Configuration.any_instance.stub(:logger).and_return(configured_logger)
+      Babysitter.logger.should eql(configured_logger)
+    end
+  end
+
+  describe '.exception_notifiers' do
+    let(:exception_notifiers) { double('notifiers').as_null_object}
+
+    it 'returns the notifiers from the configuration' do
+      Babysitter::Configuration.any_instance.stub(:exception_notifiers).and_return(exception_notifiers)
+      Babysitter.exception_notifiers.should eql(exception_notifiers)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'awesome_print'
+require 'babysitter'
+require 'timecop'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: babysitter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nicolas Overloop
+- Paul Grayson
+- Andy Roberts
+- Mike Wagg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fozzie
+  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: timecop
+  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: aws-sdk
+  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: awesome_print
+  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: 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'
+description: Babysits long-running processes and reports progress or failures
+email:
+- noverloop@gmail.com
+- paul.grayson@lonelyplanet.com
+- coder@onesandthrees.com
+- michael@guerillatactics.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- babysitter.gemspec
+- lib/babysitter.rb
+- lib/babysitter/configuration.rb
+- lib/babysitter/counter.rb
+- lib/babysitter/exception_notifiers.rb
+- lib/babysitter/exception_notifiers/simple_notification_service.rb
+- lib/babysitter/logger_with_stats.rb
+- lib/babysitter/logging.rb
+- lib/babysitter/monitor.rb
+- lib/babysitter/null_logger.rb
+- lib/babysitter/tracker.rb
+- lib/babysitter/version.rb
+- spec/lib/babysitter/configuration_spec.rb
+- spec/lib/babysitter/exception_notifiers/simple_notification_service_spec.rb
+- spec/lib/babysitter/monitor_spec.rb
+- spec/lib/babysitter/tracker_spec.rb
+- spec/lib/babysitter_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.24
+signing_key: 
+specification_version: 3
+summary: Babysits long-running processes and reports progress or failures
+test_files:
+- spec/lib/babysitter/configuration_spec.rb
+- spec/lib/babysitter/exception_notifiers/simple_notification_service_spec.rb
+- spec/lib/babysitter/monitor_spec.rb
+- spec/lib/babysitter/tracker_spec.rb
+- spec/lib/babysitter_spec.rb
+- spec/spec_helper.rb