whenauser 0.1.0 → 0.2.0

data/Gemfile

@@ -1,4 +1,4 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in whenauser.gemspec
+# dependencies are in whenauser.gemspec
 gemspec

data/README.md

@@ -1,4 +1,15 @@
-whenauser
+WhenAUser
 =========
 
-Connect your Rails applications to 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 eliminate business logic in 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.
+
+Usage
+-----
+
+    config.middleware.use 'WhenAUser::Rack',
+      :token => 'miKTaOlW1xzvEDG-QF9ZrA'
+    config.middleware.use 'WhenAUser::Exceptions',
+      :token => 'T4Jk7141XQefcD35v1Wzwg'
+    config.middleware.use 'WhenAUser::Pageviews',
+      :ignore_if => lambda { |env| env['action_controller.instance'].is_a? SillyController }
+

data/lib/whenauser/exceptions.rb

@@ -0,0 +1,90 @@
+# With inspiration from
+#   https://github.com/smartinez87/exception_notification
+#   http://sharagoz.com/posts/1-rolling-your-own-exception-handler-in-rails-3
+
+require 'action_dispatch'
+
+module WhenAUser
+  class Exceptions
+    include WhenAUser::Helpers
+
+    def self.default_ignored_exceptions
+      [].tap do |exceptions|
+        exceptions << 'ActiveRecord::RecordNotFound'
+        exceptions << 'AbstractController::ActionNotFound'
+        exceptions << 'ActionController::RoutingError'
+      end
+    end
+
+    def initialize(app, options={})
+      @app, @options = app, options
+      @options[:ignore_exceptions] ||= self.class.default_ignored_exceptions
+      @options[:ignore_crawlers]   ||= WhenAUser.default_ignored_crawlers
+      @options[:ignore_if]         ||= lambda { |env, e| false }
+      @options[:token]             ||= WhenAUser.token
+      @options[:custom_data]       ||= lambda { |env| {} }
+    end
+
+    def call(env)
+      begin
+        @app.call(env)
+      rescue Exception => exception
+        send_event_now event(env, exception), @options[:token] unless should_be_ignored(env, exception)
+        raise exception
+      end
+    end
+
+  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
+    end
+
+    def should_be_ignored(env, exception)
+      ignored_exception(@options[:ignore_exceptions], exception)       ||
+      from_crawler(@options[:ignore_crawlers], env['HTTP_USER_AGENT']) ||
+      conditionally_ignored(@options[:ignore_if], env, exception)
+    end
+
+    def ignored_exception(ignore_array, exception)
+      Array.wrap(ignore_array).map(&:to_s).include?(exception.class.name)
+    end
+
+    def conditionally_ignored(ignore_proc, env, exception)
+      ignore_proc.call(env, exception)
+    rescue Exception => ex
+      false
+    end
+
+    def clean_backtrace(exception)
+      if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
+        Rails.backtrace_cleaner.send(:filter, exception.backtrace)
+      else
+        exception.backtrace
+      end
+    end
+
+    def event(env, exception)
+      request = ActionDispatch::Request.new(env)
+      backtrace = clean_backtrace(exception)
+      actor = backtrace.first.match(/^(.*:.*):/)[1] rescue @app.to_s
+      event = {
+        :_actor => actor,
+        :_domain => 'exception',
+        :_name => exception.class.to_s,
+        :message => exception.to_s,
+        :backtrace => backtrace.join("\n"),
+        :request_url => request.url,
+        :request_method => request.request_method,
+        :params => request.params.except(*WhenAUser.filter_parameters),
+        :user_agent => request.user_agent
+      }
+      user = current_user(env)
+      event.merge!(:current_user => user) if user
+      event.merge!(:referer_url => request.referer) if request.referer
+      event.merge!(@options[:custom_data].call(env))
+      event
+    end
+
+  end
+end

data/lib/whenauser/helpers.rb

