exceptions_begone_notifier 0.2.3

data/.gitignore

@@ -0,0 +1,4 @@
+/pkg
+*.gemspec
+coverage/*
+/rdoc

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+ 
+Copyright (c) 2009 {XING AG}[http://www.xing.com/]
+ 
+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.rdoc

@@ -0,0 +1,96 @@
+=ExceptionsBegoneIdentifier
+
+This gem catch all exceptions from a Rails application and send them
+to a ExceptionsBegone server. Actually it doesn't has to be an exception. 
+You can easily send *any* *kind* *of* *notification* and let the server aggregate it for you. It could be for example
+a cron or nagios message.
+
+This project is currently under development, however it is stable enough to use
+it in production environment. 
+
+==Prerequisites
+
+This gem is <tt>require 'rubygems'</tt> free. See {here}[http://tomayko.com/writings/require-rubygems-antipattern] for explanation.
+If you want to use rubygems as a gems source do <tt>export RUBYOPT="rubygems"</tt>
+
+This gem send informations to an {Exceptions Begone Server}[http://github.com/xing/exceptions_begone]. 
+See the README for the installation guide.
+
+The gem relies that the Rails.logger responds to <tt>error</tt> method (which is a default behavior in Rails applications).
+
+==Downloading gem
+
+<tt>gem sources -a http://gemcutter.org</tt>
+
+or if you have the gemcutter gem installed:
+
+<tt>gem install exceptions_begone_notifier</tt>
+
+==Enabling functionality
+
+Add <tt>require "exceptions_begone_notifier"</tt> in the proper place (e.g. in <tt>config/environment.rb</tt>).
+
+To activate the gem add following lines to you application configuration file (e.g. <tt>config/environments/production.rb</tt>).
+
+  ExceptionsBegone::Catcher.catch_exceptions do |catcher|
+    catcher.host = "exceptions_begone_server"
+  end
+
+Sender expects following parameters for configuration:
+* <tt>project</tt>: name of project (this project has to exist on ExceptionsBegone server)
+* <tt>host</tt>: host name of the ExceptionsBegone server
+* <tt>port</tt>: same as above
+* <tt>open_timeout</tt>: http timeout (in sec)
+* <tt>read_timeout</tt>: same as above
+
+==Usage
+
+After activation all exceptions will be send via HTTP POST (JSON) to the ExceptionsBegone server.
+
+If you want to send a notification use:
+
+<tt>ExceptionsBegone::Sender.send_YOUR_CATEGORY_GOES_HERE({:identifier => "NotificationName", :payload => {:anything => "you want"}})</tt>
+
+or
+
+<tt>ExceptionsBegone::Sender.send_YOUR_CATEGORY_GOES_HERE({:identifier => "NotificationName", :payload => {:anything => "you want"}}, :host => "new host address", :port => "new port")</tt>
+
+if want to override the settings from the ExceptionsBegone::Catcher. As you can see the category of your notification (e.g. nagios_message or warning)
+is taken from the method name: "send_ *category*()".
+
+==Throttling traffic between servers
+
+If you really need to throttle number of send exceptions you will need a caching layer. You could write your own or use
+following implementation ExceptionsBegone::Cache and enable it with:
+
+<tt>ExceptionsBegone::Sender.extend ExceptionsBegone::Cache</tt>
+
+==Authors
+
+{Patryk Peszko}[http://github.com/ppeszko]
+
+==Contributors
+
+==License
+
+The MIT License
+ 
+Copyright (c) 2009 {XING AG}[http://www.xing.com/]
+ 
+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/Rakefile

@@ -0,0 +1,51 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "exceptions_begone_notifier"
+    gemspec.description = "Catch and send exceptions to exceptions_begone service"
+    gemspec.summary = "Catch and send exceptions to exceptions_begone service"
+    gemspec.homepage = "http://github.com/ppeszko/exceptions_begone_notifier"
+    gemspec.authors = ["Patryk Peszko"]
+    gemspec.add_dependency('activesupport')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+    test.rcov_opts << '--exclude "gems/*"'
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "exceptions_begone_notifier #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO

@@ -0,0 +1 @@
+[OPEN]  log exceptions in easy to read format

data/VERSION

@@ -0,0 +1 @@
+0.2.3

data/lib/exceptions_begone/connection_configurator.rb

@@ -0,0 +1,52 @@
+module ExceptionsBegone
+  class ConnectionConfigurator
+    @@defaults = {
+      :project => "production",
+      :port => 80,
+      :open_timeout => 5,
+      :read_timeout => 5,
+      :host => "127.0.0.1"
+    }
+    
+    class << self
+      attr_writer :global_connection
+      
+      def global_connection
+        @global_connection ||= ConnectionConfigurator.new
+      end
+      
+      def global_parameters=(parameters = {})
+        parameters = parameters.marshal_dump if parameters.respond_to?(:marshal_dump)
+        self.global_connection = ConnectionConfigurator.build(parameters)
+      end
+      
+      def build(parameters = {})
+        parameters.blank? ? self.global_connection : new(parameters)
+      end
+      
+    end
+    
+    def initialize(parameters = {})
+      parameters.each do |method_name, key|
+        self.__send__("#{method_name}=", key)
+      end
+    end
+    
+    def path
+      "/projects/#{project}/notifications"
+    end
+    
+    def method_missing(method_id, *args, &block)
+      method_id.to_s =~ /(\w*)(=)?/
+      name, setter = $1, $2
+      
+      super unless @@defaults.include?(name.to_sym)
+      
+      if setter
+        instance_variable_set("@#{name}", *args)
+      else
+        instance_variable_get("@#{name}") || @@defaults[method_id]
+      end
+    end
+  end
+end

data/lib/exceptions_begone/exceptions_support/cache.rb

@@ -0,0 +1,44 @@
+require 'digest/md5'
+
+module ExceptionsBegone::Cache
+  
+  HOURLY_SEND_LIMIT = 500
+  TTL = 60
+  
+  def self.extended(target)
+    target.instance_eval do
+      class << self 
+        alias_method :send_exception_without_cache, :send_exception
+        alias_method :send_exception, :send_exception_with_cache
+      end
+    end
+  end
+
+  def send_exception_with_cache(exception, controller, request, connection_options = {})
+    exception_signature = Digest::MD5.hexdigest(exception.backtrace.join.to_s)
+    return if skip_sending?(exception_signature)
+
+    save_signature_in_cache(exception_signature)
+    send_exception_without_cache(exception, controller, request, connection_options = {})
+  end
+
+  def skip_sending?(exception_signature)
+     signature_equal?(exception_signature) || hourly_send_limit_reached?    
+  end
+
+  def signature_equal?(exception_signature)
+    Rails.cache.read('last_exception_signature', :raw => true) == exception_signature
+  end
+
+  def hourly_send_limit_reached?
+    key = "exceptions_sent_in_last_hour.#{Time.now.hour}"
+    sent_number = Rails.cache.fetch(key, :expires_in => 1.hour, :raw => true) do
+      0
+    end
+    Rails.cache.increment(key) > HOURLY_SEND_LIMIT
+  end
+
+  def save_signature_in_cache(exception_signature)
+    Rails.cache.write('last_exception_signature', exception_signature, :expires_in => TTL, :raw => true)
+  end
+end

data/lib/exceptions_begone/exceptions_support/catcher.rb

@@ -0,0 +1,23 @@
+module ExceptionsBegone
+  module Catcher
+    def catch_exceptions(&block)
+      ActionController::Base.__send__(:include, InstanceMethods)
+      parameters = OpenStruct.new
+      block.call(parameters) if block_given?
+      ConnectionConfigurator.global_parameters = parameters
+    end
+    module_function :catch_exceptions
+        
+    module InstanceMethods
+      def self.included(target)
+        target.send(:alias_method, :rescue_action_in_public_without_catcher, :rescue_action_in_public)
+        target.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_catcher)
+      end
+
+      def rescue_action_in_public_with_catcher(exception)
+        Sender.send_exception(exception, self, request)
+        rescue_action_in_public_without_catcher(exception)
+      end
+    end
+  end
+end

data/lib/exceptions_begone/formatter.rb

@@ -0,0 +1,51 @@
+module ExceptionsBegone
+  class Formatter
+    class << self
+      def format_data(category, notification)
+        notification.symbolize_keys!
+        notification.merge!(:category => category)
+        serialized_notification = serialize_data(notification)
+        to_json(serialized_notification)
+      end
+      
+      def format_exception_data(exception, controller, request)
+        { :identifier => generate_identifier(controller, exception),
+          :payload => {
+            :parameters => request.parameters, 
+            :url => request.url,
+            :ip => request.ip,
+            :request_environment => request.env,
+            :session => request.session, 
+            :environment => ENV.to_hash,
+            :backtrace => exception.backtrace 
+          }
+        }
+      end
+      
+      def generate_identifier(controller, exception)
+        "#{controller.controller_name}##{controller.action_name} (#{exception.class}) #{exception.message.inspect}"
+      end
+  
+      def serialize_data(data)
+        case data
+        when String
+          data
+        when Hash
+          data.inject({}) do |result, (key, value)|
+            result.update(key => serialize_data(value))
+          end
+        when Array
+          data.map do |elem|
+            serialize_data(elem)
+          end
+        else
+          data.to_s
+        end
+      end
+  
+      def to_json(attributes)
+        ActiveSupport::JSON.encode(:notification => attributes)
+      end
+    end
+  end
+end

data/lib/exceptions_begone/sender.rb

@@ -0,0 +1,45 @@
+module ExceptionsBegone
+  class Sender
+    class << self
+      # ugly
+      attr_accessor :mailer
+      
+      def post(data, connection_options = {})
+        conn_conf = ConnectionConfigurator.build(connection_options)
+
+        http = Net::HTTP.new(conn_conf.host, conn_conf.port)
+        http.read_timeout = conn_conf.read_timeout
+        http.open_timeout = conn_conf.open_timeout
+      
+        log(data)
+        http.post(conn_conf.path, data, "Content-type" => "application/json", "Accept" => "application/json")
+      rescue TimeoutError, Errno::ECONNREFUSED => e
+        log(e.inspect)
+        log(data)
+        mailer.deliver_error(e.message, "#{e.inspect} #{data}") if mailer
+      end
+    
+      def send_exception(exception, controller, request, connection_options = {})
+        notification = Formatter.format_exception_data(exception, controller, request)
+        send_generic("exception", notification, connection_options = {})    
+      end
+          
+      def send_generic(category, notification, connection_options = {})
+        data = Formatter.format_data(category, notification)
+        post(data, connection_options)
+      end
+      
+      def log(message)
+        Rails.logger.error("[EXCEPTIONS_BEGONE]: #{message}")
+      end
+      
+      def method_missing(method_name, *args)
+        if method_name.to_s =~ /^send_(.*)/
+          Sender.__send__(:send_generic, "#{$1}", *args)
+        else
+          super(method_name, *args)
+        end
+      end
+    end
+  end
+end

data/lib/exceptions_begone_notifier.rb

@@ -0,0 +1,9 @@
+require 'active_support'
+require 'active_support/json'
+require 'ostruct'
+
+require 'exceptions_begone/connection_configurator'
+require 'exceptions_begone/sender'
+require 'exceptions_begone/formatter'
+require 'exceptions_begone/exceptions_support/catcher'
+require 'exceptions_begone/exceptions_support/cache'

data/test/test_cache.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+module Rails
+end
+
+class TestCachingInterface < Test::Unit::TestCase
+
+  class ExceptionsBegone::TestSender
+    class << self
+      def send_exception(exception, controller, request, connection_options = {})
+      end
+    end
+  end
+
+  ExceptionsBegone::TestSender.extend ExceptionsBegone::Cache
+  
+  def setup
+    @cache = stub("cache")
+    Rails.stubs(:cache).returns(@cache)
+    @exception = Exception.new
+    @exception.stubs(:backtrace).returns([])
+    @hashed_backtrace = Digest::MD5.hexdigest(@exception.backtrace.join.to_s)
+  end
+    
+  def test_cache_should_be_enabled_after_including
+    ExceptionsBegone::TestSender.expects(:skip_sending?).returns(true)
+    
+    ExceptionsBegone::TestSender.send_exception(@exception, "controller", "request")
+  end
+  
+  def test_should_send_exception_on_new_exception_if_the_hourly_limit_is_not_reached
+    ExceptionsBegone::TestSender.expects(:signature_equal?).with(@hashed_backtrace).returns(false)
+    ExceptionsBegone::TestSender.expects(:hourly_send_limit_reached?).returns(false)
+    
+    ExceptionsBegone::TestSender.expects(:save_signature_in_cache).with(@hashed_backtrace)
+    ExceptionsBegone::TestSender.expects(:send_exception_without_cache).with(@exception, "controller", "request", {})
+    ExceptionsBegone::TestSender.send_exception(@exception, "controller", "request")
+  end
+  
+  def test_should_not_send_exception_on_new_exception_if_the_hourly_limit_is_reached
+    ExceptionsBegone::TestSender.expects(:signature_equal?).with(@hashed_backtrace).returns(false)
+    ExceptionsBegone::TestSender.expects(:hourly_send_limit_reached?).returns(true)
+    
+    ExceptionsBegone::TestSender.expects(:save_signature_in_cache).never
+    ExceptionsBegone::TestSender.expects(:send_exception_without_cache).never
+    ExceptionsBegone::TestSender.send_exception(@exception, "controller", "request")
+  end
+end

data/test/test_catcher.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+require 'action_controller'
+require 'net/http'
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+end
+
+class TestCatchingExceptions < ActionController::TestCase
+
+  class CatchingExceptionsController < ActionController::Base
+    CatchingExceptionsController.consider_all_requests_local = false
+
+    def action_with_exception
+      raise "Exception from #{self.class.name}"
+    end
+
+    ExceptionsBegone::Catcher.catch_exceptions
+  end
+    
+  tests CatchingExceptionsController
+  def setup
+    @request.remote_addr = '1.2.3.4'
+    @request.host = 'example.com'
+  end
+  
+  def test_should_catch_all_exceptions_from_controller
+    CatchingExceptionsController.any_instance.expects(:rescue_action_in_public)
+
+    get :action_with_exception
+  end  
+  
+  def test_should_send_the_exception
+    ExceptionsBegone::Sender.expects(:send_generic).with("exception", anything, anything)
+    CatchingExceptionsController.any_instance.expects(:rescue_action_in_public_without_catcher)
+    
+    get :action_with_exception
+  end
+end
+
+class TestConfiguringCatcher < ActionController::TestCase
+  class ConfiguringExceptionsController < ActionController::Base
+    ConfiguringExceptionsController.consider_all_requests_local = false
+
+    def action_with_exception
+      raise "Exception from #{self.class.name}"
+    end
+
+    ExceptionsBegone::Catcher.catch_exceptions do |catcher|
+      catcher.project = "test_configuration_project"
+      catcher.host = "my_host"
+      catcher.port = 987
+    end
+  end
+  
+  tests ConfiguringExceptionsController
+  def test_should_send_exceptions_to_chosen_service
+    ExceptionsBegone::Sender.stubs(:log)
+    @request.remote_addr = '1.2.3.4'
+    @request.host = 'my_host'
+    
+    notification = {:status => "ok"}
+    parameters = {:port => 987, :host => "my_host", :project => "test_configuration_project"}
+    net_http = Net::HTTP.new(parameters[:host], parameters[:port])
+    
+    Net::HTTP.expects(:new).with(parameters[:host], parameters[:port]).returns(net_http)
+    Net::HTTP.any_instance.expects(:post).with("/projects/#{parameters[:project]}/notifications", anything, anything)
+    ConfiguringExceptionsController.any_instance.expects(:rescue_action_in_public_without_catcher)
+    
+    get :action_with_exception
+  end
+end
+  

data/test/test_connection_configurator.rb

@@ -0,0 +1,12 @@
+require "test_helper"
+
+class TestConnectionConfigurator < Test::Unit::TestCase
+  def setup
+    ExceptionsBegone::ConnectionConfigurator.instance_variable_set("@global_connection", nil)
+  end
+
+  def test_build_should_return_a_connection_cofigurator_with_default_settings
+    conn_conf = ExceptionsBegone::ConnectionConfigurator.build
+    assert_equal "127.0.0.1", conn_conf.host
+  end
+end

data/test/test_formatter.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+require 'action_controller'
+
+class TestFormatter < Test::Unit::TestCase
+  def test_serialize_data
+    object = Object.new
+    nested_object = Object.new
+    object_in_array = Object.new
+    notification = {:string => "", :hash => {}, :array => [object_in_array], :object => object, :nested => {:nested_object => nested_object}}
+      
+    object.expects(:to_s).returns("object")
+    nested_object.expects(:to_s).returns("nested_object")
+    object_in_array.expects(:to_s).returns("object_in_array")
+    
+    serialize_data = ExceptionsBegone::Formatter.serialize_data(notification)
+    assert_equal "object", serialize_data[:object]
+    assert_equal "nested_object", serialize_data[:nested][:nested_object]
+    assert_equal ["object_in_array"], serialize_data[:array]
+  end
+  
+  def test_all_data_should_be_serialized
+    ExceptionsBegone::Formatter.expects(:serialize_data).returns("")
+        
+    ExceptionsBegone::Formatter.format_data("test_category", :payload => {})
+  end
+end 
+
+class TestFormattingExceptionsData < Test::Unit::TestCase
+  
+  def setup
+    @exception = Exception.new("some exception")
+    @controller = ActionController::Base.new
+    request = stub(:parameters => "", 
+                          :url => "http://www.example.com", 
+                           :ip => "127.0.0.1",
+                          :env => ENV.to_hash,
+                      :session => "")
+    @controller.stubs(:request).returns(request)
+  end
+  
+  def test_generate_identifier
+    assert_equal "#{@controller.controller_name}##{@controller.action_name} (#{@exception.class}) #{@exception.message.inspect}", ExceptionsBegone::Formatter.generate_identifier(@controller, @exception)
+  end
+  
+  def test_format_exception_data_should_automatically_set_identifier
+    identifier = ExceptionsBegone::Formatter.format_exception_data(@exception, @controller, @controller.request)[:identifier]
+    
+    assert_match(/#{@controller.controller_name}/, identifier)
+    assert_match(/#{@controller.action_name}/, identifier)
+    assert_match(/#{@exception.class}/, identifier)
+    assert_match(/#{@exception.message.inspect}/, identifier)
+  end
+  
+  def test_format_exception_data_should_automatically_set_payload
+    payload = ExceptionsBegone::Formatter.format_exception_data(@exception, @controller, @controller.request)[:payload]
+
+    assert_equal(@controller.request.session, payload[:session])
+    assert_equal(@exception.backtrace, payload[:backtrace])
+    assert_equal(ENV.to_hash, payload[:environment])
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'mocha'
+
+begin
+  require 'redgreen' unless ENV['TM_FILENAME']
+rescue LoadError
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'exceptions_begone_notifier'
+
+class Test::Unit::TestCase
+end

data/test/test_sender.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+require 'net/http'
+
+class TestSendingNotifications < Test::Unit::TestCase
+
+  def setup
+    ExceptionsBegone::Sender.stubs(:log)
+    @notification = { :identifier => "NotificationName", :payload => "payload" }
+    @parameters = {:port => 987, :host => "my_host", :project => "my_project"}
+  end
+  
+  def test_should_be_possible_to_send_notification
+    Net::HTTP.any_instance.expects(:post).with("/projects/production/notifications", anything, anything)
+    
+    ExceptionsBegone::Sender.send_notification({:status => "ok"}, :host => "my_host")
+  end
+  
+  def test_should_be_possible_to_specify_parameters_connection_parameters
+    @notification = {:status => "ok"}
+    @parameters = {:port => 987, :host => "my_host", :project => "my_project"}
+    net_http = Net::HTTP.new(@parameters[:host], @parameters[:port])
+    
+    Net::HTTP.expects(:new).with(@parameters[:host], @parameters[:port]).returns(net_http)
+    Net::HTTP.any_instance.expects(:post).with("/projects/#{@parameters[:project]}/notifications", anything, anything)
+    
+    ExceptionsBegone::Sender.send_notification(@notification, @parameters)
+  end
+  
+  def test_deliver_notfications_as_json
+    Net::HTTP.any_instance.expects(:post).with("/projects/#{@parameters[:project]}/notifications", @notification, 'Content-type' => 'application/json', 'Accept' => 'application/json')
+    
+    ExceptionsBegone::Sender.post(@notification, @parameters)
+  end
+  
+  def test_should_handle_timeouts
+    Net::HTTP.any_instance.expects(:post).with("/projects/#{@parameters[:project]}/notifications", @notification, 'Content-type' => 'application/json', 'Accept' => 'application/json').raises(TimeoutError)
+    
+    assert_nothing_raised do
+      ExceptionsBegone::Sender.post(@notification, @parameters)
+    end
+  end
+  
+  def test_category_should_be_automatically_generated_from_method_name
+    encoded_notification = ActiveSupport::JSON.encode(:notification => {:category => 'warning'}.merge(@notification))
+    Net::HTTP.any_instance.expects(:post).with("/projects/#{@parameters[:project]}/notifications", encoded_notification, "Content-type" => "application/json", "Accept" => "application/json")
+    
+    ExceptionsBegone::Sender.send_warning(@notification, @parameters)
+  end  
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: exceptions_begone_notifier
+version: !ruby/object:Gem::Version 
+  version: 0.2.3
+platform: ruby
+authors: 
+- Patryk Peszko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-03 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Catch and send exceptions to exceptions_begone service
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+- TODO
+files: 
+- .gitignore
+- LICENSE
+- Manifest
+- README.rdoc
+- Rakefile
+- TODO
+- VERSION
+- lib/exceptions_begone/connection_configurator.rb
+- lib/exceptions_begone/exceptions_support/cache.rb
+- lib/exceptions_begone/exceptions_support/catcher.rb
+- lib/exceptions_begone/formatter.rb
+- lib/exceptions_begone/sender.rb
+- lib/exceptions_begone_notifier.rb
+- test/test_cache.rb
+- test/test_catcher.rb
+- test/test_connection_configurator.rb
+- test/test_formatter.rb
+- test/test_helper.rb
+- test/test_sender.rb
+has_rdoc: true
+homepage: http://github.com/ppeszko/exceptions_begone_notifier
+licenses: []
+
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Catch and send exceptions to exceptions_begone service
+test_files: 
+- test/test_cache.rb
+- test/test_catcher.rb
+- test/test_connection_configurator.rb
+- test/test_formatter.rb
+- test/test_helper.rb
+- test/test_sender.rb