preact 0.8.2 → 0.8.3

data/lib/generators/preact_generator.rb

@@ -17,7 +17,7 @@ Preact.configure do |config|
 
   # 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
-  config.autolog_ignored_actions = ["sessions#create"]
+  config.autolog_ignored_actions = ["sessions#create", "devise/sessions#create"]
 
   # disable in Rails non-production environments
   # uncomment this if you don't want to log development activities

data/lib/preact/configuration.rb

@@ -113,9 +113,7 @@ module Preact
         :name => user.name,
         :email => user.email,
         :uid => user.id,
-        :properties => {
-          :created_at => (user.created_at.to_i if user.respond_to?(:created_at))
-        }
+        :created_at => (user.created_at.to_i if user.respond_to?(:created_at))
       }
     end
 

data/lib/preact/objects/person.rb

@@ -3,12 +3,12 @@ class Preact::Person < Preact::ApiObject
   attr_accessor :name, :email, :external_identifier, :properties, :uid, :created_at
     
   def as_json(options={})
-    {
+    d = {
       :name                => self.name,
       :email               => self.email,
       :uid                 => self.uid || self.external_identifier,
-      :created_at          => self.created_at.to_i,
-      :properties          => self.properties
+      :created_at          => self.created_at ? self.created_at.to_i : nil,
+      :properties          => self.properties || {}
     }
   end
     

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

@@ -1,16 +1,18 @@
 module Preact
   module Controllers
     module Helpers
-      extend ActiveSupport::Concern
 
       def preact_autolog_controller_action
+
         # only track logged-in users
         return true unless current_user
+
+        # don't autolog if we logged something already on this controller execution
+        # this allows you to add better preact logging in your controller and not get duplicate logging
+        return true if defined?(@preact_logged_event)
         
         controller = params[:controller]
         action = params[:action]
-        target_id = params[:id]
-        note = nil
 
         return true unless controller && action
 
@@ -18,15 +20,11 @@ module Preact
 
         event_name = "#{controller}##{action}"
 
-        if response.status == 404
-          note = "NOT FOUND"
-        elsif response.status == 500
-          event_name = "!#{event_name}--error"
-        end
+        note = self.guess_target_item_name(controller)
 
         event = {
           :name => event_name,
-          :target_id => target_id,
+          :target_id => params[:id],
           :medium => "autolog-rails-v1.0",
           :note => note,
           :extras => {
@@ -39,6 +37,9 @@ module Preact
         preact_log(event)
 
         true
+      rescue => ex
+        Preact.logger.warn "[Preact] Autolog failed: #{ex.message}"
+        true # always returns strue no matter what...
       end
 
       # helper method on the controller to make logging events easy
@@ -48,6 +49,9 @@ module Preact
         else
           Preact.log_event(current_user, event)
         end
+
+        # make a note that we've logged an event on this controller
+        @preact_logged_event = event
       end
 
       # attach the after_filter to all controllers if we've enabled autologging
@@ -57,6 +61,21 @@ module Preact
         end
       end
 
+
+      protected
+
+        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
+          if guessed_target_variable
+            if guessed_target_item = self.instance_variable_get("@#{guessed_target_variable}")
+              return guessed_target_item.name if guessed_target_item.respond_to?(:name)
+              return guessed_target_item.title if guessed_target_item.respond_to?(:title)
+            end
+          end
+          nil
+        end
+
     end
   end
 end

data/lib/preact/version.rb

@@ -1,3 +1,3 @@
 module Preact
-  VERSION = "0.8.2"
+  VERSION = "0.8.3"
 end

data/readme.md

@@ -8,28 +8,87 @@ Installation
 In your Gemfile:
 
 ```ruby
-gem 'preact'
+gem 'preact', "~> 0.8.0"
 ```
 
+Then do a `bundle install` to get the gem.
+
 Configuration
 ---
 
-Configure Preact with your API credentials. You can find your Preact credentials on the [API settings page](https://secure.preact.io/settings/api) (This should go in an initializer file named `/config/initializers/preact.rb` in Rails applications)
+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:
+
+```bash
+rails g preact your-code-1234 api-secret-xyzw
+```
+
+That will generate a preact.rb initializer that looks something like this:
 
 ```ruby
 Preact.configure do |config|
-  config.code   = 'abcdefg'           # required
-  config.secret = '1234asdfasdf1234'  # required
+  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
+```
+
+Now when you launch your app and do something as an authenticated user, you should see the activity in Preact.
+
+Autolog
+---
+
+New in version 0.8.1 is the ability to automatically log all controller-based actions that your authenticated users are performing.
+
+In many cases, you won't need to do anything other than put the gem in your Gemfile, bundle, and run the generator.
+
+This works by creating an method on the ActiveController::Base class and setting it as an after_filter for all controllers. We assume that you're using Devise/Warden, because everyone does, and can directly access that to identify who the current_user is. With Autolog enabled, what you will see is rails routes-style events in Preact for each user.
+
+We turn Autolog on by default when you use the generator to build the preact.rb initializer, but if you're upgrading from an existing preact-ruby install you will need to manually update your config.
+
+You can configure controllers and routes to ignore by adding them in the initializer as well. If you want to ignore a specific action, you can include it like so:
+
+```ruby
+config.autolog_ignored_actions = [
+    "documents#new", # ignores the new action on the documents_controller
+    "people#new", # ignores the new action on the people_controller
+    "secret_pages#*" # ignores ALL actions on the secret_pages_controller
+  ]
+```
+
+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:
+
+```ruby
+class DocumentsController < ApplicationController
+  def show
+    # YOUR CODE STUFF HERE
+
+    preact_log("did-something-cool")
+  end
   
-  # Uncomment this this line to customize the data sent with your Person objects.
-  # Your custom procedure should return a Hash of attributes
-  # config.person_builder = lambda {|user| {:keys => :values}}
-  
-  # Defaults to Rails.logger or Logger.new(STDOUT). Set to Logger.new('/dev/null') to disable logging.
-  # config.logger = Logger.new('/dev/null')  
+  def search
+    # YOUR CODE STUFF HERE
+    
+    preact_log({
+      name: "searched-documents",
+      note: @search_term,
+      extras: {
+        term: @search_term,
+        result_count: @results.count
+      }
+    })
+  end
 end
 ```
 
@@ -138,19 +197,13 @@ All you need to do is add `require 'preact/sidekiq'` at the top of your `preact.
 
 Devise / Warden Integration
 --
-Automatically log your login/logout events by including this in your `preact.rb` initializer. Just put it under the Preact config block.
+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.
 
-```ruby
-# after-auth hook to log the login
-Warden::Manager.after_authentication do |user,auth,opts|
-  Preact.log_event(user, "logged-in")
-end
-Warden::Manager.before_logout do |user,auth,opts|
-  Preact.log_event(user, "logged-out")
-end
-```
 
 
+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: 0.8.2
+  version: 0.8.3
   prerelease: 
 platform: ruby
 authors: