ratchetio 0.5.5 → 0.6.0

data/.travis.yml

@@ -3,7 +3,6 @@ rvm:
   - 1.8.7
   - 1.9.3
   - 1.9.2
-  - ree
   - ruby-head
   - jruby-18mode
   - jruby-19mode
@@ -14,3 +13,5 @@ matrix:
   allow_failures:
     - rvm: ruby-head
     - rvm: rbx-18mode
+    - rvm: jruby-18mode
+    - rvm: jruby-19mode

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Change Log
 
+**0.6.0**
+- BREAKING CHANGE: Ratchetio.report_exception now returns 'ignored', 'disabled', or 'error' instead of nil when the exception is not reported for one of those reasons. It still returns the payload upon success.
+- Request data is now parsed from the rack environment instead of from within the controller, addressing issue #10.
+- Add Sidekiq middleware for catching workers' exceptions
+- Replaced activesupport dependency with multi_json
+
+**0.5.5**
+- Added activesupport dependency for use without Rails 
+
 **0.5.4**
 - Added new default scrub params
 

data/THANKS

@@ -2,6 +2,8 @@ Huge thanks to the following contributors (by github username). For the most up-
 
 arr-ee
 kavu
+magnolia-fan
 mipearson
 trisweb
 tysontate
+wbond

data/lib/ratchetio/exception_reporter.rb

@@ -0,0 +1,24 @@
+module Ratchetio
+  module ExceptionReporter
+    include RequestDataExtractor
+
+    def report_exception_to_ratchetio(env, exception)
+      ratchetio_debug "[Ratchet.io] Reporting exception: #{exception.try(:message)}", :error
+      request_data = extract_request_data_from_rack(env)
+      person_data = extract_person_data_from_controller(env)
+      exception_data = Ratchetio.report_exception(exception, request_data, person_data)
+      env['ratchetio.exception_uuid'] = exception_data[:uuid]
+      ratchetio_debug "[Ratchet.io] Exception uuid saved in env: #{exception_data[:uuid]}"
+    rescue => e
+      ratchetio_debug "[Ratchet.io] Exception while reporting exception to Ratchet.io: #{e.try(:message)}"
+    end
+
+    def ratchetio_debug(message, level = :debug)
+      if defined?(Rails)
+        ::Rails.logger.send(level, message)
+      else
+        puts message
+      end
+    end
+  end
+end

data/lib/ratchetio/middleware/rack/builder.rb

@@ -0,0 +1,21 @@
+module Ratchetio
+  module Middleware
+    module Rack
+      module Builder
+        include ExceptionReporter
+
+        def call_with_ratchetio(env)
+          call_without_ratchetio(env)
+        rescue => exception
+          report_exception_to_ratchetio(env, exception)
+          raise exception
+        end
+
+        def self.included(base)
+          base.send(:alias_method, :call_without_ratchetio, :call)
+          base.send(:alias_method, :call, :call_with_ratchetio)
+        end
+      end
+    end
+  end
+end

data/lib/ratchetio/middleware/rack/test_session.rb

@@ -0,0 +1,31 @@
+module Ratchetio
+  module Middleware
+    module Rack
+      module TestSession
+        include ExceptionReporter
+
+        def process_request_with_ratchetio(uri, env, &block)
+          process_request_without_ratchetio(uri, env, &block)
+        rescue => exception
+          report_exception_to_ratchetio(env, exception)
+          raise exception
+        end
+
+        def env_for_with_ratchetio(path, env)
+          env_for_without_ratchetio(path, env)
+        rescue => exception
+          report_exception_to_ratchetio(env, exception)
+          raise exception
+        end
+
+        def self.included(base)
+          base.send(:alias_method, :process_request_without_ratchetio, :process_request)
+          base.send(:alias_method, :process_request, :process_request_with_ratchetio)
+
+          base.send(:alias_method, :env_for_without_ratchetio, :env_for)
+          base.send(:alias_method, :env_for, :env_for_with_ratchetio)
+        end
+      end
+    end
+  end
+end

