ratchetio 0.4.7 → 0.4.8

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+**0.4.8**
+- Add ability to send reports asynchronously, using girl_friday or Threading by default.
+- Add ability to save reports to a file (for use with ratchet-agent) instead of sending across to Ratchet servers.
+
 **0.4.7**
 - Sensitive params now scrubbed out of requests. Param name list is customizable via the `scrub_fields` config option.
 

data/Gemfile

@@ -5,3 +5,4 @@ gemspec
 gem 'sqlite3',                          :platform => [:ruby, :mswin, :mingw]
 gem 'jruby-openssl',                    :platform => :jruby
 gem 'activerecord-jdbcsqlite3-adapter', :platform => :jruby
+gem 'girl_friday'

data/README.md

@@ -85,7 +85,7 @@ If the methods to extract the `id`, `username`, and `email` from the object retu
 
 ## Exception level filters
 
-By default, all exceptions reported through `Ratchetio.report_exception()` are reporeted at the "error" level, except for the following, which are reported at "warning" level:
+By default, all exceptions reported through `Ratchetio.report_exception()` are reported at the "error" level, except for the following, which are reported at "warning" level:
 
 - ActiveRecord::RecordNotFound
 - AbstractController::ActionNotFound
@@ -94,6 +94,41 @@ By default, all exceptions reported through `Ratchetio.report_exception()` are r
 If you'd like to customize this list, see the example code in `config/initializers/ratchetio.rb`. Supported levels: "critical", "error", "warning", "info", "debug", "ignore". Set to "ignore" to cause the exception not to be reported at all.
 
 
