preact 0.8.6 → 1.0.0

data/lib/preact.rb

@@ -2,15 +2,7 @@ require 'preact/configuration'
 require 'preact/client'
 require 'preact/background_logger'
 
-require 'preact/objects/api_object'
-require 'preact/objects/person'
-require 'preact/objects/event'
-require 'preact/objects/action_event'
-require 'preact/objects/action_link'
-require 'preact/objects/account_event'
-require 'preact/objects/message'
-require 'preact/objects/account'
-
+require 'json'
 require 'logger'
 
 module Preact
@@ -27,6 +19,7 @@ module Preact
     # Call this method to modify the configuration in your initializers
     def configure
       defaults = {}
+
       # try to use the yml config if we're on rails and it exists
       if defined? ::Rails
         config_yml = File.join(::Rails.root.to_s,"config","preact.yml")
@@ -55,6 +48,11 @@ module Preact
         require 'preact/warden'
       end
 
+      if defined? ::Preact::Sidekiq
+        # set up the default queue for the sidekiq job
+        ::Preact::Sidekiq::PreactLoggingWorker.sidekiq_options(:queue => self.configuration.sidekiq_queue)
+      end
+
     end
 
     def log_event(user, event, account = nil)
@@ -71,26 +69,26 @@ module Preact
       end
 
       if event.is_a?(String)
-        preact_event = ActionEvent.new({
+        preact_event = {
             :name => event,
             :timestamp => Time.now.to_f
-          })
+          }
       elsif event.is_a?(Hash)
-        preact_event = ActionEvent.new(event)
-      elsif event.is_a?(ActionEvent)
         preact_event = event
       else
-        raise StandardError.new "Unknown event class, must pass a string event name, event hash or ActionEvent object"
+        raise StandardError.new "Unknown event class, must pass a string event name or event hash."
       end
 
       if account
         # attach the account info to the event
-        preact_event.account = configuration.convert_to_account(account).as_json
+        preact_event[:account] = configuration.convert_to_account(account)
       end
 
       person = configuration.convert_to_person(user)
+
+      preact_event[:klass] = "actionevent"
       
-      send_log(person.as_json, preact_event.as_json)
+      send_log(person, preact_event)
     end
 
     def log_account_event(event, account)
@@ -120,7 +118,7 @@ module Preact
       end
 
       # attach the account info to the event
-      preact_event.account = configuration.convert_to_account(account).as_json
+      preact_event.account = configuration.convert_to_account(account)
       
       send_log(nil, preact_event.as_json)
     end
@@ -135,9 +133,9 @@ module Preact
         return nil
       end
       
-      person = configuration.convert_to_person(user).as_json
+      person = configuration.convert_to_person(user)
 
-      send_log(person)
+      client.update_person(person)
     end
     
     def update_account(account)
@@ -155,27 +153,6 @@ module Preact
       client.update_account(account)
     end
     
-    # message - a Hash with the following required keys
-    #           :subject - subject of the message
-    #           :body - body of the message
-    #           * any additional keys are used as extra options for the message (:note, etc.)
-    # DEPRECATED - DO NOT USE
-    def message(user, message = {})
-      # Don't send requests when disabled
-      if configuration.disabled?
-        logger.info "[Preact] Logging is disabled, not logging event"
-        return nil
-      elsif user.nil?
-        logger.info "[Preact] No person specified, not logging event"
-        return nil
-      end
-      
-      person = configuration.convert_to_person(user).as_json
-      message_obj = Message.new(message).as_json
-
-      send_log(person, message_obj)
-    end
-    
     def client
       self.default_client ||= Client.new
     end
@@ -183,13 +160,12 @@ module Preact
     protected
 
       def send_log(person, event=nil)
-        psn = person.as_json
-        evt = event.nil? ? nil : event.as_json
+        psn = person.to_hash
+        evt = event.nil? ? nil : event.to_hash
 
-        if defined?(Preact::Sidekiq)
+        if defined?(Preact::Sidekiq) && (configuration.logging_mode.nil? || configuration.logging_mode == :sidekiq)
           Preact::Sidekiq::PreactLoggingWorker.perform_async(psn, evt)
         else
