preact 1.0.1 → 1.1.0

data/lib/generators/preact_generator.rb

@@ -33,6 +33,11 @@ production: &defaults
     - "sessions#create"
     - "devise/sessions#create"
 
+  # specify how to retrieve the current user and account from within the application controller
+  # you may use either an instance variable (prefixed with @) or a method name
+  #current_user_getter: "current_user"
+  #current_account_getter: "@current_account"
+
 development:
   <<: *defaults
 

data/lib/preact.rb

@@ -105,22 +105,21 @@ module Preact
       end
 
       if event.is_a?(String)
-        preact_event = AccountEvent.new({
+        preact_event = {
             :name => event,
             :timestamp => Time.now.to_f
-          })
+          }
       elsif event.is_a?(Hash)
-        preact_event = AccountEvent.new(event)
-      elsif event.is_a?(AccountEvent)
         preact_event = event
       else
-        raise StandardError.new "Unknown event class, must pass a string event name, event hash or AccountEvent object"
+        raise StandardError.new "Unknown event class, must pass a string event name or event hash."
       end
 
       # attach the account info to the event
-      preact_event.account = configuration.convert_to_account(account)
+      preact_event[:account] = configuration.convert_to_account(account)
+      preact_event[:klass] = "accountevent"
       
-      send_log(nil, preact_event.as_json)
+      send_log(nil, preact_event)
     end
       
     def update_person(user)
@@ -160,7 +159,7 @@ module Preact
     protected
 
       def send_log(person, event=nil)
-        psn = person.to_hash
+        psn = person.nil? ? nil : person.to_hash
         evt = event.nil? ? nil : event.to_hash
 
         if defined?(Preact::Sidekiq) && (configuration.logging_mode.nil? || configuration.logging_mode == :sidekiq)

data/lib/preact/configuration.rb

@@ -16,6 +16,10 @@ module Preact
     attr_accessor :sidekiq_queue
     attr_accessor :request_timeout
     attr_accessor :logging_mode
+    attr_accessor :inject_javascript
+
+    attr_accessor :current_user_getter
+    attr_accessor :current_account_getter
     
     # Logger settings
     attr_accessor :logger
@@ -38,6 +42,11 @@ module Preact
       @logging_mode = nil
       @sidekiq_queue = :default
       @request_timeout = 5
+
+      @inject_javascript = false
+
+      @current_user_getter = :current_user
+      @current_account_getter = nil
       
       @user_agent = "ruby-preact:#{Preact::VERSION}"
 
@@ -49,6 +58,7 @@ module Preact
     end
     
     def valid?
+      # we require both the API keys
       code && secret
     end
     
@@ -68,6 +78,10 @@ module Preact
       "#{scheme}://#{code}:#{secret}@#{host}#{base_path}"
     end
 
+    def inject_javascript?
+      inject_javascript == true
+    end
+
     def autolog_enabled?
       autolog == true
     end
@@ -87,7 +101,31 @@ module Preact
       true
     end
     
+    def get_current_user(target)
+      return nil if current_user_getter.nil?
+
+      if current_user_getter.to_s.starts_with?("@")
+        # instance var
+        target.instance_variable_get(current_user_getter) rescue nil
+      else
+        target.send(current_user_getter) rescue nil
+      end
+    end
+
+    def get_current_account(target)
+      return nil if current_user_getter.nil?
+
+      if current_account_getter.to_s.starts_with?("@")
+        # instance var
+        target.instance_variable_get(current_account_getter) rescue nil
+      else
+        target.send(current_account_getter) rescue nil
+      end
+    end
+
     def convert_to_person(user)
+      return nil if user.nil?
+
       if person_builder
         if person_builder.respond_to?(:call)
           hash = person_builder.call(user)
@@ -106,6 +144,8 @@ module Preact
     end
 
     def convert_to_account(account)
+      return nil if account.nil?
+      
       if account_builder
         if account_builder.respond_to?(:call)
           hash = account_builder.call(account)
@@ -124,6 +164,8 @@ module Preact
     end
 
     def prepare_person_hash(person)
+      return nil if person.nil?
+
       if external_id = person[:external_identifier] || person["external_identifier"]
         person[:uid] ||= external_id
         person.delete(:external_identifier)

data/lib/preact/rails/controllers/helpers.rb

@@ -44,16 +44,23 @@ module Preact
 
       # helper method on the controller to make logging events easy
       def preact_log(event, account=nil)
-        if account
-          Preact.log_event(current_user, event, account)
-        else
-          Preact.log_event(current_user, event)
-        end
+        user = Preact.configuration.get_current_user(self) # handle nil
+        account ||= Preact.configuration.get_current_account(self) # handle nil
+
+        Preact.log_event(user, event, account)
 
         # make a note that we've logged an event on this controller
         @preact_logged_event = event
       end
 
+      def inject_javascript
+        if body_end = response.body.index("</body")
+          script = build_script
+
+          response.body = response.body.insert(body_end, script)
+        end
+      end
+
       # attach the after_filter to all controllers if we've enabled autologging
       if Preact.configuration.autolog_enabled?
         ActiveSupport.on_load(:action_controller) do
