relevance-chatterbox 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+.specification
+coverage

data/.treasure_map.rb

@@ -0,0 +1,22 @@
+map_for(:chatterbox) do |map|
+  
+  map.keep_a_watchful_eye_for 'lib', 'examples', 'rails'
+
+  # map.add_mapping %r%examples/(.*)_example\.rb% do |match|
+  #   ["examples/#{match[1]}_example.rb"]
+  # end
+  # 
+  # map.add_mapping %r%examples/example_helper\.rb% do |match|
+  #   Dir["examples/**/*_example.rb"]
+  # end
+  #  
+  # map.add_mapping %r%lib/(.*)\.rb% do |match|
+  #   Dir["examples/#{match[1]}_example.rb"]
+  # end
+  
+  map.add_mapping %r%rails/(.*)\.rb% do |match|
+    ["examples/#{match[1]}_example.rb"]
+  end
+  
+  
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Rob Sanheim
+
+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.markdown

@@ -0,0 +1,54 @@
+Chatterbox
+==========================================
+
+TODO summary
+
+Installing and Running
+---------------------------------------
+
+To install within a Rails app:
+
+Add the following to your environment.rb file:
+
+    config.gem "relevance-chatterbox"
+
+Then run:
+
+    rake gems:install
+
+To enable standard Rails exception catching for your controllers, add the following to `application_controller`
+
+    class ApplicationController < ActionController::Base
+      include Chatterbox::RailsCatcher
+      # ...
+    end
+    
+Then, wire up a producer
+
+
+
+  
+
+
+Rails Exception Integration
+---------------------------------------
+
+Example 1
+---------------------------------------
+
+Example 2
+---------------------------------------
+
+Bugs & Patches
+--------------
+
+Links
+-------------
+
+Contributors
+------------
+* Rob Sanheim
+
+Copyrights
+------------
+* Copyright &copy; 2008-2009 [Relevance, Inc.](http://www.thinkrelevance.com/), under the MIT license

data/Rakefile

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "chatterbox"
+    gem.summary = %Q{TODO}
+    gem.email = "rsanheim@gmail.com"
+    gem.homepage = "http://github.com/relevance/chatterbox"
+    gem.authors = ["Rob Sanheim"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'micronaut/rake_task'
+Micronaut::RakeTask.new(:examples) do |examples|
+  examples.pattern = 'examples/**/*_example.rb'
+  examples.ruby_opts << '-Ilib -Iexamples'
+end
+
+Micronaut::RakeTask.new(:rcov) do |examples|
+  examples.pattern = 'examples/**/*_example.rb'
+  examples.rcov_opts = '-Ilib -Iexamples'
+  examples.rcov = true
+end
+
+
+task :default => :examples

data/examples/chatterbox_example.rb

@@ -0,0 +1,73 @@
+require File.join(File.dirname(__FILE__), *%w[example_helper])
+
+describe Chatterbox do
+
+  before do
+    Chatterbox.logger = Logger.new(nil)
+    Chatterbox::Publishers.clear!
+  end
+  
+  after do
+    Chatterbox.logger = nil
+  end
+  
+  describe "handle_notice" do
+    include Chatterbox
+    
+    it "should create Notification and return the notice" do
+      notification = mock(:notice => {:hash => 'of awesomeness'})
+      Chatterbox::Notification.expects(:new).returns(notification)
+      handle_notice("message")
+    end
+    
+    it "should publish the notice" do
+      notification = stub(:notice => {:hash => 'of awesomeness'})
+      Chatterbox::Notification.stubs(:new).returns(notification)
+      expects(:publish_notice).with({:hash => 'of awesomeness'})
+      handle_notice("message")
+    end
+    
+  end
+  
+  describe "logger" do
+    
+    it "uses STDOUT logger if Rails not available" do
+      Chatterbox.logger = nil
+      
+      Logger.expects(:new).with(STDOUT).returns("logger")
+      Chatterbox.stubs(:rails_default_logger).returns(nil)
+      Chatterbox.logger.should == "logger"
+    end
+  end
+  
+  describe "publish" do
+    
+    include Chatterbox
+    
+    it "should call each publisher with the notice" do
+      notice = stub
+      publisher = Chatterbox::Publishers.register { "i'm in your block" }
+      publisher.expects(:call).with(notice)
+      
+      publish_notice(notice)
+    end
+    
+  end
+
+  describe "publishers" do
+    
+    it "should allow clearing all publishers" do
+      Chatterbox::Publishers.register { "sending your messages" }
+      Chatterbox::Publishers.publishers.size.should == 1
+      Chatterbox::Publishers.clear!
+      Chatterbox::Publishers.publishers.size.should == 0
+    end
+    
+    it "should allow registering with a block" do
+      pub1 = Chatterbox::Publishers.register { "sending your messages" }
+      pub2 = Chatterbox::Publishers.register { "announcing your news" }
+      Chatterbox::Publishers.publishers.should == [pub1, pub2]
+    end
+  end
+  
+end

data/examples/example_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'action_controller'
+require 'micronaut'
+require 'micronaut-rails'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'chatterbox'
+
+def not_in_editor?
+  !(ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM'))
+end
+
+Micronaut.configure do |c|
+  c.mock_with :mocha
+  c.color_enabled = not_in_editor?
+  c.filter_run :focused => true
+  c.alias_example_to :fit, :focused => true
+  c.enable_controller_support :behaviour => { :describes => lambda { |dt| dt < ::ActionController::Base } }
+end

data/examples/lib/chatterbox/notification_example.rb

@@ -0,0 +1,138 @@
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. example_helper]))
+
+describe Chatterbox::Notification do
+
+  before do
+    Chatterbox.logger = Logger.new(nil)
+  end
+
+  describe "creating the notice" do
+
+    it "should safely handle nil" do
+      lambda {
+        Chatterbox::Notification.new(nil).notice
+      }.should_not raise_error
+    end
+    
+    it "should convert exception to notice" do
+      exception = RuntimeError.new
+      notification = Chatterbox::Notification.new(exception)
+      notification.expects(:exception_to_notice).with(exception).returns({})
+      notification.notice
+    end
+    
+    it "should use to_hash if message is not an exception and it responds_to possible" do
+      some_object = mock(:to_hash => {:foo => "bar"})
+      Chatterbox::Notification.new(some_object).notice.should include({:foo => "bar"})
+    end
+    
+    it "should call to_s on anything that responds to it, as a last resort" do
+      some_object = mock(:to_s => "my to_s")
+      Chatterbox::Notification.new(some_object).notice.should include({:summary => "my to_s"})
+    end
+    
+    it "merges hash passed in with default info" do
+      hash = {:message => "hey!"}
+      default_info = mock()
+      default_info.expects(:merge).with(hash)
+      notification = Chatterbox::Notification.new(hash)
+      notification.expects(:default_info).returns(default_info)
+      notification.notice
+    end
+    
+    it "turns string notice into a hash keyed by notice" do
+      notification = Chatterbox::Notification.new("You have been placed on alert")
+      notification.notice.should include({:summary => "You have been placed on alert"})
+    end
+    
+    it "always includes a summary" do
+      Chatterbox::Notification.new().notice.should include(:summary)
+      Chatterbox::Notification.new({}).notice.should include(:summary)
+      Chatterbox::Notification.new(RuntimeError.new).notice.should include(:summary)
+    end
+    
+    it "should set summary to N/A if nothing provided" do
+      Chatterbox::Notification.new({}).notice.should include(:summary => "N/A")
+      Chatterbox::Notification.new({:foo => 'baz'}).notice.should include(:summary => "N/A")
+    end
+  end
+  
+  describe "exceptions" do
+    
+    def raised_exception
+      raise RuntimeError, "Your zing bats got mixed up with the snosh frazzles."
+    rescue => e
+      e
+    end
+
+    it "should extract exception info" do
+      exception = raised_exception
+      data = Chatterbox::Notification.new(exception).notice
+      data[:summary].should == "RuntimeError: Your zing bats got mixed up with the snosh frazzles."
+      data[:error_class].should == "RuntimeError"
+      data[:error_message].should == "Your zing bats got mixed up with the snosh frazzles."
+      data[:backtrace].should == exception.backtrace
+    end
+    
+    it "merges rails info and ruby info into the exception info" do
+      notification = Chatterbox::Notification.new(raised_exception)
+      rails = stub_everything(:version => "2.0", :root => "/rails/root", :env => "production")
+      notification.stubs(:rails_configuration).returns(rails)
+      notification.notice.should include(:rails_version => "2.0")
+      notification.notice.should include(:rails_root => "/rails/root")
+      notification.notice.should include(:rails_env => "production")
+    end
+    
+  end
+  
+  describe "hashes" do 
+
+    it "merges rails info and ruby info into the notification" do
+      notification = Chatterbox::Notification.new({})
+      rails = stub_everything(:version => "2.0", :root => "/rails/root", :env => "production")
+      notification.stubs(:rails_configuration).returns(rails)
+      notification.notice.should include(:rails_version => "2.0")
+      notification.notice.should include(:rails_root => "/rails/root")
+      notification.notice.should include(:rails_env => "production")
+    end
+    
+  end
+  
+  describe "default info to be included with every notification" do
+    
+    it "should return full ENV" do
+      environment = { "USER" => "jdoe", "PATH" => "/usr/bin", "HOME" => "/usr/home/jdoe" }
+      notification = Chatterbox::Notification.new
+      notification.stubs(:env).returns(environment)
+      notification.default_info.should include(:environment => environment)
+    end
+    
+    it "should return Ruby version and platform" do
+      notification = Chatterbox::Notification.new
+      notification.stubs(:ruby_version).returns("1.8.6")
+      notification.stubs(:ruby_platform).returns("Mac OS X blah")
+      data = notification.default_info
+      data.should include(:ruby_version => "1.8.6")
+      data.should include(:ruby_platform => "Mac OS X blah")
+    end
+    
+    describe "when Rails is defined" do
+      
+      it "should return Rails info" do
+        notification = Chatterbox::Notification.new
+        rails = stub
+        rails.stubs(:root).returns("/some/path")
+        rails.stubs(:env).returns("production")
+        rails.stubs(:version).returns("2.1.2")
+        notification.stubs(:rails_configuration).returns(rails)
+        
+        notification.default_info.should include(:rails_root => "/some/path")
+        notification.default_info.should include(:rails_env => "production")
+        notification.default_info.should include(:rails_version => "2.1.2")
+      end
+      
+    end
+    
+  end
+  
+end