data/lib/ratchetio/middleware/rails/show_exceptions.rb

@@ -0,0 +1,26 @@
+module Ratchetio
+  module Middleware
+    module Rails
+      module ShowExceptions
+        include ExceptionReporter
+
+        def render_exception_with_ratchetio(env, exception)
+          report_exception_to_ratchetio(env, exception)
+          render_exception_without_ratchetio(env, exception)
+        end
+
+        def call_with_ratchetio(env)
+          call_without_ratchetio(env)
+        rescue => exception
+          report_exception_to_ratchetio(env, exception)
+          raise exception
+        end
+
+        def self.included(base)
+          base.send(:alias_method_chain, :render_exception, :ratchetio)
+          base.send(:alias_method_chain, :call, :ratchetio)
+        end
+      end
+    end
+  end
+end

data/lib/ratchetio/rack.rb

@@ -0,0 +1,9 @@
+if defined?(Rack::Builder)
+  require 'ratchetio/middleware/rack/builder'
+  Rack::Builder.send(:include, Ratchetio::Middleware::Rack::Builder)
+end
+
+if defined?(Rack::Test::Session)
+  require 'ratchetio/middleware/rack/test_session'
+  Rack::Test::Session.send(:include, Ratchetio::Middleware::Rack::TestSession)
+end

data/lib/ratchetio/rails/controller_methods.rb

@@ -1,28 +1,16 @@
 module Ratchetio
   module Rails
     module ControllerMethods
-    
-      def ratchetio_request_data
-        { 
-          :params => ratchetio_filter_params(params),
-          :url => ratchetio_request_url,
-          :user_ip => ratchetio_user_ip,
-          :headers => ratchetio_request_headers,
-          :GET => request.GET.to_hash,
-          # leaving out POST for now
-          :session => ratchetio_session_data,
-          :method => request.method,
-        }
-      end
+      include RequestDataExtractor
 
       def ratchetio_person_data
         user = send(Ratchetio.configuration.person_method)
         # include id, username, email if non-empty
         if user