@@ -61,9 +68,40 @@ module Preact
         end
       end
 
+      if Preact.configuration.inject_javascript?
+        ActiveSupport.on_load(:action_controller) do
+          after_filter :inject_javascript
+        end
+      end
 
       protected
 
+        def build_script
+          script = <<-SCRIPT
+<script>
+  var _preactq = _preactq || [];
+  _preactq.push(['_setCode', '#{Preact.configuration.code.to_s}']);
+  _preactq.push(['_setPersonData', #{Preact.configuration.convert_to_person(Preact.configuration.get_current_user(self)).to_json}]);
+SCRIPT
+          if Preact.configuration.get_current_account(self)
+            script += <<-SCRIPT
+  _preactq.push(['_setAccount', #{Preact.configuration.convert_to_account(Preact.configuration.get_current_account(self)).to_json}]);
+SCRIPT
+          end
+
+          script += <<-SCRIPT
+  _preactq.push(['_logEvent', '___loaded:preact']);
+  (function() {
+    var ln = document.createElement('script'); 
+    ln.type = 'text/javascript'; ln.async = true;
+    ln.src = 'https://d2bbvl6dq48fa6.cloudfront.net/js/preact-4.0.min.js';
+    var s = document.getElementsByTagName('script')[0]; 
+    s.parentNode.insertBefore(ln, s);
+  })();
+</script>
+SCRIPT
+        end
+
         def guess_target_item_name(controller)
           # get a little too clever and try to see if we've loaded an item
           guessed_target_variable = controller.split("/").last.singularize rescue nil

data/lib/preact/version.rb

@@ -1,3 +1,3 @@
 module Preact
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/readme.md

@@ -8,7 +8,7 @@ Installation
 In your Gemfile:
 
 ```ruby
-gem 'preact', "~> 0.8.0"
+gem 'preact', '~> 1.0'
 ```
 
 Then do a `bundle install` to get the gem.
@@ -18,25 +18,59 @@ Configuration
 
 In version 0.8.1 we added a rails generator to make it really easy to add the initializer and get you up and running.
 
-First, obtain your Preact Project Code and API Secret from the [API settings page](https://secure.preact.io/settings/api). Then, in your application directory, run the generator:
+First, obtain your Preact Project Code and API Secret from the [API settings page](https://secure.preact.com/settings/api). Then, in your application directory, run the generator:
 
 ```bash
 rails g preact your-code-1234 api-secret-xyzw
 ```
 
-That will generate a preact.rb initializer that looks something like this:
+That will generate an initializer and a preact.yml config that looks something like this:
 
 ```ruby
-Preact.configure do |config|
-  config.code   = 'your-code-1234'           # required
-  config.secret = 'api-secret-xyzw'  # required
-  
-  config.autolog = true
-  config.autolog_ignored_actions = ["sessions#create"]
 
-  # Disable in Rails development environments
-  # config.disabled = Rails.env.development?
-end
+Preact Logging Configs
+---
+production: &defaults
+
+  # your Preact API credentials
+  code: "your-code-1234"
+  secret: "api-secret-xyzw"
+
+  # automatically log controller actions for authed users
+  # disable this if you want to only log manual events
+  autolog: true
+
+  # specify controller#action items that you want to ignore and not log to Preact.
+  # default is to not log sessions#create beacuse if you're using Devise, we get that already
+  autolog_ignored_actions:
+    - "sessions#create"
+    - "devise/sessions#create"
+
+  # specify how to retrieve the current user and account from within the application controller
+  # you may use either an instance variable (prefixed with @) or a method name
+  #current_user_getter: "current_user"
+  #current_account_getter: "@current_account"
+
+development:
+  <<: *defaults
+
+  # we usually suggest that you use a different project for development, to keep
+  # those events separate from production events
+  #code: "DEV_CODE"
+  #secret: "DEV_SECRET"
+
+  # you may also completely disable event logging in development
+  #disabled: false
+
+staging:
+  <<: *defaults
+
+  # if you want to log staging events separately as well
+  #code: "STAGING_CODE"
+  #secret: "STAGING_SECRET"
+
+  # you may also completely disable event logging in staging
+  #disabled: false
 ```
 
 Now when you launch your app and do something as an authenticated user, you should see the activity in Preact.
@@ -61,10 +95,12 @@ config.autolog_ignored_actions = [
     "secret_pages#*" # ignores ALL actions on the secret_pages_controller
   ]
 ```
+Background Sending
+---
+By default, Preact uses [SuckerPunch](https://github.com/brandonhilkert/sucker_punch) to make sure nothing gets blocked while logging events to Preact in the background.
 
 Rails Controller Helper
 ---
-
 Since version 0.8.1, we include a helper method on the base controller called `preact_log` to make it convenient for you to log events directly.
 
 The helper is aware of the current_user and so only requires you to pass the event information as things occur. So for instance, you may log a simple event from one of yoru controllers like so:
@@ -126,32 +162,29 @@ The `event` parameter may be either a String if you just are passing the event n
 
 ```ruby
 person = {
-  :name => "Christopher Gooley",
-  :email => "gooley@foliohd.com",
-  :uid => "gooley",
-  :properties => {
-    :subscription_level => 4,
-    :subscription_level_name => "Pro",
-    :is_paying => true,
-    :created_at => 1347060566
-    :twitter => "gooley"
+  name: 'Christopher Gooley',
+  email: 'gooley@foliohd.com',
+  uid: 'gooley',
+  properties: {
+    created_at: 1347060566
+    twitter: 'gooley'
   }
 }
 
-#common event examples:
+##common event examples:
 Preact.log_event(person, 'logged-in')
 Preact.log_event(person, 'upgraded')
-Preact.log_event(person, { :name => 'processed:payment', :revenue => 900 }) # revenue specified in cents
-Preact.log_event(person, { :name => 'uploaded:file', :note => "awesome_resume.pdf" })
+Preact.log_event(person, { name: 'processed:payment', revenue: 900 }) # revenue specified in cents
+Preact.log_event(person, { name: 'uploaded:file', note: 'awesome_resume.pdf' })
 
 Preact.log_event(person, {
-    :name => 'purchased:item',
-    :note => "black shoes", 
-    :revenue => 2500, 
-    :extras => {
-      :category => "shoes",
-      :size => "13",
-      :color => "blue"
+    name: 'purchased:item',
+    note: 'black shoes', 
+    revenue: 2500, 
+    extras: {
+      category: 'shoes',
+      size: '13',
+      color: 'blue'
     })
 ```
 
@@ -159,9 +192,9 @@ If you are a Preact B2B user, you should also log the `account` that this event
 
 ```ruby
 Preact.log_event(
-          { :email => "bob@honda.com", :name => "Bob Smith" }, # person
-          { :name => 'uploaded:file', :note => "awesome_resume.pdf" }, # event
-          { :id => 1234, :name => "Honda"} # account
+          { email: 'bob@honda.com', name: 'Bob Smith' }, # person
+          { name: 'uploaded:file', note: 'awesome_resume.pdf' }, # event
+          { id: 1234, name: 'Honda'} # account
         )
 ```
 
@@ -173,21 +206,20 @@ In your `User` model, you can define a `to_preact` method returning a Hash. Prea
 class User < ActiveRecord::Base
   def to_preact
     {
-      :name => self.name,
-      :email => self.email,
-      :uid => self.id,
-      :properties => {
-        :is_paying => self.paying_customer?,
-        :created_at => self.created_at.to_i
-      }
+      name: self.name,
+      email: self.email,
+      uid: self.id,
+      created_at: self.created_at.to_i
     }
   end
 end
 ```
 
+For a list of available built-in person fields, see the [API Docs](http://www.preact.com/api#person_object) Person Object section.
+
 ```ruby
 Preact.log_event(@current_user, 'restored_answer_data') 
-Preact.log_event(@current_user, { :name => 'updated-profile', :extras => {:twitter => "@gooley"} })
+Preact.log_event(@current_user, { name: 'updated-profile', extras: {twitter: '@gooley'} })
 ```
 
 #### B2B Account mapping method
@@ -198,23 +230,26 @@ Likewise, if you are a Preact B2B user, you can define the `to_preact` method on
 class Project < ActiveRecord::Base
   def to_preact
     {
-      :name => self.name,
-      :id => self.id
+      name: self.name,
+      id: self.id,
+      license_status: self.account_status
     }
   end
 end
 ```
 
+For a list of available built-in account fields, see the [API Docs](http://www.preact.com/api#account_object) Account Object section.
+
 Then, you just pass that model to the log_event method and we will associate the user's action with that account.
 
 ```ruby
 Preact.log_event(@current_user, 'restored_answer_data', @current_project) 
-Preact.log_event(@current_user, { :name => 'updated-profile', :extras => {:twitter => "@gooley"} }, @current_project)
+Preact.log_event(@current_user, { name: 'updated-profile', extras: {twitter: '@gooley'} }, @current_project)
 ```
 
 Sidekiq Integration
 ---
-Using [Sidekiq](http://sidekiq.org) for background processing? That's the best way to log data to Preact so it's not done in-process. 
+Using [Sidekiq](http://sidekiq.org) for background processing?
 
 All you need to do is add `require 'preact/sidekiq'` at the top of your `preact.rb` initializer and we'll take it from there. Jobs will be placed on the :default queue.
 
@@ -224,9 +259,8 @@ If you are using Warden, Preact will automatically log your login/logout events.
 If when Preact loads, it notices that a ::Warden class is defined, it will require the preact/warden module which adds the appropriate hooks into Warden.
 
 
-
 License
---
+---
 Copyright (c) 2011-2013 Christopher Gooley, Preact / Less Neglect, Inc. See LICENSE.txt for further details.
 
 Thanks to [Zach Millman](https://github.com/zmillman) for many contributions.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: preact
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-24 00:00:00.000000000 Z
+date: 2014-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client