data/examples/lib/chatterbox/rails_catcher_example.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. example_helper]))
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. .. rails init]))
+
+ActionController::Routing::Routes.draw { |map| map.connect ':controller/:action/:id' }
+
+class WidgetException < RuntimeError; end
+class WidgetsController < ActionController::Base
+  include Chatterbox::RailsCatcher
+
+  def rescue_action e
+    rescue_action_in_public e
+  end
+  
+  def rescue_action_in_public_without_chatterbox e
+    raise e
+  end
+  
+  def index
+    raise_exception
+    render :text => "hi"
+  end
+  
+  def raise_exception
+    raise WidgetException, "Bad dog!"
+  end
+end
+
+describe WidgetsController do
+  
+  describe "rescue aliasing" do
+    
+    it "should alias method chain" do
+      exception = RuntimeError.new
+      @controller.expects(:rescue_action_in_public_without_chatterbox).with(exception)
+      @controller.rescue_action_in_public(exception)
+    end
+  end
+
+  describe "exception handling" do
+    
+    it "should raise on index" do
+      lambda {
+        get :index
+      }.should raise_error(WidgetException, "Bad dog!")
+    end
+    
+    it "should send exception to handle_notice" do
+      Chatterbox.expects(:handle_notice).with(instance_of(WidgetException))
+      get :index rescue nil
+    end
+    
+  end
+
+end

