whenauser 0.3.0 → 0.4.2

data/README.md

@@ -17,20 +17,47 @@ In your Gemfile:
 
     gem 'whenauser'
 
+You also need
 
-For Ruby on Rails
+    gem 'girl_friday', :git => 'git://github.com/mperham/girl_friday.git'
+    gem 'connection_pool', :git => 'git://github.com/mperham/connection_pool.git'
 
-You'll need to create two incoming channels in WhenAUser, and configure their tokens in `config/whenauser.rb` (the available options are explained below). You may want to create additional channels to use in other environments, eg for staging.
+until girl_friday ~> 0.9.7 and connection_pool ~> 0.9.2 are released.
 
-    token "CHANNEL_TOKEN"
+###For Ruby on Rails
+
+You should create two incoming channels in WhenAUser, and configure their tokens in `config/whenauser.rb` (the available options are explained below). You may want to create additional channels to use in other environments, eg for staging.
+
+    token 'CHANNEL_TOKEN'          # default channel (for user-centric events)
 
     middleware :errors do
-      token "ERROR_CHANNEL_TOKEN"
+      token 'ERROR_CHANNEL_TOKEN'  # channel for error-centric events
     end
+    
+###As general-purpose Rack middleware, without Rails
+
+    config.middleware.use 'WhenAUser::Rack',       :token => 'CHANNEL_TOKEN_'
+    config.middleware.use 'WhenAUser::Exceptions', :token => 'ERROR_CHANNEL_TOKEN'
+
+Using girl_friday for asynchronous communication and persistence
+-----------------
+
+By default this gem sends a batch of events to the WhenAUser service synchronously, at the end of each request to your application. This means that each request to your app will be slowed down by the time it takes to do that communication. In general, this is not going to be acceptable. To avoid this delay, WhenAUser supports the use of the [girl_friday](https://github.com/mperham/girl_friday) gem, which you can enable in your whenauser.rb file:
+
+    queue WhenAUser::GirlFridayQueue
+
+You can also pass options to girl_friday. To avoid losing events when your app server instances restart, you can tell girl_friday to use Redis:
+
+    queue WhenAUser::GirlFridayQueue, 
+      :store => GirlFriday::Store::Redis, :store_config => { :host => 'hostname', :port => 12345 }
+
+If you already have a Redis connection pool, you can tell girl_friday to use it:
+
+    queue WhenAUser::GirlFridayQueue, 
+      :store => GirlFriday::Store::Redis, :store_config => { :pool => $redis }
+
+See the [girl_friday wiki](https://github.com/mperham/girl_friday/wiki) for more information on how to use girl_friday.
 
-    middleware :pageviews do
-      ignore_if lambda { |env| env['action_controller.instance'].is_a? SillyController }
-    end
 
 Options
 -------
@@ -40,13 +67,14 @@ WhenAUser::Rack accepts these options:
 * `token` -- the token for a WhenAUser channel
 * `webhook_url` -- defaults to 'http://whenauser.com/events'
 * `middleware` -- takes the symbol for a middleware and a block, configuring it
+* `queue` -- takes the class used for queuing (default: WhenAUser::MemoryQueue), and an optional hash
 
 The `exceptions` middleware accepts these options:
 
+* `token` -- the token for a WhenAUser error channel
 * `ignore_exceptions` -- an array of exception class names, defaults to ['ActiveRecord::RecordNotFound', 'AbstractController::ActionNotFound', 'ActionController::RoutingError']
 * `ignore_crawlers` -- an array of strings to match against the user agent, includes a number of webcrawlers by default
 * `ignore_if` -- this proc is passed env and an exception; if it returns true, the exception is not reported to WhenAUser
-* `token` -- the token for a WhenAUser channel
 * `custom_data` -- this proc is passed env, and should return a hash to be merged into each event
 
 The `pageviews` middleware accepts these options:
@@ -55,6 +83,14 @@ The `pageviews` middleware accepts these options:
 * `ignore_if` -- this proc is passed env; if it returns true, the pageview is not reported to WhenAUser
 * `custom_data` -- this proc is passed env, and should return a hash to be merged into each event
 
+The WhenAUser::Pageviews middleware uses the same token as WhenAUser::Rack.
+
+Here's an example of how to skip sending any pageview events for all requests to the SillyController:
+
+    middleware :pageviews do
+      ignore_if lambda { |env| env['action_controller.instance'].is_a? SillyController }
+    end
+
 Sending other events
 --------------------
 

data/lib/whenauser/exceptions.rb

@@ -36,8 +36,7 @@ module WhenAUser
 
   private
     def send_event_now(event, token)
-      event[:_timestamp] = Time.now.to_f unless event[:_timestamp] || event['_timestamp']
-      WhenAUser.endpoint.post token, event.to_json
+      WhenAUser.post_payload_to_token WhenAUser.prepare_event(event), token
     end
 
     def should_be_ignored(env, exception)
@@ -73,7 +72,7 @@ module WhenAUser
         :_domain => 'exception',
         :_name => exception.class.to_s,
         :message => exception.to_s,
-        :backtrace => backtrace.join("\n"),
+        :backtrace => backtrace.join("; "),
         :request_url => request.url,
         :request_method => request.request_method,
         :params => request.params.except(*WhenAUser.filter_parameters),
@@ -82,7 +81,6 @@ module WhenAUser
       user = current_user(env)
       event.merge!(:current_user => user) if user
       event.merge!(:referer_url => request.referer) if request.referer
-      event.merge!(:rails_env => Rails.env) if defined?(Rails)
       event.merge!(@options[:custom_data].call(env))
       event
     end

data/lib/whenauser/girl_friday_queue.rb

@@ -0,0 +1,23 @@
+require 'girl_friday'
+
+module WhenAUser
+  class GirlFridayQueue < GirlFriday::WorkQueue
+
+    include Singleton
+  
+    def initialize
+      super(:whenauser, {:size => 1}.merge(WhenAUser.queue_options)) do |msg|
+        WhenAUser.post_payload_to_token msg[:payload], WhenAUser.token
+      end
+    end
+
+    def self.push *args
+      instance.push *args
+    end
+
+    def self.status
+      instance.status
+    end
+
+  end
+end

data/lib/whenauser/memory_queue.rb

@@ -0,0 +1,11 @@
+require 'girl_friday'
+
+module WhenAUser
+  class MemoryQueue
+
+    def self.push(hash)
+      WhenAUser.post_payload_to_token hash[:payload], WhenAUser.token
+    end
+
+  end
+end

data/lib/whenauser/railtie.rb

@@ -4,9 +4,9 @@ require 'action_controller/log_subscriber'
 
 module Whenauser
   class RailsConfigurator
-    attr_accessor :token, :webhook_url, :middlewares
+    attr_accessor :token, :webhook_url, :middlewares, :queue, :queue_options
     def initialize
-      @webhook_url = 'http://whenauser.com/events/'
+      @webhook_url = 'http://www.whenauser.com/events/'
       @middlewares = {}
     end
 
@@ -21,6 +21,15 @@ module Whenauser
     def middleware(middleware, &block)
       @middlewares[middleware] = MiddlewareConfigurator.apply(&block)
     end
+    
+    def queue(queue, options)
+      @queue = queue
+      @queue_options = options
+    end
+
+    def girl_friday_options(options)
+      @girl_friday_options = options
+    end
   end
 
   class MiddlewareConfigurator
@@ -61,11 +70,13 @@ module Whenauser
         Whenauser::RailsConfigurator.new.instance_eval do
           eval IO.read(filename), binding, filename.to_s, 1
           if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
-            ::Rails.configuration.middleware.insert_after 'Rack::Lock', 'WhenAUser::Rack',
+            ::Rails.configuration.middleware.insert_after 'ActionDispatch::Static', 'WhenAUser::Rack',
                 :webhook_url => @webhook_url,
-                :token => @token
+                :token => @token,
+                :queue => @queue,
+                :queue_options => @queue_options
             ::Rails.configuration.middleware.use('WhenAUser::Exceptions', @middlewares[:exceptions].configuration) if @middlewares.has_key?(:exceptions)
-            puts "configuration with: #{@middlewares[:pageviews].configuration}"
+            # puts "configuration with: #{@middlewares[:pageviews].configuration}"
             ::Rails.configuration.middleware.insert_after('WhenAUser::Rack', 'WhenAUser::Pageviews', @middlewares[:pageviews].configuration) if @middlewares.has_key?(:pageviews)
           end
         end

data/lib/whenauser/version.rb

@@ -1,3 +1,3 @@
 module WhenAUser
-  VERSION = '0.3.0'
+  VERSION = '0.4.2'
 end

data/lib/whenauser.rb

@@ -2,43 +2,59 @@ require 'whenauser/version'
 require 'whenauser/helpers'
 require 'whenauser/exceptions'
 require 'whenauser/pageviews'
-require 'faraday'
-require 'faraday_middleware'
+require 'whenauser/girl_friday_queue'
+require 'whenauser/memory_queue'
+require 'net/http'
+require 'uri'
 require 'active_support/core_ext/module/attribute_accessors'
 
 module WhenAUser
-  mattr_accessor :endpoint, :filter_parameters, :queue, :token
+  mattr_accessor :endpoint, :filter_parameters, :buffer, :token, :webhook_url, :queue, :queue_options
 
   def self.default_ignored_crawlers
     %w(Baidu Gigabot Googlebot libwww-perl lwp-trivial msnbot SiteUptime Slurp WordPress ZIBB ZyBorg Yandex Jyxobot Huaweisymantecspider ApptusBot)
   end
 
   def self.send_event(event)
-    event[:_timestamp] = Time.now.to_f unless event[:_timestamp] || event['_timestamp']
-    WhenAUser.queue << event
+    WhenAUser.buffer << WhenAUser.prepare_event(event)
   end
 
   def self.flush
-    return if (events = WhenAUser.queue).empty?
-    WhenAUser.queue = []
-    endpoint.post WhenAUser.token, events.to_json
+    return if (events = WhenAUser.buffer).empty?
+    WhenAUser.buffer = []
+    WhenAUser.queue.push(:payload => events)
+    # WhenAUser.post_payload_to_token events.to_json, WhenAUser.token
+  end
+  
+  def self.post_payload_to_token(payload, token)
+    uri = URI(WhenAUser.webhook_url + token)
+    req = Net::HTTP::Post.new(uri.path)
+    req.body = payload.to_json
+    req.content_type = 'application/json'
+    Net::HTTP.start(uri.host, uri.port) do |http|
+      http.request(req)
+    end
+  end
+  
+  def self.prepare_event(event)
+    event[:_timestamp] = Time.now.to_f unless event[:_timestamp] || event['_timestamp']
+    event[:rails_env] = Rails.env if defined?(Rails)
+    event
   end
 
   class Rack
     def initialize(app, options={})
-      options[:webhook_url] ||= 'http://whenauser.com/events/'
       @app = app
-      WhenAUser.queue = []
+      WhenAUser.webhook_url = options[:webhook_url] || 'http://www.whenauser.com/events/'
+      WhenAUser.buffer = []
       WhenAUser.filter_parameters = defined?(Rails) ? Rails.application.config.filter_parameters : []
       WhenAUser.token = options[:token]
-      WhenAUser.endpoint = Faraday::Connection.new options[:webhook_url] do |builder|
-        builder.request :json
-        builder.adapter Faraday.default_adapter
-      end
+      WhenAUser.queue = options[:queue] || WhenAUser::MemoryQueue
+      WhenAUser.queue_options = options[:queue_options] || {}
     end
 
     def call(env)
-      WhenAUser.queue = []
+      WhenAUser.buffer = []
       @app.call(env)
     ensure
       WhenAUser.flush

data/whenauser.gemspec

@@ -18,6 +18,5 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency 'activesupport'
   s.add_runtime_dependency 'actionpack'
-  s.add_runtime_dependency 'faraday', '~> 0.8.0'
-  s.add_runtime_dependency 'faraday_middleware'
+  s.add_runtime_dependency 'girl_friday', '0.9.7'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whenauser
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-27 00:00:00.000000000 Z
+date: 2012-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -45,37 +45,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: girl_friday
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.9.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.8.0
-- !ruby/object:Gem::Dependency
-  name: faraday_middleware
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.7
 description: Rack middleware for connecting to WhenAUser
 email:
 - david@alpinegizmo.com
@@ -89,7 +73,9 @@ files:
 - Rakefile
 - lib/whenauser.rb
 - lib/whenauser/exceptions.rb
+- lib/whenauser/girl_friday_queue.rb
 - lib/whenauser/helpers.rb
+- lib/whenauser/memory_queue.rb
 - lib/whenauser/pageviews.rb
 - lib/whenauser/railtie.rb
 - lib/whenauser/version.rb