-          { 
-            :id => begin user.send(Ratchetio.configuration.person_id_method) rescue nil end,
-            :username => begin user.send(Ratchetio.configuration.person_username_method) rescue nil end,
-            :email => begin user.send(Ratchetio.configuration.person_email_method) rescue nil end
+          {
+            :id => (user.send(Ratchetio.configuration.person_id_method) rescue nil),
+            :username => (user.send(Ratchetio.configuration.person_username_method) rescue nil),
+            :email => (user.send(Ratchetio.configuration.person_email_method) rescue nil)
           }
         else
           {}
@@ -31,74 +19,8 @@ module Ratchetio
         {}
       end
 
-      private
-
-      def ratchetio_filter_params(params)
-        filtered = {}
-        
-        params.to_hash.each_pair do |k,v|
-          if v.is_a? ActionDispatch::Http::UploadedFile
-            # only save content_type, original_filename, and length
-            begin
-              filtered[k] = { 
-                :content_type => v.content_type, 
-                :original_filename => v.original_filename, 
-                :size => v.tempfile.size 
-              }
-            rescue
-              filtered[k] = 'Uploaded file'
-            end
-          elsif v.is_a? Hash
-            filtered[k] = ratchetio_filter_params v
-          elsif Ratchetio.configuration.scrub_fields.include? k.to_sym
-            filtered[k] = "*" * v.length
-          else
-            filtered[k] = v
-          end
-        end
-        filtered
-      end
-
-      def ratchetio_request_url
-        url = "#{request.protocol}#{request.host}"
-        unless [80, 443].include?(request.port)
-          url << ":#{request.port}"
-        end
-        url << request.fullpath
-        url
-      end
-
-      def ratchetio_user_ip
-        # priority: X-Real-Ip, then X-Forwarded-For, then request.remote_ip
-        real_ip = request.env['HTTP_X_REAL_IP']
-        if real_ip
-          return real_ip
-        end
-        forwarded_for = request.env['HTTP_X_FORWARDED_FOR']
-        if forwarded_for
-          return forwarded_for
-        end
-        request.remote_ip
-      end
-
-      def ratchetio_request_headers
-        headers = {}
-        request.env.each_pair do |k,v|
-          if k.match(/^HTTP_/)
-            # convert HTTP_CONTENT_TYPE to Content-Type, etc.
-            name = k.split("_", 2)[1].sub("_", "-").split(/(\W)/).map(&:capitalize).join
-            headers[name] = v
-          end
-        end
-        headers
-      end
-
-      def ratchetio_session_data
-        if session.respond_to?(:to_hash)
-          ratchetio_filter_params(session.to_hash)
-        else
-          session.data
-        end
+      def ratchetio_request_data
+        extract_request_data_from_rack(request.env)
       end
 
     end

data/lib/ratchetio/railtie.rb

@@ -22,16 +22,15 @@ module Ratchetio
         include Ratchetio::Rails::ControllerMethods
       end
 
-      if defined?(::ActionDispatch::DebugExceptions)
-        # rails 3.2.x
-        require 'ratchetio/rails/middleware/exception_catcher'
-        ::ActionDispatch::DebugExceptions.send(:include, Ratchetio::Rails::Middleware::ExceptionCatcher)
-      elsif defined?(::ActionDispatch::ShowExceptions)
-        # rails 3.0.x and 3.1.x
-        require 'ratchetio/rails/middleware/exception_catcher'
-        ::ActionDispatch::ShowExceptions.send(:include, Ratchetio::Rails::Middleware::ExceptionCatcher)
+      if defined?(ActionDispatch::DebugExceptions)
+        # Rails 3.2.x
+        require 'ratchetio/middleware/rails/show_exceptions'
+        ActionDispatch::DebugExceptions.send(:include, Ratchetio::Middleware::Rails::ShowExceptions)
+      elsif defined?(ActionDispatch::ShowExceptions)
+        # Rails 3.0.x and 3.1.x
+        require 'ratchetio/middleware/rails/show_exceptions'
+        ActionDispatch::ShowExceptions.send(:include, Ratchetio::Middleware::Rails::ShowExceptions)
       end
-
     end
   end
 end

data/lib/ratchetio/request_data_extractor.rb

@@ -0,0 +1,115 @@
+module Ratchetio
+  module RequestDataExtractor
+    ATTACHMENT_CLASSES = %w[
+      ActionDispatch::Http::UploadedFile
+      Rack::Multipart::UploadedFile
+    ].freeze
+
+    def extract_person_data_from_controller(env)
+      controller = env['action_controller.instance']
+      person_data = controller ? controller.try(:ratchetio_person_data) : {}
+    end
+
+    def extract_request_data_from_rack(env)
+      sensitive_params = sensitive_params_list(env)
+      request_params = ratchetio_request_params(env)
+      cookies = ratchetio_filtered_params(sensitive_params, ratchetio_request_cookies(env))
+      get_params = ratchetio_filtered_params(sensitive_params, ratchetio_get_params(env))
+      post_params = ratchetio_filtered_params(sensitive_params, ratchetio_post_params(env))
+    
+      {
+        :params => get_params.merge(post_params).merge(request_params),
+        :url => ratchetio_url(env),
+        :user_ip => ratchetio_user_ip(env),
+        :headers => ratchetio_headers(env),
+        :GET => get_params,
+        :POST => post_params,
+        :cookies => cookies,
+        :session => env['rack.session.options'],
+        :method => ratchetio_request_method(env)
+      }
+    end
+
+    private
+
+    def ratchetio_request_method(env)
+      env['REQUEST_METHOD'] || env[:method]
+    end
+
+    def ratchetio_headers(env)
+      env.keys.grep(/^HTTP_/).map do |header|
+        name = header.gsub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+        { name => env[header] }
+      end.inject(:merge)
+    end
+
+    def ratchetio_url(env)
+      scheme = env['rack.url_scheme']
+      host = env['HTTP_HOST'] || env['SERVER_NAME']
+      path = env['ORIGINAL_FULLPATH'] || env['REQUEST_URI']
+      unless path.nil? || path.empty?
+        path = '/' + path.to_s if path.to_s.slice(0, 1) != '/'
+      end
+
+      [scheme, '://', host, path].join
+    end
+
+    def ratchetio_user_ip(env)
+      (env['action_dispatch.remote_ip'] || env['HTTP_X_REAL_IP'] || env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR']).to_s
+    end
+
+    def ratchetio_request_params(env)
+      route = ::Rails.application.routes.recognize_path(env['PATH_INFO']) rescue {}
+      {
+        :controller => route[:controller],
+        :action => route[:action],
+        :format => route[:format],
+      }
+    end
+
+    def ratchetio_get_params(env)
+      rack_request(env).GET
+    rescue
+      {}
+    end
+
+    def ratchetio_post_params(env)
+      rack_request(env).POST
+    rescue
+      {}
+    end
+
+    def ratchetio_request_cookies(env)
+      rack_request(env).cookie
+    rescue
+      {}
+    end
+
+    def rack_request(env)
+      @rack_request ||= Rack::Request.new(env)
+    end
+
+    def ratchetio_filtered_params(sensitive_params, params)
+      params.inject({}) do |result, (key, value)|
+        if key.to_sym.in?(sensitive_params)
+          result[key] = '*' * (value.length rescue 8)
+        elsif value.is_a?(Hash)
+          result[key] = ratchetio_filtered_params(sensitive_params, value)
+        elsif value.class.name.in?(ATTACHMENT_CLASSES)
+          result[key] = {
+            :content_type => value.content_type,
+            :original_filename => value.original_filename,
+            :size => value.tempfile.size
+          } rescue 'Uploaded file'
+        else
+          result[key] = value
+        end
+        result
+      end
+    end
+
+    def sensitive_params_list(env)
+      Ratchetio.configuration.scrub_fields |= Array(env['action_dispatch.parameter_filter'])
+    end
+  end
+end

data/lib/ratchetio/sidekiq.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Ratchetio
+  class Sidekiq
+    def call(worker, msg, queue)
+      begin
+        yield
+      rescue => e
+        msg.delete('backtrace')
+        msg.delete('error_backtrace')
+        msg.delete('error_message')
+        msg.delete('error_class')
+
+        Ratchetio.report_exception(e, :params => msg)
+        raise
+      end
+    end
+  end
+end
+
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Ratchetio::Sidekiq
+  end
+end

data/lib/ratchetio/version.rb

@@ -1,3 +1,3 @@
 module Ratchetio
-  VERSION = "0.5.5"
+  VERSION = "0.6.0"
 end

data/lib/ratchetio.rb

@@ -6,15 +6,21 @@ require 'uri'
 
 require "girl_friday" if defined?(GirlFriday)
 
+require 'ratchetio/version'
 require 'ratchetio/configuration'
+require 'ratchetio/request_data_extractor'
+require 'ratchetio/exception_reporter'
+
 require 'ratchetio/delayed_job' if defined?(Delayed) && defined?(Delayed::Plugins)
+require 'ratchetio/sidekiq' if defined?(Sidekiq)
 require 'ratchetio/goalie' if defined?(Goalie)
+require 'ratchetio/rack' if defined?(Rack)
 require 'ratchetio/railtie' if defined?(Rails)
-require 'ratchetio/version'
 
 module Ratchetio
   class << self
     attr_writer :configuration
+    attr_reader :last_report
 
     # Configures the gem.
     #
@@ -57,24 +63,21 @@ module Ratchetio
     # @param person_data [Hash] Data describing the affected person. Should be the result of calling
     #   `ratchetio_person_data`
     def report_exception(exception, request_data = nil, person_data = nil)
-      unless configuration.enabled
-        return
-      end
-
-      if ignored?(exception)
-        return
-      end
+      return 'disabled' unless configuration.enabled
+      return 'ignored' if ignored?(exception)
 
       data = exception_data(exception, filtered_level(exception))
       data[:request] = request_data if request_data
       data[:person] = person_data if person_data
 
+      @last_report = data
+
       payload = build_payload(data)
       schedule_payload(payload)
       data
     rescue => e
       logger.error "[Ratchet.io] Error reporting exception to Ratchet.io: #{e}"
-      nil
+      'error'
     end
 
     # Reports an arbitrary message to Ratchet.io
@@ -274,7 +277,7 @@ module Ratchetio
         :access_token => configuration.access_token,
         :data => data
       }
-      ActiveSupport::JSON.encode(payload)
+      MultiJson.dump(payload)
     end
 
     def base_data(level = 'error')

data/ratchetio.gemspec

@@ -14,9 +14,9 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Ratchetio::VERSION
 
-  gem.add_runtime_dependency 'activesupport', '~> 3.2.9'
+  gem.add_runtime_dependency 'multi_json', '~> 1.5.0'
 
-  gem.add_development_dependency 'rails', '~> 3.2.9'
+  gem.add_development_dependency 'rails', '~> 3.2.11'
   gem.add_development_dependency 'devise', '>= 2.1.2'
   gem.add_development_dependency 'rspec-rails', '~> 2.12.0'
   gem.add_development_dependency 'database_cleaner', '>= 0.9.1'

data/spec/controllers/home_controller_spec.rb

@@ -1,7 +1,8 @@
 require 'spec_helper'
 
 describe HomeController do
-  
+  let(:logger_mock) { double("Rails.logger").as_null_object }
+
   before(:each) do
     reset_configuration
     Ratchetio.configure do |config|
@@ -12,8 +13,6 @@ describe HomeController do
       config.logger = logger_mock
     end
   end
-    
-  let(:logger_mock) { double("Rails.logger").as_null_object }
 
   context "ratchetio controller methods" do
     # TODO run these for a a more-real request
@@ -43,14 +42,14 @@ describe HomeController do
           :tempfile => "dummy"
         }
         file = ActionDispatch::Http::UploadedFile.new(file_hash)
