intellisense-ruby 0.6.5

data/lib/intellisense-ruby/client.rb

@@ -0,0 +1,269 @@
+
+require 'time'
+require 'thread'
+require 'intellisense-ruby/defaults'
+require 'intellisense-ruby/consumer'
+require 'intellisense-ruby/request'
+require 'json'
+
+module IntellisenseRuby
+
+  class Client
+
+    # public: Creates a new client
+    #
+    # options - Hash
+    #           :secret         - String of your project's secret
+    #           :max_queue_size - Fixnum of the max calls to remain queued (optional)
+    #           :on_error       - Proc which handles error calls from the API
+    def initialize(options = {})
+
+      @queue = Queue.new
+      @secret = options[:secret]
+      @max_queue_size = options[:max_queue_size] || IntellisenseRuby::Defaults::Queue::MAX_SIZE
+
+      check_api_key
+
+      @consumer = IntellisenseRuby::Consumer.new(@queue, @secret, options)
+      @thread = Thread.new { @consumer.run }
+
+      @logger = options[:logger]
+      log('DEBUG: ############## SENSOR initialized!')
+
+    end
+
+    # public: describe entities in the graph
+    # 
+    # entity - Hash
+    #           :type       - type of entity (program, course, user, etc.)
+    #           :entity_id  - entity Id
+    #           :properties - Hash of entity properties (optional, but recommended)
+    #           :timestamp  - Time of when the event occurred. (optional)
+    #
+    #
+    def describe(entity)
+
+      log('DEBUG: ############## describing entity' + entity.to_s)
+
+      check_api_key
+
+      type       = entity[:type]
+      entity_id  = entity[:entity_id].to_s
+      properties = entity[:properties] || {}
+      timestamp  = entity[:timestamp] || Time.new
+
+      check_timestamp(timestamp)
+
+      if type.nil? || type.empty?
+        fail ArgumentError, 'Must supply type as a non-empty string'
+      end
+
+      if entity_id.nil? || entity_id.empty?
+        fail ArgumentError, 'Must supply entity_id as a non-empty string'
+      end
+
+      fail ArgumentError, 'Properties must be a Hash' unless properties.is_a? Hash
+
+      enqueue({ type:        type,
+                entityId:    entity_id,
+                properties:  properties,
+                timestamp:   timestamp.iso8601,
+                action:      'describe'})
+    end
+
+    # public: describe entities in the graph
+    # 
+    # entity - Hash
+    #           :type  - type of entity (program, course, user, etc.)
+    #           :id    - entity Id
+    #           :properties - Hash of entity properties (optional, but recommended)
+    #           :timestamp  - Time of when the event occurred. (optional)
+    #
+    #
+    def track(learning_event)
+
+      log('DEBUG: ############## recording learning event!')
+
+      check_api_key
+
+      type       = options[:type]
+      entity_id  = options[:entity_id].to_s
+      properties = options[:properties] || {}
+      timestamp  = options[:timestamp] || Time.new
+
+      check_timestamp(timestamp)
+
+      if type.nil? || type.empty?
+        fail ArgumentError, 'Must supply type as a non-empty string'
+      end
+
+      fail ArgumentError, 'Properties must be a Hash' unless properties.is_a? Hash
+
+      enqueue({ type:      type,
+                entityId:     entity_id,
+                properties: properties,
+                timestamp:  timestamp.iso8601,
+                action:     'measure'})
+    end
+
+
+    # public: Synchronously waits until the consumer has flushed the queue.
+    #         Use only for scripts which are not long-running, and will
+    #         specifically exit
+    #
+    def flush
+      while !@queue.empty? || @consumer.is_requesting?
+        sleep(0.1)
+      end
+    end
+
+    # public: Tracks an event
+    #
+    # options - Hash
+    #           :event      - String of event name.
+    #           :user_id    - String of the user id.
+    #           :properties - Hash of event properties. (optional)
+    #           :timestamp  - Time of when the event occurred. (optional)
+    #           :context    - Hash of context. (optional)
+    def track(options)
+
+      check_api_key
+
+      event = options[:event]
+      user_id = options[:user_id].to_s
+      properties = options[:properties] || {}
+      timestamp = options[:timestamp] || Time.new
+      context = options[:context] || {}
+
+      ensure_user(user_id)
+      check_timestamp(timestamp)
+
+      if event.nil? || event.empty?
+        fail ArgumentError, 'Must supply event as a non-empty string'
+      end
+
+      fail ArgumentError, 'Properties must be a Hash' unless properties.is_a? Hash
+
+      add_context(context)
+
+      enqueue({ event:      event,
+                userId:     user_id,
+                context:    context,
+                properties: properties,
+                timestamp:  timestamp.iso8601,
+                action:     'track' })
+    end
+
+    # public: Identifies a user
+    #
+    # options - Hash
+    #           :user_id   - String of the user id
+    #           :traits    - Hash of user traits. (optional)
+    #           :timestamp - Time of when the event occurred. (optional)
+    #           :context   - Hash of context. (optional)
+    def identify(options)
+
+      check_api_key
+
+      user_id = options[:user_id].to_s
+      traits = options[:traits] || {}
+      timestamp = options[:timestamp] || Time.new
+      context = options[:context] || {}
+
+      ensure_user(user_id)
+      check_timestamp(timestamp)
+
+      fail ArgumentError, 'Must supply traits as a hash' unless traits.is_a? Hash
+
+      add_context(context)
+
+      enqueue({ userId:    user_id,
+                context:   context,
+                traits:    traits,
+                timestamp: timestamp.iso8601,
+                action:    'identify' })
+    end
+
+    # public: Aliases a user from one id to another
+    #
+    # options - Hash
+    #           :from      - String of the id to alias from
+    #           :to        - String of the id to alias to
+    #           :timestamp - Time of when the alias occured (optional)
+    #           :context   - Hash of context (optional)
+    def alias(options)
+
+      check_api_key
+
+      from = options[:from].to_s
+      to = options[:to].to_s
+      timestamp = options[:timestamp] || Time.new
+      context = options[:context] || {}
+
+      ensure_user(from)
+      ensure_user(to)
+      check_timestamp(timestamp)
+
+      add_context(context)
+
+      enqueue({ from:      from,
+                to:        to,
+                context:   context,
+                timestamp: timestamp.iso8601,
+                action:    'alias' })
+    end
+
+    # public: Returns the number of queued messages
+    #
+    # returns Fixnum of messages in the queue
+    def queued_messages
+      @queue.length
+    end
+
+    private
+
+    # private: Enqueues the action.
+    #
+    # returns Boolean of whether the item was added to the queue.
+    def enqueue(action)
+      queue_full = @queue.length >= @max_queue_size
+      @queue << action.to_json unless queue_full
+
+      !queue_full
+    end
+
+    # private: Ensures that a user id was passed in.
+    #
+    # user_id    - String of the user id
+    #
+    def ensure_user(user_id)
+      fail ArgumentError, 'Must supply a non-empty user_id' if user_id.empty?
+    end
+
+    # private: Adds contextual information to the call
+    #
+    # context - Hash of call context
+    def add_context(context)
+      context[:library] = 'intellisense-ruby'
+    end
+
+    # private: Checks that the secret is properly initialized
+    def check_api_key
+      fail 'Secret must be initialized' if @secret.nil?
+    end
+
+    # private: Checks the timstamp option to make sure it is a Time.
+    def check_timestamp(timestamp)
+      fail ArgumentError, 'Timestamp must be a Time' unless timestamp.is_a? Time
+    end
+
+    # private: log the requested message
+    def log(message) 
+      if !@logger.nil?
+        @logger.debug(message)
+      else
+        puts message
+      end
+    end
+  end
+end