data/init.rb

@@ -0,0 +1,2 @@
+# For backwards compatibility with old versions of Rails and plugins
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[rails init]))

data/lib/chatterbox.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), *%w[chatterbox notification])
+require File.join(File.dirname(__FILE__), *%w[consumers])
+
+module Chatterbox
+
+  def handle_notice(message)
+    notice = Notification.new(message).notice
+    publish_notice(notice)
+  end
+
+  def publish_notice(notice)
+    Publishers.publishers.each { |p| p.call(notice) }
+  end
+  
+  def logger
+    @logger ||= rails_default_logger || Logger.new(STDOUT)
+  end
+  
+  def logger=(logger)
+    @logger = logger
+  end
+  
+  def rails_default_logger
+    defined?(RAILS_DEFAULT_LOGGER) ? RAILS_DEFAULT_LOGGER : nil
+  end
+  
+  extend self
+  
+  module Publishers
+
+    class << self
+
+      def publishers
+        @publishers ||= []
+      end
+      
+      def register(&blk)
+        Chatterbox.logger.debug { "Registering publisher: #{blk}"}
+        publishers << blk
+        blk
+      end
+      
+      def clear!
+        @publishers = []
+      end
+
+    end
+    
+  end
+  
+end
+

data/lib/chatterbox/notification.rb