-        
+
         params = {
           :name => name,
           :a_file => file
         }
 
-        filtered = controller.send(:ratchetio_filter_params, params)
-        
+        filtered = controller.send(:ratchetio_filtered_params, Ratchetio.configuration.scrub_fields, params)
+
         filtered[:name].should == name
         filtered[:a_file].should be_a_kind_of(Hash)
         filtered[:a_file][:content_type].should == file_hash[:type]
@@ -67,7 +66,7 @@ describe HomeController do
           :tempfile => "dummy"
         }
         file = ActionDispatch::Http::UploadedFile.new(file_hash)
-        
+
         params = {
           :name => name,
           :wrapper => {
@@ -78,18 +77,18 @@ describe HomeController do
           }
         }
 
-        filtered = controller.send(:ratchetio_filter_params, params)
-        
+        filtered = controller.send(:ratchetio_filtered_params, Ratchetio.configuration.scrub_fields, params)
+
         filtered[:name].should == name
         filtered[:wrapper][:wrapper2][:foo].should == "bar"
-        
+
         filtered_file = filtered[:wrapper][:wrapper2][:a_file]
         filtered_file.should be_a_kind_of(Hash)
         filtered_file[:content_type].should == file_hash[:type]
         filtered_file[:original_filename].should == file_hash[:filename]
         filtered_file[:size].should == file_hash[:tempfile].size
       end