data/lib/intellisense-ruby/consumer.rb

@@ -0,0 +1,106 @@
+
+require 'intellisense-ruby/defaults'
+require 'intellisense-ruby/request'
+require 'intellisense-ruby/sqs_publisher'
+
+module IntellisenseRuby
+
+  class Consumer
+
+    # public: Creates a new consumer
+    #
+    # The consumer continuously takes messages off the queue
+    # and makes requests to the intellify api
+    #
+    # queue   - Queue synchronized between client and consumer
+    # secret  - String of the project's secret
+    # options - Hash of consumer options
+    #           batch_size - Fixnum of how many items to send in a batch
+    #           on_error   - Proc of what to do on an error
+    #
+    def initialize(queue, secret, options = {})
+      @queue = queue
+      @secret = secret
+      @batch_size = options[:batch_size] || IntellisenseRuby::Defaults::Queue::BATCH_SIZE
+      @on_error = options[:on_error] || Proc.new { |status, error| }
+      @transport = options[:transport] || IntellisenseRuby::Defaults::Request::TRANSPORT
+
+      @current_batch = []
+
+      @mutex = Mutex.new
+
+      @logger = options[:logger]
+      log('DEBUG ############## SENSOR initialized! with transport ' + @transport)
+
+    end
+
+    # public: Continuously runs the loop to check for new events
+    #
+    def run
+      while true
+        flush
+      end
+    end
+
+    # public: Flush some events from our queue
+    #
+    def flush
+      # Block until we have something to send
+      item = @queue.pop()
+
+      # Synchronize on additions to the current batch
+      @mutex.synchronize {
+        @current_batch << item
+        until @current_batch.length >= @batch_size || @queue.empty?
+          @current_batch << @queue.pop()
+        end
+      }
+
+      #log("about to send messages " + @current_batch)
+
+      case @transport
+      when 'http'
+        puts 'using http transport'
+        req = IntellisenseRuby::Request.new
+        res = req.post(@secret, @current_batch)
+        @on_error.call(res.status, res.error) unless res.status == 200
+        @mutex.synchronize {
+          @current_batch = []
+        }
+      when 'sqs'
+        log('DEBUG ############## SENSOR using SQS transport to send ' + @current_batch.to_s)
+        sqs = IntellisenseRuby::SQS_Publisher.new logger: @logger
+        sqs.send_message(@current_batch)
+        @mutex.synchronize {
+          @current_batch = []
+        }
+      else
+        # cannot do anything
+        puts 'UNKNOWN transport - error'
+      end
+
+    end
+
+    # public: Check whether we have outstanding requests.
+    #
+    def is_requesting?
+      requesting = nil
+      @mutex.synchronize {
+        requesting = !@current_batch.empty?
+      }
+      requesting
+    end
+
+    private
+
+    # private: log the requested message
+    def log(message)
+      if !@logger.nil?
+        @logger.debug(message)
+      else
+        puts message
+      end
+    end
+
+  end
+end