-          #client.create_event(psn, evt)
           # use the background thread logger
           Preact::BackgroundLogger.new.async.perform(psn, evt)
         end

data/lib/preact/client.rb

@@ -4,25 +4,31 @@ require 'rest_client'
 module Preact
   class Client
     
-    def create_event(person, action_event)
+    def create_event(person, event)
     	params = {
-        :person => person,
-        :event => action_event
+        :person => Preact.configuration.prepare_person_hash(person),
+        :event => Preact.configuration.prepare_event_hash(event)
       }
+
+      if params[:event][:account]
+        params[:event][:account] = Preact.configuration.prepare_account_hash(params[:event][:account])
+      end
+      
       data = post_request("/events", params)
     end
 
     def update_person(person)
       params = {
-        :person => person
+        :person => Preact.configuration.prepare_person_hash(person)
       }
 
       data = post_request("/people", params)
     end
 
     def update_account(account)
+
       params = {
-        :account => account
+        :account => Preact.configuration.prepare_account_hash(account)
       }
 
       data = post_request("/accounts", params)
@@ -35,7 +41,14 @@ module Preact
       
       Preact.logger.debug "[Preact] post_request to #{Preact.configuration.base_uri + method} with #{params.inspect}"
       
-      res = RestClient.post Preact.configuration.base_uri + method, params.to_json, :content_type => :json, :accept => :json
+      res = RestClient::Request.execute({
+            :method => :post, 
+            :url => Preact.configuration.base_uri + method, 
+            :payload => params,
+            :headers => { :content_type => :json, :accept => :json },
+            :open_timeout => Preact.configuration.request_timeout,
+            :timeout => Preact.configuration.request_timeout
+          })
       data = MultiJson.decode(res.body)
     end
 
@@ -44,13 +57,22 @@ module Preact
 
       Preact.logger.debug "[Preact] get_request to #{Preact.configuration.base_uri + method} with #{params.inspect}"
 
-      res = RestClient.get Preact.configuration.base_uri + method, { :params => params }
+      res = RestClient::Request.execute({
+            :method => :get, 
+            :url => Preact.configuration.base_uri + method, 
+            :params => params,
+            :headers => { :content_type => :json, :accept => :json },
+            :open_timeout => Preact.configuration.request_timeout,
+            :timeout => Preact.configuration.request_timeout
+          })
+
       data = MultiJson.decode(res.body)
     end
     
     def prepare_request_params(params = {})
       params.merge({
-        :format => "json"
+        :format => "json",
+        :source => Preact.configuration.user_agent
       })
     end
     

data/lib/preact/configuration.rb

@@ -13,6 +13,9 @@ module Preact
     attr_accessor :account_builder
     attr_accessor :autolog
     attr_accessor :autolog_ignored_actions
+    attr_accessor :sidekiq_queue
+    attr_accessor :request_timeout
+    attr_accessor :logging_mode
     
     # Logger settings
     attr_accessor :logger
@@ -31,6 +34,10 @@ module Preact
       @autolog_ignored_actions = []
       @disabled = false
       @person_builder = nil
+
+      @logging_mode = nil
+      @sidekiq_queue = :default
+      @request_timeout = 5
       
       @user_agent = "ruby-preact:#{Preact::VERSION}"
 
@@ -83,33 +90,76 @@ module Preact
     def convert_to_person(user)
       if person_builder
         if person_builder.respond_to?(:call)
-          Person.new(person_builder.call(user))
+          hash = person_builder.call(user)
         else
           raise "person_builder must be callable"
         end
       elsif user.respond_to?(:to_preact)
-        Person.new(user.to_preact)
+        hash = user.to_preact
       elsif user.is_a? Hash
-        Person.new(user)
+        hash = user
       else
-        Person.new(default_user_to_preact_hash(user))
+        hash = default_user_to_preact_hash(user)
       end
+
+      hash
     end
 
     def convert_to_account(account)
       if account_builder
         if account_builder.respond_to?(:call)
-          Account.new(account_builder.call(account))
+          hash = account_builder.call(account)
         else
           raise "account_builder must be callable"
         end
       elsif account.respond_to?(:to_preact)