-      
+
       it "should scrub the default scrub_fields" do
         params = {
           :passwd => "hidden",
@@ -97,29 +96,29 @@ describe HomeController do
           :secret => "hidden",
           :notpass => "visible"
         }
-        
-        filtered = controller.send(:ratchetio_filter_params, params)
-        
+
+        filtered = controller.send(:ratchetio_filtered_params, Ratchetio.configuration.scrub_fields, params)
+
         filtered[:passwd].should == "******"
         filtered[:password].should == "******"
         filtered[:secret].should == "******"
         filtered[:notpass].should == "visible"
       end
-      
+
       it "should scrub custom scrub_fields" do
         Ratchetio.configure do |config|
           config.scrub_fields = [:notpass, :secret]
         end
-        
+
         params = {
           :passwd => "visible",
           :password => "visible",
           :secret => "hidden",
           :notpass => "hidden"
         }
-        
-        filtered = controller.send(:ratchetio_filter_params, params)
-        
+
+        filtered = controller.send(:ratchetio_filtered_params, Ratchetio.configuration.scrub_fields, params)
+
         filtered[:passwd].should == "visible"
         filtered[:password].should == "visible"
         filtered[:secret].should == "******"
@@ -132,7 +131,7 @@ describe HomeController do
         req = controller.request
         req.host = 'ratchet.io'
 