data/lib/intellisense-ruby/defaults.rb

@@ -0,0 +1,19 @@
+
+module IntellisenseRuby
+  module Defaults
+
+    module Request
+      TRANSPORT = 'http'
+      BASE_URL = 'http://www.intellifylearning.com/intellify' unless defined? IntellisenseRuby::Defaults::Request::BASE_URL
+      PATH = '/v1/import' unless defined? IntellisenseRuby::Defaults::Request::PATH
+      SSL = { verify: false } unless defined? IntellisenseRuby::Defaults::Request::SSL
+      HEADERS = { accept: 'application/json' } unless defined? IntellisenseRuby::Defaults::Request::HEADERS
+    end
+
+    module Queue
+      BATCH_SIZE = 100 unless defined? IntellisenseRuby::Defaults::Queue::BATCH_SIZE
+      MAX_SIZE = 10000 unless defined? IntellisenseRuby::Defaults::Queue::MAX_SIZE
+    end
+
+  end
+end

data/lib/intellisense-ruby/json.rb

@@ -0,0 +1,27 @@
+require 'multi_json'
+
+module IntellisenseRuby
+
+  #
+  # JSON Wrapper module using MultiJson 1.3
+  #
+  module JSON
+    if MultiJson.respond_to?(:dump)
+      def self.dump(*args)
+        MultiJson.dump(*args)
+      end
+
+      def self.load(*args)
+        MultiJson.load(*args)
+      end
+    else
+      def self.dump(*args)
+        MultiJson.encode(*args)
+      end
+
+      def self.load(*args)
+        MultiJson.decode(*args)
+      end
+    end
+  end
+end

data/lib/intellisense-ruby/request.rb