@@ -0,0 +1,22 @@
+module WhenAUser
+  module Helpers
+    def from_crawler(ignore_array, agent)
+      ignore_array.each do |crawler|
+        return true if (agent =~ /\b(#{crawler})\b/i)
+      end unless ignore_array.blank?
+      false
+    end
+
+    def current_user(env)
+      controller = env['action_controller.instance']
+      if current_user = controller.instance_variable_get('@current_user') || controller.instance_eval('current_user')
+        [:login, :username, :email, :id].each do |field|
+          return current_user.send(field) if current_user.respond_to?(field)
+        end
+      end
+      nil
+    rescue
+      nil
+    end
+  end
+end

data/lib/whenauser/pageviews.rb

@@ -0,0 +1,67 @@
+# With inspiration from
+#   https://github.com/smartinez87/exception_notification
+#   http://sharagoz.com/posts/1-rolling-your-own-exception-handler-in-rails-3
+
+require 'action_dispatch'
+
+module WhenAUser
+  class Pageviews
+    include WhenAUser::Helpers
+
+    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| {} }
+    end
+
+    def call(env)
+      before = Time.now
+      status, headers, response = @app.call(env)
+      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 should_be_ignored(env, request)
+      (defined?(Rails) && env['action_controller.instance'].nil?) ||
+      from_crawler(@options[:ignore_crawlers], env['HTTP_USER_AGENT']) ||
+      conditionally_ignored(@options[:ignore_if], env)
+    end
+
+    def conditionally_ignored(ignore_proc, env)
+      ignore_proc.call(env)
+    rescue Exception => ex
+      false
+    end
+    
+    def event_name(request)
+      if (params = request.params)['controller']
+        "#{params['controller']}##{params['action']}"
+      else
+        request.path.gsub('/', '-')
+      end
+    end
+
+    def event(env, request, status, duration)
+      actor = current_user(env) || 'anonymous'
+      event = {
+        :_actor => actor,
+        :_domain => 'pageview',
+        :_name => event_name(request),
+        :request_url => request.url,
+        :request_method => request.request_method,
+        :params => request.params.except(*WhenAUser.filter_parameters),
+        :user_agent => request.user_agent,
+        :status => status,
+        :duration => "%.2f" % (duration * 1000)
+      }
+      event.merge!(:referer_url => request.referer) if request.referer
+      event.merge!(@options[:custom_data].call(env))
+      event
+    end
+
+  end
+end

data/lib/whenauser/version.rb

@@ -1,3 +1,3 @@
 module WhenAUser
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/whenauser.rb

@@ -1,67 +1,46 @@
 require 'whenauser/version'
-require 'whenauser/log_subscriber'
-require 'active_support/core_ext/module/attribute_accessors'
+require 'whenauser/helpers'
+require 'whenauser/exceptions'
+require 'whenauser/pageviews'
 require 'faraday'
 require 'faraday_middleware'
-
-class ActionController::Base
-  def self.inherited(subclass)
-    super
-    subclass.prepend_before_filter :whenauser_disable_pageview_events
-    subclass.before_filter :whenauser_pageview_events
-  end
-
-  def whenauser_disable_pageview_events
-    WhenAUser.disable_pageview_events!
-    true
-  end
-  
-  def whenauser_pageview_events
-    WhenAUser.enable_pageview_events!
-    true
-  end
-end
+require 'active_support/core_ext/module/attribute_accessors'
 
 module WhenAUser
-  mattr_accessor :webhook_url
-  mattr_accessor :token
-  mattr_accessor :endpoint
-  mattr_accessor :filter_parameters
-  mattr_accessor :data
-  mattr_accessor :state
+  mattr_accessor :endpoint, :filter_parameters, :queue, :token
 
-  def self.setup(app)
-    WhenAUser::RequestLogSubscriber.attach_to :action_controller
-    self.webhook_url = app.config.whenauser.webhook_url
-    self.token = app.config.whenauser.token
-    self.filter_parameters = app.config.filter_parameters || []
-    self.endpoint = Faraday::Connection.new webhook_url do |builder|
-      builder.request :json
-      builder.adapter Faraday.default_adapter
-    end
-    self.data = {}
-    self.state = {}
+  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.custom_data=(hash)
-    data[Thread.current] = hash
-  end
-  
+
   def self.send_event(event)
-    endpoint.post token, event.to_json
-  end
-  
-  def self.disable_pageview_events!
-    state[Thread.current] = :disabled
+    event[:_timestamp] = Time.now.to_f unless event[:_timestamp] || event['_timestamp']
+    WhenAUser.queue << event
   end
 
-  def self.enable_pageview_events!
-    state[Thread.current] = :enabled
+  def self.flush
+    return if (events = WhenAUser.queue).empty?
+    WhenAUser.queue = []
+    endpoint.post WhenAUser.token, events.to_json
   end
-  
-  def self.pageview_events_enabled?
-    state[Thread.current] == :enabled
+
+  class Rack
+    def initialize(app, options={})
+      options[:webhook_url] ||= 'http://whenauser.com/events'
+      @app = app
+      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
+    end
+
+    def call(env)
+      WhenAUser.queue = []
+      status, headers, response = @app.call(env)
+      WhenAUser.flush
+      [status, headers, response]
+    end
   end
 end
-
-require 'whenauser/railtie' if defined?(Rails)

data/whenauser.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |s|
   s.authors     = ['David Anderson']
   s.email       = ['david@alpinegizmo.com']
   s.homepage    = 'https://github.com/tractionlabs/whenauser'
-  s.summary     = %q{Connect your Rails applications to WhenAUser}
-  s.description = %q{Connect your Rails applications to WhenAUser}
+  s.summary     = %q{Rack middleware for connecting to WhenAUser}
+  s.description = %q{Rack middleware for connecting to WhenAUser}
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whenauser
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-04 00:00:00.000000000 Z
+date: 2012-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -75,7 +75,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Connect your Rails applications to WhenAUser
+description: Rack middleware for connecting to WhenAUser
 email:
 - david@alpinegizmo.com
 executables: []
@@ -87,8 +87,9 @@ files:
 - README.md
 - Rakefile
 - lib/whenauser.rb
-- lib/whenauser/log_subscriber.rb
-- lib/whenauser/railtie.rb
+- lib/whenauser/exceptions.rb
+- lib/whenauser/helpers.rb
+- lib/whenauser/pageviews.rb
 - lib/whenauser/version.rb
 - whenauser.gemspec
 homepage: https://github.com/tractionlabs/whenauser
@@ -114,5 +115,5 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Connect your Rails applications to WhenAUser
+summary: Rack middleware for connecting to WhenAUser
 test_files: []

data/lib/whenauser/log_subscriber.rb

@@ -1,38 +0,0 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/log_subscriber'
-
-module WhenAUser
-  class RequestLogSubscriber < ActiveSupport::LogSubscriber
-    def process_action(data)
-      return unless WhenAUser.pageview_events_enabled?
-      payload = data.payload
-      return if (status = payload[:status] || 500).to_i == 302
-      now = Time.now
-      wau = {
-        :_actor => 'anonymous',
-        :_domain => 'pageview',
-        :_name => "#{payload[:params]['controller']}##{payload[:params]['action']}",
-        :_timestamp => now.to_i,
-        :nsecs => now.nsec,
-        :duration => "%.2f" % data.duration,
-        :method => payload[:method],
-        :path => payload[:path],
-        :format => payload[:format],
-        :status => status,
-        :params => payload[:params].except(*WhenAUser.filter_parameters)
-      }
-      if payload[:exception]
-        exception, message = payload[:exception]
-        wau = wau.merge(:exception => exception, :error_message => message)
-      else
-        wau = wau.merge(:view => "%.2f" % payload[:view_runtime], :db => "%.2f" % payload[:db_runtime])
-      end
-      wau = wau.merge(custom_data)
-      WhenAUser.send_event(wau)
-    end
-
-    def custom_data
-      WhenAUser.data[Thread.current] || {}
-    end
-  end
-end

data/lib/whenauser/railtie.rb

@@ -1,13 +0,0 @@
-require 'rails/railtie'
-require 'action_view/log_subscriber'
-require 'action_controller/log_subscriber'
-
-module Lograge
-  class Railtie < Rails::Railtie
-    config.whenauser = ActiveSupport::OrderedOptions.new
-
-    initializer :whenauser do |app|
-      WhenAUser.setup(app)
-    end
-  end
-end