-        controller.send(:ratchetio_request_url).should == 'http://ratchet.io'
+        controller.send(:ratchetio_request_data)[:url].should == 'http://ratchet.io'
       end
     end
 
@@ -140,16 +139,16 @@ describe HomeController do
       it "should use X-Real-Ip when set" do
         controller.request.env["HTTP_X_REAL_IP"] = '1.1.1.1'
         controller.request.env["HTTP_X_FORWARDED_FOR"] = '1.2.3.4'
-        controller.send(:ratchetio_user_ip).should == '1.1.1.1'
+        controller.send(:ratchetio_request_data)[:user_ip].should == '1.1.1.1'
       end
 
       it "should use X-Forwarded-For when set" do
         controller.request.env["HTTP_X_FORWARDED_FOR"] = '1.2.3.4'
-        controller.send(:ratchetio_user_ip).should == '1.2.3.4'
+        controller.send(:ratchetio_request_data)[:user_ip].should == '1.2.3.4'
       end
 
       it "should use the remote_addr when neither is set" do
-        controller.send(:ratchetio_user_ip).should == '0.0.0.0'
+        controller.send(:ratchetio_request_data)[:user_ip].should == '0.0.0.0'
       end
     end
 
@@ -172,15 +171,10 @@ describe HomeController do
     end
   end
 
-  # TODO need to figure out how to make a test request that uses enough of the middleware
-  # that it invokes the ratchetio exception catcher. just plain "get 'some_url'" doesn't
-  # seem to work.
-  it "should report uncaught exceptions"
-  
   after(:each) do
     Ratchetio.configure do |config|
       config.logger = ::Rails.logger
     end
   end
-  
+
 end

data/spec/dummyapp/app/controllers/home_controller.rb

@@ -18,4 +18,8 @@ class HomeController < ApplicationController
   def cause_exception
     foo = bar
   end
+
+  def current_user
+    User.find_by_encrypted_password(cookies[:session_id])
+  end
 end

data/spec/dummyapp/app/controllers/users_controller.rb

@@ -9,4 +9,9 @@ class UsersController < ApplicationController
     @user = User.find(params[:id])
   end
 
+  def start_session
+    @user = User.find(params[:id])
+    cookies[:session_id] = @user.encrypted_password
+  end
+
 end

data/spec/dummyapp/app/models/user.rb

@@ -7,5 +7,4 @@ class User < ActiveRecord::Base
 
   # Setup accessible (or protected) attributes for your model
   attr_accessible :name, :email, :password, :password_confirmation, :remember_me