+
+## Asynchronous reporting
+
+By default, all messages are reported synchronously. You can enable asynchronous reporting by adding the following in `config/initializers/ratchetio.rb`:
+
+```ruby
+  config.use_async = true
+```
+
+Ratchet uses [girl_friday](https://github.com/mperham/girl_friday) to handle asynchronous reporting when installed, and falls back to Threading if girl_friday is not installed.
+
+You can supply your own handler using `config.async_handler`. The handler should schedule the payload for later processing (i.e. with a delayed_job, in a resque queue, etc.) and should itself return immediately. For example:
+
+```ruby
+  config.async_handler = Proc.new { |payload|
+    Thread.new { Ratchetio.process_payload(payload) }
+  }
+```
+
+Make sure you pass `payload` to `Ratchetio.process_payload` in your own implementation.
+
+
+## Using with ratchet-agent
+
+For even more asynchrony, you can configure the gem to write to a file instead of sending the payload to Ratchet servers directly. [ratchet-agent](https://github.com/ratchetio/ratchet-agent) can then be hooked up to this file to actually send the payload across. To enable, add the following in `config/initializers/ratchetio.rb`:
+
+```ruby
+  config.write_to_file = true
+  # optional, defaults to "#{AppName}.ratchet"
+  config.filepath = '/path/to/file.ratchet' #should end in '.ratchet' for use with ratchet-agent
+```
+
+For this to work, you'll also need to set up ratchet-agent--see its docs for details.
+
+
 ## Help / Support
 
 If you run into any issues, please email us at `support@ratchet.io`

data/lib/generators/ratchetio/templates/initializer.rb

@@ -17,4 +17,12 @@ Ratchetio.configure do |config|
   # Valid levels: 'critical', 'error', 'warning', 'info', 'debug', 'ignore'
   # 'ignore' will cause the exception to not be reported at all.
   # config.exception_level_filters.merge!('MyCriticalException' => 'critical')
+  
+  # Enable asynchronous reporting (uses girl_friday or Threading if girl_friday
+  # is not installed)
+  # config.use_async = true
+  # Supply your own async handler:
+  # config.async_handler = Proc.new { |payload|
+  #  Thread.new { Ratchetio.process_payload(payload) }
+  # }
 end

data/lib/ratchetio/configuration.rb

@@ -8,6 +8,8 @@ module Ratchetio
     attr_accessor :default_logger
     attr_accessor :enabled
     attr_accessor :endpoint
+    attr_accessor :write_to_file
+    attr_accessor :filepath
     attr_accessor :environment
     attr_accessor :exception_level_filters
     attr_accessor :framework
@@ -18,6 +20,8 @@ module Ratchetio
     attr_accessor :person_email_method
     attr_accessor :root
     attr_accessor :scrub_fields
+    attr_accessor :use_async
+    attr_accessor :async_handler
 
     DEFAULT_ENDPOINT = 'https://submit.ratchet.io/api/1/item/'
 
@@ -25,6 +29,7 @@ module Ratchetio
       @default_logger = lambda { Logger.new(STDERR) }
       @enabled = true
       @endpoint = DEFAULT_ENDPOINT
+      @write_to_file = false
       @framework = 'Plain'
       @exception_level_filters = {
         'ActiveRecord::RecordNotFound' => 'warning',
@@ -36,6 +41,8 @@ module Ratchetio
       @person_username_method = 'username'
       @person_email_method = 'email'
       @scrub_fields = [:passwd, :password, :secret]
+      @use_async = false
+      @async_handler = nil
     end
 
     # allow params to be read like a hash

data/lib/ratchetio/railtie.rb

@@ -13,6 +13,7 @@ module Ratchetio
         config.environment ||= ::Rails.env
         config.root ||= ::Rails.root
         config.framework = "Rails: #{::Rails::VERSION::STRING}"
+        config.filepath ||= ::Rails.application.class.parent_name + '.ratchet'
       end
 
       ActiveSupport.on_load(:action_controller) do

data/lib/ratchetio/version.rb

@@ -1,3 +1,3 @@
 module Ratchetio
-  VERSION = "0.4.7"
+  VERSION = "0.4.8"
 end

data/lib/ratchetio.rb

@@ -1,11 +1,13 @@
 require 'net/https'
 require 'socket'
+require 'thread'
 require 'uri'
 
 require 'ratchetio/version'
 require 'ratchetio/configuration'
 require 'ratchetio/railtie' if defined?(Rails)
 require 'ratchetio/goalie' if defined?(Goalie)
+require "girl_friday" if defined?(GirlFriday)
 
 module Ratchetio
   class << self
@@ -67,7 +69,7 @@ module Ratchetio
       data[:person] = person_data if person_data
 
       payload = build_payload(data)
-      send_payload(payload)
+      schedule_payload(payload)
     rescue => e
       logger.error "[Ratchet.io] Error reporting exception to Ratchet.io: #{e}"
     end
@@ -90,11 +92,23 @@ module Ratchetio
       
       data = message_data(message, level, extra_data)
       payload = build_payload(data)
-      send_payload(payload)
+      schedule_payload(payload)
     rescue => e
       logger.error "[Ratchet.io] Error reporting message to Ratchet.io: #{e}"
     end
 
+    def process_payload(payload)
+      begin
+        if configuration.write_to_file
+          write_payload(payload)
+        else
+          send_payload(payload)
+        end
+      rescue => e
+        logger.error "[Ratchet.io] Error reporting message to Ratchet.io: #{e}"
+      end
+    end
+
     private
 
     def message_data(message, level, extra_data)
@@ -147,10 +161,36 @@ module Ratchetio
       end
       configuration.logger
     end
-
+    
+    def write_payload(payload)
+      if configuration.use_async
+        @file_semaphore.synchronize {
+          do_write_payload(payload)
+        }
+      else
+        do_write_payload(payload)
+      end
+    end
+    
+    def do_write_payload(payload)
+      logger.info '[Ratchet.io] Writing payload to file'
+      
+      begin
+        unless @file
+          @file = File.open(configuration.filepath, "a")
+        end
+        
+        @file.puts payload
+        @file.flush
+        logger.info "[Ratchet.io] Success"
+      rescue IOError => e
+        logger.error "[Ratchet.io] Error opening/writing to file: #{e}"
+      end
+    end
+    
     def send_payload(payload)
       logger.info '[Ratchet.io] Sending payload'
-
+    
       uri = URI.parse(configuration.endpoint)
       http = Net::HTTP.new(uri.host, uri.port)
       
@@ -170,6 +210,26 @@ module Ratchetio
         logger.info "[Ratchet.io] Response: #{response.body}"
       end
     end
+    
+    def schedule_payload(payload)
+      logger.info '[Ratchet.io] Scheduling payload'
+      
+      if configuration.use_async
+        unless configuration.async_handler
+          configuration.async_handler = method(:default_async_handler)
+        end
+        
+        if configuration.write_to_file
+          unless @file_semaphore
+            @file_semaphore = Mutex.new
+          end
+        end
+        
+        configuration.async_handler.call(payload)
+      else
+        process_payload(payload)
+      end
+    end
 
     def build_payload(data)
       payload = {
@@ -205,6 +265,20 @@ module Ratchetio
       
       data
     end
-  
+    
+    def default_async_handler(payload)
+      if defined?(GirlFriday)
+        unless @queue
+          @queue = GirlFriday::WorkQueue.new(nil, :size => 5) do |payload|
+            process_payload(payload)
+          end
+        end
+        
+        @queue.push(payload)
+      else
+        logger.warn '[Ratchet.io] girl_friday not found to handle async call, falling back to Thread'
+        Thread.new { process_payload(payload) }
+      end
+    end
   end
 end

data/ratchetio.gemspec

@@ -18,4 +18,5 @@ Gem::Specification.new do |gem|
   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'
+  gem.add_development_dependency 'girl_friday', '>= 0.11.1'
 end

data/spec/ratchetio_spec.rb

@@ -125,6 +125,107 @@ describe Ratchetio do
       end
     end
   end
+  
+  context 'payload_destination' do
+    before(:each) do
+      configure
+      Ratchetio.configure do |config|
+        config.logger = logger_mock
+        config.filepath = 'test.ratchet'
+      end
+      
+      begin
+        foo = bar
+      rescue => e
+        @exception = e
+      end
+    end
+    
+    let(:logger_mock) { double("Rails.logger").as_null_object }
+    
+    it 'should send the payload over the network by default' do
+      logger_mock.should_not_receive(:info).with('[Ratchet.io] Writing payload to file')
+      logger_mock.should_receive(:info).with('[Ratchet.io] Sending payload')
+      logger_mock.should_receive(:info).with('[Ratchet.io] Success')
+      Ratchetio.report_exception(@exception)
+    end
+    
+    it 'should save the payload to a file if set' do
+      logger_mock.should_not_receive(:info).with('[Ratchet.io] Sending payload')
+      logger_mock.should_receive(:info).with('[Ratchet.io] Writing payload to file')
+      logger_mock.should_receive(:info).with('[Ratchet.io] Success')
+      
+      filepath = ''
+      
+      Ratchetio.configure do |config|
+        config.write_to_file = true
+        filepath = config.filepath
+      end
+      
+      Ratchetio.report_exception(@exception)
+      
+      File.exist?(filepath).should == true
+      File.read(filepath).should include test_access_token
+      File.delete(filepath)
+      
+      Ratchetio.configure do |config|
+        config.write_to_file = false
+      end
+    end
+  end
+  
+  context 'asynchronous_handling' do
+    before(:each) do
+      configure
+      Ratchetio.configure do |config|
+        config.logger = logger_mock
+      end
+      
+      begin
+        foo = bar
+      rescue => e
+        @exception = e
+      end
+    end
+    
+    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] Success')
+      
+      Ratchetio.configure do |config|
+        config.use_async = true
+        GirlFriday::WorkQueue::immediate!
+      end
+      
+      Ratchetio.report_exception(@exception)
+      
+      Ratchetio.configure do |config|
+        config.use_async = false
+        GirlFriday::WorkQueue::queue!
+      end
+    end
+    
+    it 'should send the payload using a user-supplied asynchronous handler' do
+      logger_mock.should_receive(:info).with('Custom async handler called')
+      logger_mock.should_receive(:info).with('[Ratchet.io] Success')
+      
+      Ratchetio.configure do |config|
+        config.use_async = true
+        config.async_handler = Proc.new { |payload|
+          logger_mock.info 'Custom async handler called'
+          Ratchetio.process_payload(payload)
+        }
+      end
+      
+      Ratchetio.report_exception(@exception)
+      
+      Ratchetio.configure do |config|
+        config.use_async = false
+        config.async_handler = Ratchetio.method(:default_async_handler)
+      end
+    end
+  end
 
   context 'message_data' do
     before(:each) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ratchetio
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.4.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-05 00:00:00.000000000 Z
+date: 2012-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -75,6 +75,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: girl_friday
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.11.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.11.1
 description: Rails plugin to catch and send exceptions to Ratchet.io
 email:
 - brian@ratchet.io