@@ -0,0 +1,84 @@
+module Chatterbox
+  
+  class Notification
+    
+    attr_reader :message
+    
+    def initialize(message = nil)
+      @message = message
+    end
+    
+    def notice
+      hash = normalize_message_to_hash(message)
+      default_info.merge(hash)
+    end
+    
+    def normalize_message_to_hash(message)
+      case
+      when Exception === message
+        exception_to_notice(message)
+      when message.respond_to?(:to_hash)
+        message.to_hash
+      when message.respond_to?(:to_s)
+        string_to_notice(message.to_s)
+      end
+    end
+    
+    def default_info
+      default_info     = {
+        :summary       => "N/A",
+        :environment   => env,
+        :ruby_version  => ruby_version,
+        :ruby_platform => ruby_platform
+      }
+      default_info = add_ruby_info(default_info)
+      default_info = add_rails_info(default_info) if rails_configuration
+      default_info
+    end
+    
+    def string_to_notice(message)
+      { :summary => message }
+    end
+    
+    def exception_to_notice(exception)
+      {
+        :summary => "#{exception.class.name}: #{exception.message}",
+        :error_class   => exception.class.name,
+        :error_message => exception.message,
+        :backtrace     => exception.backtrace,
+      }
+    end
+    
+    def add_rails_info(data)
+      data.merge({
+        :rails_env => rails_configuration.env,
+        :rails_root => rails_configuration.root,
+        :rails_version => rails_configuration.version
+      })
+    end
+    
+    def add_ruby_info(data)
+      data.merge({
+        :ruby_version  => ruby_version,
+        :ruby_platform => ruby_platform
+      })
+    end
+
+    def ruby_version
+      RUBY_VERSION
+    end
+    
+    def ruby_platform
+      RUBY_PLATFORM
+    end
+    
+    def env
+      ENV.to_hash
+    end
+    
+    def rails_configuration
+      defined?(Rails) && Rails
+    end
+    
+  end
+end

data/lib/chatterbox/rails_catcher.rb