-  
 end

data/spec/dummyapp/config/routes.rb

@@ -4,8 +4,11 @@ Dummy::Application.routes.draw do
   end
   root :to => "home#index"
   devise_for :users
-  resources :users
+  resources :users do
+    member { post :start_session }
+  end
 
   match "/cause_exception" => "home#cause_exception"
   match "/report_exception" => "home#report_exception"
+  match "/current_user" => "home#current_user"
 end

data/spec/ratchetio_spec.rb

@@ -93,7 +93,7 @@ describe Ratchetio do
     it 'should report exception objects with no backtrace' do
       payload = nil
       Ratchetio.stub(:schedule_payload) do |*args|
-        payload = JSON.parse( args[0] )
+        payload = MultiJson.load(args[0])
       end
       Ratchetio.report_exception(StandardError.new("oops"))
       payload["data"]["body"]["trace"]["frames"].should == []
@@ -227,6 +227,8 @@ describe Ratchetio do
     let(:logger_mock) { double("Rails.logger").as_null_object }
 
     it 'should send the payload using the default asynchronous handler girl_friday' do
+      logger_mock.should_receive(:info).with('[Ratchet.io] Scheduling payload')
+      logger_mock.should_receive(:info).with('[Ratchet.io] Sending payload')
       logger_mock.should_receive(:info).with('[Ratchet.io] Success')
 
       Ratchetio.configure do |config|
@@ -361,15 +363,13 @@ describe Ratchetio do
   context 'build_payload' do
     it 'should build valid json' do
       json = Ratchetio.send(:build_payload, {:foo => {:bar => "baz"}})
-      hash = ActiveSupport::JSON.decode(json)
+      hash = MultiJson.load(json)
       hash["data"]["foo"]["bar"].should == "baz"
     end
   end
 
   context 'base_data' do
-    before(:each) do
-      configure
-    end
+    before(:each) { configure }
 
     it 'should have the correct notifier name' do
       Ratchetio.send(:base_data)[:notifier][:name].should == 'ratchetio-gem'

data/spec/requests/home_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe HomeController do
+  let(:logger_mock) { double("Rails.logger").as_null_object }
+
+  before(:each) do
+    reset_configuration
+    Ratchetio.configure do |config|
+      config.access_token = 'aaaabbbbccccddddeeeeffff00001111'
+      config.environment = ::Rails.env
+      config.root = ::Rails.root
+      config.framework = "Rails: #{::Rails::VERSION::STRING}"
+      config.logger = logger_mock
+    end
+  end
+
+  context "with broken request" do
+    it "should report uncaught exceptions" do
+      expect{ get 'current_user', nil, :cookie => '8%B' }.to raise_exception
+
+      exception_info = Ratchetio.last_report[:body][:trace][:exception]
+      exception_info[:class].should == 'ArgumentError'
+      exception_info[:message].should == 'invalid %-encoding (8%B)'
+    end
+  end
+
+  context "with error hiding deep inside" do
+    let!(:cookie_method_name){ :[] }
+    let!(:original_cookie_method){ ActionDispatch::Cookies::CookieJar.instance_method(cookie_method_name) }
+    let!(:broken_cookie_method){ Proc.new{ |name| "1" - 1 } }
+
+    before(:each) do
+      ActionDispatch::Cookies::CookieJar.send(:define_method, cookie_method_name, broken_cookie_method)
+    end
+
+    after(:each) do
+      ActionDispatch::Cookies::CookieJar.send(:define_method, cookie_method_name, original_cookie_method)
+    end
+
+    it "should report uncaught exceptions" do
+      expect{ get 'current_user' }.to raise_exception
+
+      exception_info = Ratchetio.last_report[:body][:trace][:exception]
+      exception_info[:class].should == 'NoMethodError'
+      # exception_info[:message].should == 'undefined method `-\' for "1":String'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 require 'rubygems'
 
