whenauser 0.2.3 → 0.3.0

data/README.md

@@ -1,27 +1,36 @@
 WhenAUser
 =========
 
-[WhenAUser.com](http://whenauser.com) is a rules engine as a service that uses events from your application to trigger calls to 3rd party SaaS APIs. This lets you lift out the rapidly evolving parts of the business logic from your application, and use the WhenAUser web UI instead. This gem contains Rack middleware for connecting to WhenAUser. It generates two event streams, one for exceptions and the other for pageviews.
+[WhenAUser.com](http://whenauser.com) is a rules engine that reacts to things users do or experience in your software, and makes things happen in 3rd party SaaS APIs -- without your having to write any code. Rather than implementing the most rapidly evolving parts of your application's business logic in code, your team can use the WhenAUser web app to specify "when", "how", and "who", with rules like these:
 
-Usage Example
--------------
+* when a user gets a validation error twice for the same form, send an email to Frank
+* when a premium customer hasn't logged in for a month, flag them in Highrise
+* when a user gets a 500 response, create a ticket in Zendesk
+* when a user invites ten friends, add them to the "well-connected" segment in MailChimp
 
-    config.middleware.use 'WhenAUser::Rack',
-      :token => CHANNEL_TOKEN
-    config.middleware.use 'WhenAUser::Exceptions',
-      :token => ERROR_CHANNEL_TOKEN
-    config.middleware.use 'WhenAUser::Pageviews',
-      :ignore_if => lambda { |env| env['action_controller.instance'].is_a? SillyController }
+This gem contains Rack middleware that automatically generates two event streams, one for exceptions and the other for pageviews, that can be used to trigger rules in WhenAUser. You can (and probably should) also send more specific events manually.
 
-This gem will automatically send events for all exceptions and all pageviews (except those that filtered out by the options). You can also manually send additional events. For example:
+Setup
+-----
 
-    WhenAUser.send_event(
-      :_actor => current_user.unique_id, 
-      :_timestamp => Time.now.to_f, 
-      :_domain => 'account',
-      :_name => 'upgrade',
-      :user_email => current_user.email,
-      :plan => plan.name )
+In your Gemfile:
+
+    gem 'whenauser'
+
+
+For Ruby on Rails
+
+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.
+
+    token "CHANNEL_TOKEN"
+
+    middleware :errors do
+      token "ERROR_CHANNEL_TOKEN"
+    end
+
+    middleware :pageviews do
+      ignore_if lambda { |env| env['action_controller.instance'].is_a? SillyController }
+    end
 
 Options
 -------
@@ -30,8 +39,9 @@ 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
 
-WhenAUser::Exceptions accepts these options:
+The `exceptions` middleware accepts these options:
 
 * `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
@@ -39,12 +49,25 @@ WhenAUser::Exceptions accepts these options:
 * `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
 
-WhenAUser::Pageviews accepts these options:
+The `pageviews` middleware accepts these options:
 
 * `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; 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
 
+Sending other events
+--------------------
+
+To manually send an event when a user upgrades to a "premium" account:
+
+    WhenAUser.send_event(
+      :_actor => current_user.unique_id,
+      :_timestamp => Time.now.to_f,
+      :_domain => 'account',
+      :_name => 'upgrade',
+      :user_email => current_user.email,
+      :plan => 'premium' )
+
 Use Cases
 ---------
 

data/lib/whenauser/exceptions.rb

@@ -82,6 +82,7 @@ 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/pageviews.rb

@@ -18,15 +18,23 @@ module WhenAUser
     def call(env)
       before = Time.now
       status, headers, response = @app.call(env)
+      [status, headers, response]
+    rescue Exception => e
+      status = 500
+      raise e
+    ensure
       after = Time.now
       request = ActionDispatch::Request.new(env)
       WhenAUser.send_event event(env, request, status, after - before) unless should_be_ignored(env, request)
-      [status, headers, response]
     end
 
   private
+    def rails_asset_request?(env, request)
+      defined?(Rails) && env['action_controller.instance'].nil?
+    end
+
     def should_be_ignored(env, request)
-      (defined?(Rails) && env['action_controller.instance'].nil?) ||
+      rails_asset_request?(env, request) ||
       from_crawler(@options[:ignore_crawlers], env['HTTP_USER_AGENT']) ||
       conditionally_ignored(@options[:ignore_if], env)
     end
@@ -36,7 +44,7 @@ module WhenAUser
     rescue Exception => ex
       false
     end
-    
+
     def event_name(request)
       if (params = request.params)['controller']
         "#{params['controller']}##{params['action']}"
@@ -59,6 +67,7 @@ module WhenAUser
         :duration => "%.2f" % (duration * 1000)
       }
       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/railtie.rb

@@ -0,0 +1,75 @@
+require 'rails/railtie'
+require 'action_view/log_subscriber'
+require 'action_controller/log_subscriber'
+
+module Whenauser
+  class RailsConfigurator
+    attr_accessor :token, :webhook_url, :middlewares
+    def initialize
+      @webhook_url = 'http://whenauser.com/events/'
+      @middlewares = {}
+    end
+
+    def token(token)
+      @token = token
+    end
+
+    def webhook_url(webhook_url)
+      @webhook_url = webhook_url
+    end
+
+    def middleware(middleware, &block)
+      @middlewares[middleware] = MiddlewareConfigurator.apply(&block)
+    end
+  end
+
+  class MiddlewareConfigurator
+    attr_accessor :configuration
+
+    def self.apply(&block)
+      x = new
+      x.configure(&block)
+      x
+    end
+
+    def initialize
+      @configuration = {}
+    end
+
+    def configure(&block)
+      instance_eval &block
+    end
+
+    def method_missing(mid, *args, &block)
+      mname = mid.id2name
+      if block_given?
+        @configuration[mname.to_sym] = *block
+      else
+        if args.size == 1
+          @configuration[mname.to_sym] = args.first
+        else
+          @configuration[mname.to_sym] = args
+        end
+      end
+    end
+  end
+
+  class Railtie < Rails::Railtie
+    initializer :whenauser do |app|
+      filename = Rails.root.join('config/whenauser.rb')
+      if File.exists?(filename)
+        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',
+                :webhook_url => @webhook_url,
+                :token => @token
+            ::Rails.configuration.middleware.use('WhenAUser::Exceptions', @middlewares[:exceptions].configuration) if @middlewares.has_key?(:exceptions)
+            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
+      end
+    end
+  end
+end

data/lib/whenauser/version.rb

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

data/lib/whenauser.rb

@@ -39,9 +39,11 @@ module WhenAUser
 
     def call(env)
       WhenAUser.queue = []
-      status, headers, response = @app.call(env)
+      @app.call(env)
+    ensure
       WhenAUser.flush
-      [status, headers, response]
     end
   end
 end
+
+require 'whenauser/railtie' if defined?(Rails)

data/whenauser.gemspec

@@ -5,7 +5,7 @@ require 'whenauser/version'
 Gem::Specification.new do |s|
   s.name        = 'whenauser'
   s.version     = WhenAUser::VERSION
-  s.authors     = ['David Anderson']
+  s.authors     = ['David Anderson', 'Chris Weis']
   s.email       = ['david@alpinegizmo.com']
   s.homepage    = 'https://github.com/tractionlabs/whenauser'
   s.summary     = %q{Rack middleware for connecting to WhenAUser}

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: whenauser
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
 - David Anderson
+- Chris Weis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-20 00:00:00.000000000 Z
+date: 2012-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -90,6 +91,7 @@ files:
 - lib/whenauser/exceptions.rb
 - lib/whenauser/helpers.rb
 - lib/whenauser/pageviews.rb
+- lib/whenauser/railtie.rb
 - lib/whenauser/version.rb
 - whenauser.gemspec
 homepage: https://github.com/tractionlabs/whenauser