@@ -0,0 +1,53 @@
+
+require 'intellisense-ruby/defaults'
+require 'intellisense-ruby/response'
+require 'intellisense-ruby/json'
+require 'faraday'
+require 'faraday_middleware'
+
+module IntellisenseRuby
+
+  class Request
+
+    # public: Creates a new request object to send analytics batch
+    #
+    def initialize(options = {})
+
+      options[:url] ||= IntellisenseRuby::Defaults::Request::BASE_URL
+      options[:ssl] ||= IntellisenseRuby::Defaults::Request::SSL
+      options[:headers] ||= IntellisenseRuby::Defaults::Request::HEADERS
+      @path = options[:path] || IntellisenseRuby::Defaults::Request::PATH
+
+      @conn = Faraday.new(options) do |faraday|
+        faraday.request :json
+        faraday.response :json, :content_type => /\bjson$/
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    # public: Posts the secret and batch of messages to the API.
+    #
+    # returns - Response of the status and error if it exists
+    def post(secret, batch)
+
+      status, error = nil, nil
+
+      begin
+        res = @conn.post do |req|
+          req.options[:timeout] = 8
+          req.options[:open_timeout] = 3
+          req.url(@path)
+          req.body = IntellisenseRuby::JSON::dump(secret: secret, batch: batch)
+        end
+        status = res.status
+        error  = res.body["error"]
+
+      rescue Exception => err
+        status = -1
+        error = "Connection error: #{err}"
+      end
+
+      IntellisenseRuby::Response.new(status, error)
+    end
+  end
+end

data/lib/intellisense-ruby/response.rb

@@ -0,0 +1,17 @@
+
+module IntellisenseRuby
+
+  class Response
+
+    attr_reader :status
+    attr_reader :error
+
+    # public: Simple class to wrap responses from the API
+    #
+    #
+    def initialize(status = 200, error = nil)
+      @status = status
+      @error  = error
+    end
+  end
+end

data/lib/intellisense-ruby/sqs_publisher.rb

@@ -0,0 +1,53 @@
+require 'intellisense-ruby/defaults'
+require 'intellisense-ruby/request'
+require 'aws-sdk'
+require 'pp'
+
+module IntellisenseRuby
+
+  class SQS_Publisher
+
+    def initialize(options = {})
+
+      @sqs = AWS::SQS.new(
+        :access_key_id => 'AKIAJPYU646KQOWWZ4SA',
+        :secret_access_key => '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')
+
+      @sqs_queue = @sqs.queues['https://sqs.us-east-1.amazonaws.com/691677686063/yoda-events']
+
+      @logger = options[:logger]
+      log('DEBUG ############## SQS_Publisher created! with queue ' + @sqs_queue.to_s)
+
+      #queue_urls = @sqs.queues.collect(&:url)
+      #queue = @sqs.queues[queue_urls[0]]
+      #pp queue
+      # msg = queue.send_message("TEST")
+      # puts "Sent message: #{msg.id}"
+
+    end
+
+    def send_message(message = {})
+
+    	return false unless @sqs_queue
+
+      log('DEBUG ############## SQS_Publisher created! sending message ' + message.to_s)
+
+    	val = message.to_s
+    	msg = @sqs_queue.send_message(val)
+    	puts "Sent message: #{msg.id}"
+
+    end
+
+    private
+    # private: log the requested message
+    def log(message)
+      if !@logger.nil?
+        @logger.debug(message)
+      else
+        puts message
+      end
+    end
+
+  end
+
+end

data/lib/intellisense-ruby/version.rb

@@ -0,0 +1,3 @@
+module IntellisenseRuby
+  VERSION = '0.6.5'
+end

data/lib/intellisense-ruby.rb

@@ -0,0 +1,50 @@
+require 'intellisense-ruby/version'
+require 'intellisense-ruby/client'
+
+module IntellisenseRuby
+
+  module ClassMethods
+
+    # By default use a single client for the module
+    def init(options = {})
+      @client = IntellisenseRuby::Client.new options
+    end
+
+    def describe(entity)
+      return false unless @client
+      @client.describe entity 
+    end
+
+    def track(learning_event)
+      return false unless @client
+      @client.measure event 
+    end
+
+    def track(options)
+      return false unless @client
+      @client.track(options)
+    end
+
+    def identify(options)
+      return false unless @client
+      @client.identify(options)
+    end
+
+    def alias(options)
+      return false unless @client
+      @client.alias(options)
+    end
+
+    def flush
+      return false unless @client
+      @client.flush
+    end
+
+  end
+
+  extend ClassMethods
+
+end
+
+# Alias for IntellisenseRuby
+Intellisense = IntellisenseRuby