-ENV['RAILS_ENV'] ||= 'test'
+ENV['RAILS_ENV'] = 'test'
 require File.expand_path('../dummyapp/config/environment', __FILE__)
 require 'rspec/rails'
 require 'database_cleaner'
@@ -26,10 +26,10 @@ RSpec.configure do |config|
   config.after(:each) do
     DatabaseCleaner.clean
   end
-  
+
 end
 
 def reset_configuration
   Ratchetio.reconfigure do |config|
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ratchetio
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,16 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-26 00:00:00.000000000 Z
+date: 2013-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: multi_json
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.2.9
+        version: 1.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.2.9
+        version: 1.5.0
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -34,7 +34,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.2.9
+        version: 3.2.11
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 3.2.9
+        version: 3.2.11
 - !ruby/object:Gem::Dependency
   name: devise
   requirement: !ruby/object:Gem::Requirement
@@ -127,12 +127,18 @@ files:
 - lib/ratchetio.rb
 - lib/ratchetio/configuration.rb
 - lib/ratchetio/delayed_job.rb
+- lib/ratchetio/exception_reporter.rb
 - lib/ratchetio/goalie.rb
+- lib/ratchetio/middleware/rack/builder.rb
+- lib/ratchetio/middleware/rack/test_session.rb
+- lib/ratchetio/middleware/rails/show_exceptions.rb
+- lib/ratchetio/rack.rb
 - lib/ratchetio/rails.rb
 - lib/ratchetio/rails/controller_methods.rb
-- lib/ratchetio/rails/middleware/exception_catcher.rb
 - lib/ratchetio/railtie.rb
 - lib/ratchetio/rake_tasks.rb
+- lib/ratchetio/request_data_extractor.rb
+- lib/ratchetio/sidekiq.rb
 - lib/ratchetio/version.rb
 - ratchetio.gemspec
 - spec/controllers/home_controller_spec.rb
@@ -188,6 +194,7 @@ files:
 - spec/dummyapp/public/favicon.ico
 - spec/dummyapp/script/rails
 - spec/ratchetio_spec.rb
+- spec/requests/home_spec.rb
 - spec/spec_helper.rb
 - spec/support/devise.rb
 homepage: https://github.com/ratchetio/ratchetio-gem
@@ -268,6 +275,7 @@ test_files:
 - spec/dummyapp/public/favicon.ico
 - spec/dummyapp/script/rails
 - spec/ratchetio_spec.rb
+- spec/requests/home_spec.rb
 - spec/spec_helper.rb
 - spec/support/devise.rb
 has_rdoc: 

data/lib/ratchetio/rails/middleware/exception_catcher.rb

@@ -1,37 +0,0 @@
-module Ratchetio
-  module Rails
-    module Middleware
-      module ExceptionCatcher
-        def self.included(base)
-          base.send(:alias_method_chain, :render_exception, :ratchetio)
-        end
-
-        def render_exception_with_ratchetio(env, exception)
-          exception_data = nil
-          begin
-            controller = env['action_controller.instance']
-            request_data = controller.try(:ratchetio_request_data)
-            person_data = controller.try(:ratchetio_person_data)
-            exception_data = Ratchetio.report_exception(exception, request_data, person_data)
-          rescue => e
-            # TODO use logger here?
-            puts "[Ratchet.io] Exception while reporting exception to Ratchet.io: #{e}" 
-          end
-
-          # if an exception was reported, save uuid in the env
-          # so it can be displayed to the user on the error page
-          if exception_data
-            begin
-              env['ratchetio.exception_uuid'] = exception_data[:uuid]
-            rescue => e
-              puts "[Ratchet.io] Exception saving uuid in env: #{e}"
-            end
-          end
-
-          # now continue as normal
-          render_exception_without_ratchetio(env, exception)
-        end
-      end
-    end
-  end
-end