@@ -0,0 +1,24 @@
+module Chatterbox
+
+  module RailsCatcher
+    
+    def self.included(base)
+      if base.instance_methods.map(&:to_s).include? 'rescue_action_in_public' and !base.instance_methods.map(&:to_s).include? 'rescue_action_in_public_without_chatterbox'
+        base.send(:alias_method, :rescue_action_in_public_without_chatterbox, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_chatterbox)
+      end
+    end
+    
+    # Overrides the rescue_action method in ActionController::Base, but does not inhibit
+    # any custom processing that is defined with Rails 2's exception helpers.
+    def rescue_action_in_public_with_chatterbox exception
+      Chatterbox.logger.debug { "#{self.class}#rescue_action_in_public_with_chatterbox: caught exception #{exception} - about to handle"}
+      Chatterbox.handle_notice(exception)
+      Chatterbox.logger.debug { "#{self.class}#rescue_action_in_public_with_chatterbox: handing exception #{exception} off to normal rescue handling"}
+      
+      rescue_action_in_public_without_chatterbox(exception)
+    end
+    
+  end
+  
+end

data/lib/consumers.rb

@@ -0,0 +1,2 @@
+require 'action_mailer'
+require File.join(File.dirname(__FILE__), *%w[consumers email_consumer])

data/lib/consumers/email_consumer.rb

@@ -0,0 +1,55 @@
+module Chatterbox
+  class EmailConsumer
+    
+    attr_reader :notice
+    
+    def initialize(notice)
+      @notice = notice
+    end
+    
+    def process
+      Chatterbox.logger.debug { "Mailing notification #{notice['summary']}"}
+      Mailer.deliver_exception_notification(notice)
+    end
+  
+  end
+  
+  class Mailer < ActionMailer::Base
+    @@sender_address = %("Exception Notifier" <exception.notifier@default.com>)
+    cattr_accessor :sender_address
+
+    @@exception_recipients = []
+    cattr_accessor :exception_recipients
+
+    @@email_prefix = "[ERROR] "
+    cattr_accessor :email_prefix
+
+    self.template_root = File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. views]))
+
+    def self.reloadable?() false end
+
+    def exception_notification(data={})
+      content_type "text/plain"
+
+      subject    "#{email_prefix} Error - #{data['summary']}"
+
+      recipients exception_recipients
+      from       sender_address
+
+      body       data
+    end
+
+    private
+
+      def sanitize_backtrace(trace)
+        re = Regexp.new(/^#{Regexp.escape(rails_root)}/)
+        trace.map { |line| Pathname.new(line.gsub(re, "[RAILS_ROOT]")).cleanpath.to_s }
+      end
+
+      def rails_root
+        @rails_root ||= Pathname.new(RAILS_ROOT).cleanpath.to_s
+      end
+
+  end
+  
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. lib chatterbox]))
+require File.expand_path(File.join(File.dirname(__FILE__), *%w[.. lib chatterbox rails_catcher]))

data/version.yml

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

data/views/chatterbox/mailer/exception_notification.erb

@@ -0,0 +1,11 @@
+Error Message
+--------------
+<%= @error_class %>: <%= @error_message %>
+
+Backtrace
+----------
+<%= @backtrace.join "\n" %>
+
+Environment
+------------
+<%= @environment %>

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: relevance-chatterbox
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Rob Sanheim
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-20 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: rsanheim@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .gitignore
+- .treasure_map.rb
+- LICENSE
+- README.markdown
+- Rakefile
+- examples/chatterbox_example.rb
+- examples/example_helper.rb
+- examples/lib/chatterbox/notification_example.rb
+- examples/lib/chatterbox/rails_catcher_example.rb
+- init.rb
+- lib/chatterbox.rb
+- lib/chatterbox/notification.rb
+- lib/chatterbox/rails_catcher.rb
+- lib/consumers.rb
+- lib/consumers/email_consumer.rb
+- rails/init.rb
+- version.yml
+- views/chatterbox/mailer/exception_notification.erb
+has_rdoc: false
+homepage: http://github.com/relevance/chatterbox
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: TODO
+test_files: 
+- examples/chatterbox_example.rb
+- examples/example_helper.rb
+- examples/lib/chatterbox/notification_example.rb
+- examples/lib/chatterbox/rails_catcher_example.rb