whenauser 0.6.4 → 0.7.1

data/README.md

@@ -3,12 +3,12 @@ WhenAUser
 
 [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:
 
-* 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 form validation error three times in an hour, send an email to Frank
+* when a premium customer hasn't logged in for a month, flag them in your CRM
 * 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
 
-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 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 also send more specific events manually.
 
 Setup
 -----
@@ -30,9 +30,31 @@ You should create two incoming channels (event streams) in WhenAUser, and config
 ###As general-purpose Rack middleware, with or without Rails
 
     config.middleware.insert 0, 'WhenAUser::Rack', :token => 'CHANNEL_TOKEN'
-    config.middleware.insert_after 'WhenAUser::Rack', 'WhenAUser::Pageviews'
+    config.middleware.use 'WhenAUser::Pageviews'
     config.middleware.use 'WhenAUser::Exceptions', :token => 'ERROR_CHANNEL_TOKEN'
 
+The current user
+----------------
+
+WhenAUser can take advantage of knowing about the user behind each event, which is supplied by the \_actor field. This gem employs a number of heuristics to determine the current user, but you can also help it out. If, for example, you want to use current_user.id as the \_actor for every event (and 0 for the logged out user), you could do this via:
+
+    controller_data '{:_actor => current_user.try(:id) || 0}'
+
+The string will be evaluated in the context of your controller.
+
+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' )
+
 Using girl_friday for asynchronous communication and persistence
 -----------------
 
@@ -66,7 +88,7 @@ WhenAUser::Rack accepts these options:
 * `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
-* `custom_data` -- this proc is passed env, and should return a hash to be merged into every event
+* `controller_data` -- a string evaluated in the context of the Rails controller (if any) handling the request; it should return a hash to be merged into every event
 
 The `exceptions` middleware accepts these options:
 
@@ -80,6 +102,7 @@ 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
+* `ignore_if_controller` -- a string to be evaluated in the context of the Rails controller instance
 * `custom_data` -- this proc is passed env, and should return a hash to be merged into each automatically generated event
 
 The WhenAUser::Pageviews middleware uses the same token as WhenAUser::Rack.
@@ -90,18 +113,17 @@ Here's an example of how to skip sending any pageview events for all requests to
       ignore_if lambda { |env| env['action_controller.instance'].is_a? SillyController }
     end
 
-Sending other events
---------------------
+To make life easier in the case where you want a condition evaluated in the context of a Rails controller, you can do the same thing like this. (Only the pageviews middleware supports ignore_if_controller.)
 
-To manually send an event when a user upgrades to a "premium" account:
+    middleware :pageviews do
+      ignore_if_controller 'self.is_a?(EventsController)'
+    end
 
-    WhenAUser.send_event(
-      :_actor => current_user.unique_id,
-      :_timestamp => Time.now.to_f,
-      :_domain => 'account',
-      :_name => 'upgrade',
-      :user_email => current_user.email,
-      :plan => 'premium' )
+Or if you want to skip sending pageview events for requests from pingdom.com:
+
+    middleware :pageviews do
+      ignore_crawlers WhenAUser.default_ignored_crawlers + ['Pingdom.com_bot']
+    end
 
 Use Cases
 ---------
@@ -109,7 +131,7 @@ Use Cases
 ### Example rule triggers
 
 * whenever a `UserIsHavingAVeryBadDay` exception is raised
-* the first time any exception occurs
+* the first time any particular exception occurs
 * whenever a request takes more than 20 seconds to process
 * whenever someone upgrades their account
 * whenever someone does comment#create more than 10 times in a day
@@ -120,7 +142,7 @@ Use Cases
 * send yourself an email or a mobile push message
 * send a user an email or a mobile push message
 * create a ticket in your ticketing system
-* add a data point to a Librato graph
+* add a data point to a Librato or StatsMix graph
 * tag a user in WhenAUser, or in your CRM
 * segment a user in your email campaign tool
 

data/lib/whenauser.rb

@@ -8,24 +8,23 @@ require 'net/http'
 require 'uri'
 require 'logger'
 require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module WhenAUser
-  mattr_accessor :filter_parameters, :buffer, :token, :webhook_url, :queue, :queue_options, :custom_data, :logger
+  mattr_accessor :filter_parameters, :buffer, :token, :webhook_url, :queue, :queue_options, :controller_data, :logger
 
   def self.default_ignored_crawlers
-    %w(Baidu Gigabot Googlebot libwww-perl lwp-trivial msnbot SiteUptime Slurp WordPress ZIBB ZyBorg Yandex Jyxobot Huaweisymantecspider ApptusBot)
+    %w(Baidu Gigabot Googlebot libwww-perl lwp-trivial msnbot SiteUptime Slurp WordPress ZIBB ZyBorg Yandex Jyxobot Huaweisymantecspider ApptusBot NewRelicPinger)
   end
 
   def self.send_event(event)
-    logger.debug "============= #{event.inspect} ============="
     buffer << event
   end
 
   def self.flush(env={})
     return if (events = WhenAUser.buffer).empty?
     WhenAUser.buffer = []
-    events.each {|event| WhenAUser.prepare_event(event, env)}
-    WhenAUser.queue.push(:payload => events)
+    WhenAUser.queue.push(:payload => events.map {|event| WhenAUser.prepare_event(event, env)})
     # WhenAUser.post_payload_to_token events.to_json, WhenAUser.token
   end
   
@@ -53,19 +52,39 @@ module WhenAUser
   end
 
   private
+  def self.page_event_name(request, params)
+    if params && params['controller']
+      "#{params['controller']}##{params['action']}"
+    else
+      request.path.gsub('/', '-')[1..-1]
+    end
+  end
+
   def self.prepare_event(event, env)
-    event[:_actor] ||= current_user(env) || 'anonymous'
-    event[:_timestamp] = Time.now.to_f unless (event[:_timestamp] || event['_timestamp'])
+    event = event.with_indifferent_access
+
+    if controller = env['action_controller.instance']
+      data = controller.instance_eval(WhenAUser.controller_data)
+      event.merge!(data)
+    end
+
+    event[:_actor] = current_user(env) || 'anonymous' unless event[:_actor].present?
+    event[:_timestamp] ||= Time.now.to_f
     event[:rails_env] = Rails.env if defined?(Rails)
+
     unless env.empty?
-      event[:request_url] = env['whenauser.request_url']
-      event[:request_method] = env['whenauser.request_method']
-      event[:user_agent] = env['whenauser.user_agent']
-      event[:referer_url] = env['whenauser.referer_url'] if env['whenauser.referer_url']
-      request = ActionDispatch::Request.new(env)
-      event[:params] = request.params.except(*WhenAUser.filter_parameters)
+      env['rack.input'].rewind
+      request = defined?(Rails) ? ActionDispatch::Request.new(env) : ::Rack::Request.new(env)
+      params = request.params
+
+      event[:_name] ||= page_event_name(request, params)
+      event[:request_url] = request.url
+      event[:request_method] = request.request_method
+      event[:user_agent] = request.user_agent
+      event[:referer_url] = request.referer if request.referer.present?
+      event[:params] = params
     end
-    event.merge!(WhenAUser.custom_data.call(env))
+
     event
   end
 
@@ -79,16 +98,11 @@ module WhenAUser
       WhenAUser.token = options[:token]
       WhenAUser.queue = options[:queue] || WhenAUser::MemoryQueue
       WhenAUser.queue_options = options[:queue_options] || {}
-      WhenAUser.custom_data = options[:custom_data] || lambda { |env| {} }
+      WhenAUser.controller_data = options[:controller_data] || '{}'
     end
 
     def call(env)
       WhenAUser.buffer = []
-      request = ActionDispatch::Request.new(env)
-      env['whenauser.request_url'] = request.url
-      env['whenauser.request_method'] = request.request_method
-      env['whenauser.user_agent'] = request.user_agent
-      env['whenauser.referer_url'] = request.referer
       @app.call(env)
     ensure
       WhenAUser.flush(env)

data/lib/whenauser/pageviews.rb

@@ -10,13 +10,13 @@ module WhenAUser
 
     def initialize(app, options={})
       @app, @options = app, options
-      @options[:ignore_crawlers]   ||= WhenAUser.default_ignored_crawlers
-      @options[:ignore_if]         ||= lambda { |env| false }
-      @options[:custom_data]       ||= lambda { |env| {} }
+      @options[:ignore_crawlers]      ||= WhenAUser.default_ignored_crawlers
+      @options[:ignore_if]            ||= lambda { |env| false }
+      @options[:ignore_if_controller] ||= 'false'
+      @options[:custom_data]          ||= lambda { |env| {} }
     end
 
     def call(env)
-      request = ActionDispatch::Request.new(env)
       before = Time.now
       status, headers, response = @app.call(env)
       [status, headers, response]
@@ -25,38 +25,33 @@ module WhenAUser
       raise e
     ensure
       after = Time.now
-      WhenAUser.send_event event(env, request, status, after - before) unless should_be_ignored(env, request)
+      WhenAUser.send_event event(env, status, after - before) unless should_be_ignored(env)
     end
 
   private
-    def rails_asset_request?(env, request)
+    def rails_asset_request?(env)
       defined?(Rails) && env['action_controller.instance'].nil?
     end
 
-    def should_be_ignored(env, request)
-      rails_asset_request?(env, request) ||
+    def should_be_ignored(env)
+      rails_asset_request?(env) ||
       from_crawler(@options[:ignore_crawlers], env['HTTP_USER_AGENT']) ||
-      conditionally_ignored(@options[:ignore_if], env)
+      conditionally_ignored(@options[:ignore_if], env) ||
+      conditionally_ignored_controller(@options[:ignore_if_controller], env)
     end
 
-    def conditionally_ignored(ignore_proc, env)
-      ignore_proc.call(env)
-    rescue Exception => ex
-      false
+    def conditionally_ignored_controller(condition, env)
+      controller = env['action_controller.instance']
+      controller.instance_eval condition
     end
 
-    def page_event_name(request)
-      if (params = request.params)['controller']
-        "#{params['controller']}##{params['action']}"
-      else
-        request.path.gsub('/', '-')
-      end
+    def conditionally_ignored(ignore_proc, env)
+      ignore_proc.call(env)
     end
 
-    def event(env, request, status, duration)
+    def event(env, status, duration)
       event = {
         :_domain => (status.to_i >= 400) ? 'pageerror' : 'pageview',
-        :_name => page_event_name(request),
         :status => status,
         :duration => "%.2f" % (duration * 1000)
       }

data/lib/whenauser/railtie.rb

@@ -3,7 +3,7 @@ require 'active_record'
 
 module Whenauser
   class RailsConfigurator
-    attr_accessor :token, :webhook_url, :middlewares, :queue, :queue_options
+    attr_accessor :token, :webhook_url, :middlewares, :queue, :controller_data, :queue_options
     def initialize
       @webhook_url = 'http://www.whenauser.com/events/'
       @middlewares = {}
@@ -26,6 +26,10 @@ module Whenauser
       @queue_options = options
     end
 
+    def controller_data(data)
+      @controller_data = data
+    end
+
     def girl_friday_options(options)
       @girl_friday_options = options
     end
@@ -73,10 +77,10 @@ module Whenauser
                 :webhook_url => @webhook_url,
                 :token => @token,
                 :queue => @queue,
-                :queue_options => @queue_options
+                :queue_options => @queue_options,
+                :controller_data => @controller_data
+            ::Rails.configuration.middleware.use('WhenAUser::Pageviews', @middlewares[:pageviews].configuration) if @middlewares.has_key?(:pageviews)
             ::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

data/lib/whenauser/version.rb

@@ -1,3 +1,3 @@
 module WhenAUser
-  VERSION = '0.6.4'
+  VERSION = '0.7.1'
 end

metadata

@@ -1,72 +1,71 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: whenauser
-version: !ruby/object:Gem::Version
-  version: 0.6.4
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 7
+  - 1
+  version: 0.7.1
 platform: ruby
-authors:
+authors: 
 - David Anderson
 - Chris Weis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-09 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-08-11 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: activesupport
-  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'
-- !ruby/object:Gem::Dependency
-  name: actionpack
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: actionpack
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: girl_friday
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.10.0
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: girl_friday
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 0
         version: 0.10.0
+  type: :runtime
+  version_requirements: *id003
 description: Rack middleware for connecting to WhenAUser
-email:
+email: 
 - david@alpinegizmo.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - Gemfile
 - README.md
@@ -81,28 +80,35 @@ files:
 - lib/whenauser/railtie.rb
 - lib/whenauser/version.rb
 - whenauser.gemspec
+has_rdoc: true
 homepage: https://github.com/tractionlabs/whenauser
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Rack middleware for connecting to WhenAUser
 test_files: []
+