.gitignore test/exception_test.rb @@ -4,34 +4,28 @@ This plugin provides exception reporting for "Loom":http://loomapp.com. h2. Usage -You must sign up to Loom to use this plugin. +You must sign up to Loom to use this plugin. Install as a gem or a plugin. -Add this to a controller in your application: +h3. Installation -<pre><code> - enable_loom :email => 'alex@helicoid.net', - :password => 'test', - :url => 'http://helicoid.localhost:3000', - :project_id => 18, - :user_id => Proc.new { self.session[:user_id] }, - :before_action => :try_to_load_account, - :display => :error_page -</code></pre> +As a gem: -# Add a user account to Loom to use for exception reporting -# Then set the project ID you'd like to send reports to -# Finally, set the URL of your Loom account (loom uses subdomains for accounts) +<code>gem install loom-exceptions-rails-plugin --source=http://gems.github.com/</code> -The <code>user_id</code> parameter can be used to represent your application's user. We sometimes use this to record the email address of the customer who encountered an exception to provide them with support. +As a plugin: -The <code>display</code> parameter references a controller action. It will be rendered after the exception has been handled. +<code>script/plugin install git://github.com/alexyoung/loom-exceptions-rails-plugin.git</code> -Similarly, <code>before_action</code> is an action that will be run before rendering the display action. This can be used to check a visitor is logged in to display either an internal application or public template. +Add this to <code>config/initializers/loom.rb</code> -h2. Todo +<pre><code> +Helicoid::Loom.configure do |config| + config.api_key = 'xxx' + config.server = 'http://loomapp.com' +end +</code></pre> -* We need to correctly handle Loom being down or errors reporting to Loom -* Error reporting API for easy reporting outside controllers +The <code>server</code> option can be used with the open source version of Loom. h2. Credits README.textile @@ -1,27 +1,44 @@ module Helicoid module Loom - def self.enable - ActionController::Base.class_eval do - include InstanceMethods - extend ClassMethods + class << self + attr_accessor :api_key, :server, :before_action, :user_id + + def enable + ActionController::Base.class_eval do + include Reporter + end + end + + def configure + yield self + + self.server ||= 'http://loomapp.com' + + if defined?(ActionController::Base) && !ActionController::Base.include?(Helicoid::Loom::Reporter) + enable + end end end - module InstanceMethods - def log_with_loom(exception) + module Reporter + def self.included(base) + base.send(:alias_method, :original_rescue_action_in_public, :rescue_action_in_public) + base.send(:alias_method, :rescue_action_in_public, :send_to_loom) + end + + def send_to_loom(exception) raise if local_request? - send(loom_options[:before_action]) if loom_options.has_key? :before_action + send(Helicoid::Loom.before_action) if Helicoid::Loom.before_action - user_id = case loom_options[:user_id] + user_id = case Helicoid::Loom.user_id when Proc - loom_options[:user_id].bind(self).call + Helicoid::Loom.user_id.bind(self).call when Symbol, String - send loom_options[:user_id] + send Helicoid::Loom.user_id end - LoomException.log loom_options[:url], loom_options[:email], loom_options[:password] do |loom| - loom.project_id = loom_options[:project_id] + LoomException.log Helicoid::Loom.server, Helicoid::Loom.api_key do |loom| loom.session = session.data loom.remote_ip = request.remote_ip loom.exception = exception @@ -30,26 +47,19 @@ module Helicoid loom.url = request.request_uri loom.user_id = user_id end - - if loom_options.has_key? :display - send(loom_options[:display]) - else - raise - end + + original_rescue_action_in_public exception end end module ClassMethods - def enable_loom(options = {}) - write_inheritable_hash :loom_options, options - class_inheritable_reader :loom_options + def logger + ActiveRecord::Base.logger + end - class_eval <<-RUBY - rescue_from Exception do |exception| - log_with_loom exception - end - RUBY + def enable_loom(options = {}) + logger.warn "enable_loom has been removed. Please use config/initializers/loom.rb." end end end -end \ No newline at end of file +end lib/loom.rb @@ -2,13 +2,13 @@ require 'pp' require 'net/http' class LoomException - attr_accessor :session, :cookies, :request_parameters, :url, :user_id, :exception, :project_id, :remote_ip + attr_accessor :session, :cookies, :request_parameters, :url, :user_id, :exception, :remote_ip class LoomDown < Exception ; end class LoomError < Exception ; end - def initialize(url, email, password) - @loom_login = { :url => url, :email => email, :password => password } + def initialize(url, api_key) + @loom_login = { :url => url, :api_key => api_key } end def send_to_loom @@ -22,8 +22,8 @@ class LoomException end end - def self.log(url, email, password, &block) - loom = new url, email, password + def self.log(url, api_key, &block) + loom = new url, api_key yield loom loom.send_to_loom rescue LoomDown # TODO @@ -37,12 +37,11 @@ class LoomException private def post - url = URI.parse "#{@loom_login[:url]}/projects/#{@project_id}/exceptions" + url = URI.parse "#{@loom_login[:url]}/report/#{@loom_login[:api_key]}" req = Net::HTTP::Post.new url.path req.add_field 'Accept', 'application/xml' req.add_field 'Content-Type', 'application/xml' - req.basic_auth @loom_login[:email], @loom_login[:password] connection = Net::HTTP.new(url.host, url.port) connection.request req, loom_parameters_as_xml lib/loom_exception.rb @@ -2,3 +2,30 @@ # task :loom do # # Task goes here # end + +namespace :loom do + desc "Sends a test exception so you can test your settings" + task :test do + require 'action_controller/test_process' + require 'app/controllers/application_controller' + + class ApplicationController + def test + puts "Connecting to server: #{Helicoid::Loom.server} with API key: #{Helicoid::Loom.api_key}" + raise "This is a test error notification" + end + + def rescue_action(exception) + rescue_action_in_public exception + end + end + + request = ActionController::TestRequest.new + response = ActionController::TestResponse.new + + request.action = 'test' + request.request_uri = '/test' + + ApplicationController.process request, response + end +end tasks/loom_tasks.rake @@ -26,6 +26,15 @@ class LoomTest < Test::Unit::TestCase assert exception.send_to_loom end + def test_configure + Helicoid::Loom.configure do |config| + config.api_key = 'xxx' + end + + assert_equal 'xxx', Helicoid::Loom.api_key + assert_equal 'http://loomapp.com', Helicoid::Loom.server + end + private def mocked_response(options = {}) @@ -47,14 +56,13 @@ class LoomTest < Test::Unit::TestCase end def mock_loom_exception(options = {}) - exception = LoomException.new 'helicoid', 'alex@example.com', 'test' + exception = LoomException.new 'helicoid', 'xxx' exception.session = OpenStruct.new :user_id => '1' exception.cookies = [] exception.request_parameters = [] exception.url = 'http://example.com' exception.user_id = '1' exception.exception = options[:exception] || ZeroDivisionError.new - exception.project_id = 1 exception.remote_ip = '127.0.0.1' exception end test/loom_test.rb 61f997e28d039e1321e13d4da34304890fce7720 Alex Young alex@helicoid.net http://github.com/alexyoung/loom-exceptions-rails-plugin/commit/f2ae6507831b1582ad549e83343c0cbcfe1a5a02 f2ae6507831b1582ad549e83343c0cbcfe1a5a02 2009-07-18T09:31:52-07:00 2009-07-18T09:31:52-07:00 Authentication now works with a key so you don't need to specify email/password Added exception test that can be run with rake loom:test b32ebefa68b985c91cad8ec5d4f0271dab5bd1a4 Alex Young alex@helicoid.net