-        Account.new(account.to_preact)
+        hash = account.to_preact
       elsif account.is_a? Hash
-        Account.new(account)
+        hash = account
       else
-        Account.new(default_account_to_preact_hash(account))
+        hash = default_account_to_preact_hash(account)
+      end
+
+      hash
+    end
+
+    def prepare_person_hash(person)
+      if external_id = person[:external_identifier] || person["external_identifier"]
+        person[:uid] ||= external_id
+        person.delete(:external_identifier)
+        person.delete("external_identifier")
+      end
+
+      if created_at = person[:created_at] || person["created_at"]
+        if created_at.respond_to?(:to_i)
+          created_at = created_at.to_i
+        end
+
+        person[:created_at] = created_at
+        person.delete("created_at")
       end
+
+      person
+    end
+
+    def prepare_account_hash(account)
+      # id for account should actually be passed as external_identifier
+      # make that correction here before sending (LEGACY SUPPORT)
+      external_id = account[:external_identifier] || account["external_identifier"]
+      if account_id = account[:id] || account["id"]
+        if external_id.nil?
+          account[:external_identifier] = account_id
+          account.delete(:id)
+          account.delete("id")
+        end
+      end
+
+      account
+    end
+
+    def prepare_event_hash(event)
+      event[:source] = Preact.configuration.user_agent
+      event
     end
     
     private

data/lib/preact/sidekiq/preact_logging_worker.rb

@@ -1,6 +1,8 @@
+require 'sidekiq'
+
 module Preact::Sidekiq
   class PreactLoggingWorker
-    include Sidekiq::Worker
+    include ::Sidekiq::Worker
 
     def perform(person, event=nil)
       client = Preact::Client.new

data/lib/preact/version.rb

@@ -1,3 +1,3 @@
 module Preact
-  VERSION = "0.8.6"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: preact
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -135,14 +135,9 @@ files:
 - lib/preact/background_logger.rb
 - lib/preact/client.rb
 - lib/preact/configuration.rb
-- lib/preact/objects/account.rb
-- lib/preact/objects/account_event.rb
-- lib/preact/objects/action_event.rb
 - lib/preact/objects/action_link.rb
 - lib/preact/objects/api_object.rb
 - lib/preact/objects/event.rb
-- lib/preact/objects/message.rb
-- lib/preact/objects/person.rb
 - lib/preact/rails/controllers/helpers.rb
 - lib/preact/rails.rb
 - lib/preact/sidekiq/preact_logging_worker.rb

data/lib/preact/objects/account.rb

@@ -1,21 +0,0 @@
-class Preact::Account < Preact::ApiObject
-    
-  attr_accessor :id, :name
-  attr_accessor :license_status, :license_mrr, :license_type, :license_count, :license_value, :license_duration, :license_renewal
-    
-  def as_json(options={})
-    {
-      :name               => self.name,
-      :external_identifier=> self.id,
-
-      :license_type       => self.license_type,
-      :license_count      => self.license_count,
-      :license_renewal    => self.license_renewal,
-      :license_value      => self.license_value,
-      :license_mrr        => self.license_mrr,
-      :license_duration   => self.license_duration,
-      :license_status     => self.license_status
-    }
-  end
-    
-end

data/lib/preact/objects/account_event.rb

@@ -1,12 +0,0 @@
-module Preact
-	class AccountEvent < Event
-
-    def as_json(options={})
-      super(options).merge({
-        :klass => "accountevent"
-      })
-    end
-
-	end
-
-end

data/lib/preact/objects/action_event.rb

@@ -1,5 +0,0 @@
-module Preact
-	class ActionEvent < Event
-
-	end
-end

data/lib/preact/objects/message.rb

@@ -1,13 +0,0 @@
-class Preact::Message < Preact::Event
-  
-  attr_accessor :subject, :body
-
-  def as_json(options={})
-    super(options).merge({
-      :klass => "message",
-      :subject => self.subject,
-      :body => self.body
-    })
-  end
-  
-end

data/lib/preact/objects/person.rb

@@ -1,15 +0,0 @@
-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 ? self.created_at.to_i : nil,
-      :properties          => self.properties || {}
-    }
-  end
-    
-end