botanalytics 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8118a81982da69c23bd717e419f7087cfad3c306b31e48ef3be04b54870f3a8c
+  data.tar.gz: 2c0e9688fdc4c7b798b0d609ccc742a81dffc1445f981f4092284913ab294e6b
+SHA512:
+  metadata.gz: e5b311fd5f1663438e79fae71f0fc95f749e1735c2dd63750cce3b5546750abfc7cfd48268ae41a723067b5ff6fca66dac714ef21d92489ed6c1b36ba9b8aa1e
+  data.tar.gz: ac70bd6d10c1440c3848d76206353d2a9943684f4888420aa2bfd97f08324b25758c8562db3a52e925512f393a92f904a1ecc0daddaf9d0f15a34e4d2a699612

data/lib/botanalytics.rb

@@ -0,0 +1,13 @@
+require_relative 'botanalytics/google'
+require_relative 'botanalytics/amazon'
+require_relative 'botanalytics/facebook'
+require_relative 'botanalytics/generic'
+require_relative 'botanalytics/slack'
+module Botanalytics
+    AmazonAlexa = ::AmazonAlexa
+    GoogleAssistant = ::GoogleAssistant
+    Generic = ::Generic
+    SlackRTMApi = ::SlackRTMApi
+    SlackEventApi = ::SlackEventApi
+    FacebookMessenger = ::FacebookMessenger
+end

data/lib/botanalytics/amazon.rb

@@ -0,0 +1,64 @@
+require_relative '../util/util'
+
+# Amazon Alexa Logger
+class AmazonAlexa < Envoy
+    # @param params Hash
+    # @raise ArgumentError When token is nil
+    def initialize(params = {})
+        super(params)
+        @path = 'messages/amazon-alexa/'
+        @async = params.fetch(:async, false)
+        informs("Logging enabled for #{self.class.name}...")
+        if @async
+            require 'concurrent'
+            @executor_service = Concurrent::ThreadPoolExecutor.new(
+                min_threads: 1,
+                max_threads: Concurrent.processor_count,
+                max_queue: 100,
+                fallback_policy: :caller_runs
+            )
+            informs("Mode: Async...")
+        end
+    end
+
+    def log(req, res)
+        validation = validate(req, res)
+        if validation[:ok]
+            payload = {:request => req, :response => res}
+            informs("Logging messages...")
+            informs(payload)
+            if @async
+                @executor_service.post do
+                    submits(payload, @path)
+                end
+            else
+                submits(payload, @path)
+            end
+        else
+            fails(validation[:err], validation[:reason], {:request => req, :response => res})
+        end
+    end
+    # @param req Hash
+    # @param res Hash
+    # @return Hash
+    def validate(req, res)
+        pv = is_valid(req, {}, 'request')
+        unless pv[:ok]
+            return pv
+        end
+        pv = is_valid(req, {}, 'request', 'request')
+        unless pv[:ok]
+            return pv
+        end
+        pv = is_valid(req, "", 'request', 'context', 'System', 'user', 'userId')
+        unless pv[:ok]
+            return pv
+        end
+        pv = is_valid(res, {}, 'response')
+        unless pv[:ok]
+            return pv
+        end
+        is_valid(res, {}, 'response', 'response')
+    end
+    private :validate
+end

data/lib/botanalytics/facebook.rb

@@ -0,0 +1,106 @@
+require_relative "../util/util"
+
+require_relative '../util/util'
+
+# Facebook Logger
+class FacebookMessenger < Envoy
+    # @param params Hash
+    # @raise ArgumentError When token is nil
+    def initialize(params = {})
+        super(params)
+        @fb_token = params.fetch(:fb_token, nil)
+        @path = 'messages/facebook-messenger/'
+        @profile_path = 'facebook-messenger/users/'
+        @async = params.fetch(:async, false)
+        informs("Logging enabled for #{self.class.name}...")
+        if @async
+            require 'concurrent'
+            @executor_service = Concurrent::ThreadPoolExecutor.new(
+                min_threads: 1,
+                max_threads: Concurrent.processor_count,
+                max_queue: 100,
+                fallback_policy: :caller_runs
+            )
+            informs("Mode: Async...")
+        end
+    end
+    # @param message Hash
+    def log_incoming(message)
+        validation = validate(message, "Incoming message")
+        if validation[:ok]
+            payload = {
+                'recipient': nil,
+                'timestamp': (Time.new.to_f*1000).to_i,
+                'message': message
+            }
+            informs("Logging incoming message...")
+            informs(message)
+            if @async
+                @executor_service.post do
+                    submits(payload, @path)
+                end
+            else
+                submits(payload, @path)
+            end
+        else
+            fails(validation[:err], validation[:reason], message)
+        end
+    end
+    # @param message Hash
+    # @param sender_id String
+    def log_outgoing(message, sender_id)
+        validation = validate_outgoing(message, sender_id)
+        if validation[:ok]
+            payload = {
+                'recipient': sender_id,
+                'timestamp': (Time.new.to_f*1000).to_i,
+                'message': message,
+                'fb_token': @fb_token
+            }
+            informs("Logging outgoing message...")
+            informs(message)
+            if @async
+                @executor_service.post do
+                    submits(payload, @path)
+                end
+            else
+                submits(payload, @path)
+            end
+        else
+            fails(validation[:err], validation[:reason], message)
+        end
+    end
+
+    # @param message Hash
+    def log_user_profile(message)
+        validation = validate(message, "User profile")
+        if validation[:ok]
+            informs("Logging user profile message...")
+            informs(message)
+            if @async
+                @executor_service.post do
+                    submits(message, @profile_path)
+                end
+            else
+                submits(message, @profile_path)
+            end
+        else
+            fails(validation[:err], validation[:reason], message)
+        end
+    end
+
+    def validate(payload, name)
+        is_valid(payload, {}, name)
+    end
+
+    def validate_outgoing(message, sender_id)
+        mv = is_valid(message, {}, "Outgoing message")
+        unless mv[:ok]
+            return mv
+        end
+        is_valid(sender_id, "", "Sender id")
+    end
+
+    private :validate
+    private :validate_outgoing
+end

data/lib/botanalytics/generic.rb

@@ -0,0 +1,65 @@
+require_relative "../util/util"
+
+# Generic Logger
+class Generic < Envoy
+    # @param params Hash
+    # @raise ArgumentError When token is nil
+    def initialize(params = {})
+        super(params)
+        @async = params.fetch(:async, false)
+        informs("Logging enabled for #{self.class.name}...")
+        if @async
+            require 'concurrent'
+            @executor_service = Concurrent::ThreadPoolExecutor.new(
+                min_threads: 1,
+                max_threads: Concurrent.processor_count,
+                max_queue: 100,
+                fallback_policy: :caller_runs
+            )
+            informs("Mode: Async...")
+        end
+    end
+
+    # @param message Hash
+    def log(message)
+        validation = validate(message)
+        if validation[:ok]
+            informs("Logging messages...")
+            informs(message)
+            if @async
+                @executor_service.post do
+                    submits(message)
+                end
+            else
+                submits(message)
+            end
+        else
+            fails(validation[:err], validation[:reason], message)
+        end
+    end
+    # @param payload Hash
+    def validate(payload)
+        pv = is_valid(payload, {}, 'payload')
+        unless pv[:ok]
+            return pv
+        end
+        pv = is_valid(payload, Object.new, 'payload', 'is_sender_bot')
+        unless pv[:ok]
+            return pv
+        end
+        pv = is_valid(payload, "", 'payload', 'user', 'id')
+        unless pv[:ok]
+            return pv
+        end
+        pv = is_valid(payload, "", 'payload', 'user', 'name')
+        unless pv[:ok]
+            return pv
+        end
+        pv = is_valid(payload, "", 'payload', 'message', 'text')
+        unless pv[:ok]
+            return pv
+        end
+        is_valid(payload, 1, 'payload', 'message', 'timestamp')
+    end
+    private :validate
+end

data/lib/botanalytics/google.rb

@@ -0,0 +1,67 @@
+require_relative '../util/util'
+
+# GoogleAsistant Logger
+class GoogleAssistant < Envoy
+  # @param params Hash
+  # @raise ArgumentError When token is nil
+  def initialize(params = {})
+    super(params)
+    @path = 'messages/google-assistant/'
+    @async = params.fetch(:async, false)
+    informs("Logging enabled for #{self.class.name}...")
+    if @async
+        require 'concurrent'
+        @executor_service = Concurrent::ThreadPoolExecutor.new(
+          min_threads: 1,
+          max_threads: Concurrent.processor_count,
+          max_queue: 100,
+          fallback_policy: :caller_runs
+        )
+        informs("Mode: Async...")
+    end
+  end
+
+  # @param req Hash
+  # @param res Hash
+  def log(req, res)
+    validation = validate(req, res)
+    if validation[:ok]
+      payload = {:request => req, :response => res}
+      informs("Logging messages...")
+      informs(payload)
+      if @async
+        @executor_service.post do
+            submits(payload, @path)
+        end
+      else
+        submits(payload, @path)
+      end
+    else
+      fails(validation[:err], validation[:reason], {:request => req, :response => res})
+    end
+  end
+
+  def validate(req, res)
+    pv = is_valid(req, {}, 'request')
+    unless pv[:ok]
+      return pv
+    end
+    pv = is_valid(req, "", 'request', 'user', 'userId')
+    unless pv[:ok]
+      return pv
+    end
+    pv = is_valid(req, "", 'request', 'conversation', 'conversationId')
+    unless pv[:ok]
+      return pv
+    end
+    pv = is_valid(res, {}, 'response')
+    unless pv[:ok]
+      return pv
+    end
+    res['expectUserResponse'] ?
+        is_valid(res, {}, 'response', 'finalResponse'):
+        is_valid(res, [], 'response', 'expectedInputs')
+
+  end
+  private :validate
+end

data/lib/botanalytics/slack.rb

@@ -0,0 +1,301 @@
+require_relative "../util/util"
+require 'net/https'
+require 'uri'
+require 'json'
+require 'thread'
+
+class SlackRTMApi < Envoy
+
+    def initialize(params={})
+        super(params)
+        @slack_token = params.fetch(:slack_token, nil)
+        raise ArgumentError.new "slack_token can not be nil or empty" if @slack_token.nil? || @slack_token.to_s.empty?
+        @path = 'messages/slack/'
+        @initialize_path = 'bots/slack/initialize/'
+        @active_user = nil
+        @active_team = nil
+        @async = params.fetch(:async, false)
+        informs("Logging enabled for #{self.class.name}...")
+        if @async
+            require 'concurrent'
+            @executor_service = Concurrent::ThreadPoolExecutor.new(
+                min_threads: 1,
+                max_threads: Concurrent.processor_count+1,
+                max_queue: 100,
+                fallback_policy: :caller_runs
+            )
+            @executor_service.post do
+                fetch
+            end
+            informs("Mode: Async...")
+        else
+            Thread.new do
+                fetch
+            end
+        end
+    end
+
+    def fetch
+        informs("Initializing slack rtm api bot...")
+        wait_interval = 2
+        update_interval = 3600
+        uri = URI.parse('https://slack.com/api/rtm.start')
+        while true
+            begin
+                response = Net::HTTP.post_form(uri, :token => @slack_token)
+                case response
+                when Net::HTTPSuccess
+                    start_data = JSON.parse(response.body)
+                    if start_data['ok']
+
+                        @active_user = start_data['self']['id']
+                        @active_team = start_data['team']['id']
+
+                        if submits(start_data, @initialize_path, "Successfully updated bot '#{start_data['self']['name']}' info...")
+                            informs("Botanalytics::#{self.class.name} initialized team info successfully...")
+                            sleep update_interval
+                            wait_interval = 2
+                        else
+                            sleep wait_interval
+                            if wait_interval < 20
+                                wait_interval += 3
+                            end
+                            informs("Botanalytics::#{self.class.name} can not initialize team info, retrying...")
+                        end
+                    else
+                        # nope there is a problem here, try
+                        sleep wait_interval
+                        if wait_interval < 20
+                            wait_interval += 3
+                        end
+                        informs("Botanalytics::#{self.class.name} can not initialize team info, retrying...")
+                    end
+                else
+                    informs("Botanalytics::#{self.class.name} can not initialize team info, Reason: statuscode:#{response.code} retrying...")
+                    sleep wait_interval
+                    if wait_interval < 20
+                        wait_interval += 3
+                    end
+                end
+            rescue Exception => e
+                informs("Botanalytics::#{self.class.name} can not initialize team info due to http error, Error: #{e.message}, retrying...")
+                sleep wait_interval
+                if wait_interval < 20
+                    wait_interval += 3
+                end
+            end
+        end
+    end
+
+    # @param payload Hash
+    def log_incoming(payload)
+        if @active_team.nil? or @active_user.nil?
+            fails(Exception.new('team and bot'), 'Not initialized yet...')
+        else
+            validation = validate(payload)
+            if validation[:ok]
+                informs('Logging message...')
+                payload['is_bot'] = false
+                payload['team']= @active_team
+                informs(payload)
+                if @async
+                    @executor_service.post do
+                        submits(payload, @path)
+                    end
+                else
+                    submits(payload, @path)
+                end
+            else
+                fails(validation[:err], validation[:reason], payload)
+            end
+        end
+    end
+
+    def log_outgoing(channel_id, message, params = {})
+        #thread=None, reply_broadcast=None, msg_payload=None
+
+        if @active_team.nil? or @active_user.nil?
+            fails(Exception.new('team and bot'), 'Not initialized yet...')
+        else
+            thread = params.fetch(:thread, nil)
+            reply_broadcast = params.fetch(:reply_broadcast, nil)
+            msg_payload = params.fetch(:msg_payload, nil)
+            if !msg_payload.nil?
+                unless msg_payload.is_a?(Hash)
+                    fails(Exception.new("Expected format for msg_payload is Hash found #{msg_payload.class.name}"), 'Unexpected payload format!')
+                    return
+                end
+                msg = msg_payload.clone
+                validation = validate(msg)
+                if validation[:ok]
+                    msg['is_bot'] = true
+                    msg['ts'] = (Time.new.to_f*1000).to_s
+                    msg['team'] = @active_team
+                    msg['user'] = @active_user
+                    informs('Logging message...')
+                    informs(msg)
+                    if @async
+                        @executor_service.post do
+                            submits(msg, @path)
+                        end
+                    else
+                        submits(msg, @path)
+                    end
+                else
+                    informs("Message does not contain 'type' field. Ignoring...")
+                end
+            else
+                payload = Hash.new
+                payload['type'] = 'message'
+                payload['channel'] = channel_id
+                payload['text'] = message
+                payload['thread_ts'] = thread unless thread.nil?
+                payload['reply_broadcast'] = reply_broadcast unless reply_broadcast.nil?
+                payload['is_bot'] = true
+                payload['ts'] = (Time.new.to_f*1000).to_s
+                payload['team'] = @active_team
+                payload['user'] = @active_user
+                if @async
+                    @executor_service.post do
+                        submits(payload, @path)
+                    end
+                else
+                    submits(payload, @path)
+                end
+            end
+        end
+    end
+
+
+    def validate(payload)
+        is_valid(payload, "", 'message', 'type')
+    end
+    private :fetch
+    private :validate
+end
+
+class SlackEventApi < Envoy
+
+    def initialize(params={})
+        super(params)
+        @slack_token = params.fetch(:slack_token, nil)
+        raise ArgumentError.new "slack_token can not be nil or empty" if @slack_token.nil? || @slack_token.to_s.empty?
+        @path = 'messages/slack/event/'
+        @initialize_path = 'bots/slack/initialize/'
+        @interactive_path = 'messages/slack/interactive/'
+        @active_user = nil
+        @active_team = nil
+        @async = params.fetch(:async, false)
+        informs("Logging enabled for #{self.class.name}...")
+        if @async
+            require 'concurrent'
+            @executor_service = Concurrent::ThreadPoolExecutor.new(
+                min_threads: 1,
+                max_threads: Concurrent.processor_count+1,
+                max_queue: 100,
+                fallback_policy: :caller_runs
+            )
+            @executor_service.post do
+                fetch
+            end
+            informs("Mode: Async...")
+        else
+            Thread.new do
+                fetch
+            end
+        end
+        @accepted_types = %w(event_callback interactive_message)
+    end
+
+    def fetch
+        informs("Initializing slack event api bot...")
+        wait_interval = 2
+        update_interval = 3600
+        uri = URI.parse('https://slack.com/api/rtm.start')
+        while true
+            begin
+                response = Net::HTTP.post_form(uri, :token => @slack_token)
+                case response
+                when Net::HTTPSuccess
+                    start_data = JSON.parse(response.body)
+                    if start_data['ok']
+
+                        @active_user = start_data['self']['id']
+                        @active_team = start_data['team']['id']
+
+                        if submits(start_data, @initialize_path, "Successfully updated bot '#{start_data['self']['name']}' info...")
+                            informs("Botanalytics::#{self.class.name} initialized team info successfully...")
+                            sleep update_interval
+                            wait_interval = 2
+                        else
+                            sleep wait_interval
+                            if wait_interval < 20
+                                wait_interval += 3
+                            end
+                            informs("Botanalytics::#{self.class.name} can not initialize team info, retrying...")
+                        end
+                    else
+                        # nope there is a problem here, try
+                        sleep wait_interval
+                        if wait_interval < 20
+                            wait_interval += 3
+                        end
+                        informs("Botanalytics::#{self.class.name} can not initialize team info, retrying...")
+                    end
+                else
+                    informs("Botanalytics::#{self.class.name} can not initialize team info, Reason: statuscode:#{response.code} retrying...")
+                    sleep wait_interval
+                    if wait_interval < 20
+                        wait_interval += 3
+                    end
+                end
+            rescue Exception => e
+                informs("Botanalytics::#{self.class.name} can not initialize team info due to http error, Error: #{e.message}, retrying...")
+                sleep wait_interval
+                if wait_interval < 20
+                    wait_interval += 3
+                end
+            end
+        end
+    end
+
+    # @param payload Hash
+    def log(payload)
+        if payload.is_a?(Hash)
+            return unless payload['challenge'].nil?
+        end
+
+        if @active_team.nil? or @active_user.nil?
+            fails(Exception.new('team and bot'), 'Not initialized yet...')
+        else
+            validation = validate(payload)
+            if validation[:ok]
+                if @accepted_types.include?(payload['type'])
+                    informs('Logging message...')
+                    informs(payload)
+                    if @async
+                        @executor_service.post do
+                            submits(payload, payload['type'] == 'event_callback' ? @path : @interactive_path)
+                        end
+                    else
+                        submits(payload, payload['type'] == 'event_callback' ? @path : @interactive_path)
+                    end
+                else
+                    fails(
+                        Exception.new("Expected types, #{@accepted_types} but found #{payload['type']}"),
+                        'If you are sure this is a new event type, contact us < tech@botanalytics.co >',
+                        payload
+                    )
+                end
+            else
+                fails(validation[:err], validation[:reason], payload)
+            end
+        end
+    end
+
+    def validate(payload)
+        is_valid(payload, "", 'event', 'type')
+    end
+    private :fetch
+    private :validate
+end

data/lib/util/util.rb

@@ -0,0 +1,113 @@
+require 'net/http'
+require 'uri'
+
+# Validator method
+def is_valid(payload, t, name, *keys)
+
+  return {
+    :ok=>false,
+    :reason => 'nil payload is not accepted!',
+    :err => Exception.new("payload is nil!")
+  } if payload.nil?
+  if keys.any?
+    path = ''
+    temp = nil
+    keys.each {
+      |key|
+      if temp.nil?
+        path += key
+        return {
+            :ok => false,
+            :reason => 'Field does not exist',
+            :err => Exception.new("Expected field <#{key}> can not be found in #{name}")
+        } if payload[key.to_sym].nil? && payload[key].nil?
+        temp = payload[key] || payload[key.to_sym]
+      else
+        path += '.'+key
+        return {
+            :ok => false,
+            :reason => 'Field does not exist',
+            :err => Exception.new("Expected field <#{path}> can not be found in #{name}")
+        } if temp[key.to_sym].nil? && temp[key].nil?
+        temp = temp[key] || temp[key.to_sym]
+      end
+    }
+
+    temp.is_a?(t.class) ? {:ok => true} : {
+        :ok => false,
+        :reason => 'Unexpected format!',
+        :err => Exception.new("Expected format for #{path} is #{t.class.name}, found #{temp.class.name}")
+    }
+  else
+    payload.is_a?(t.class) ? {:ok => true} : {
+        :ok => false,
+        :reason => 'Unexpected format!',
+        :err => Exception.new("Expected format for #{name} is #{t.class.name}, found #{payload.class.name}")
+    }
+  end
+end
+# Main logging handler class
+# Others will be derived from it
+
+class Envoy
+
+  # @param params Hash
+  # @raise ArgumentError When token is nil
+  def initialize(params = {})
+    @debug = params.fetch(:debug, false)
+    @token = params.fetch(:token, nil)
+    raise ArgumentError.new 'Token can not be nil or empty' if @token.nil? || @token.to_s.empty?
+    @base_url = params.fetch(:base_url, "https://api.botanalytics.co/v1/")
+    @callback = params.fetch(:callback, nil)
+  end
+
+  # @param message Object
+  def informs(message)
+    if @debug
+      puts "[Botanalytics Debug]: #{message}"
+    end
+  end
+
+  # @param err Exception
+  # @param reason String
+  # @param payload Hash
+  def fails(err, reason, payload = nil)
+      if @callback.nil?
+          puts "[Botanalytics Error]: #{reason['error_message'] || reason  unless reason.nil?}, #{err.message unless err.nil?}...\n#{payload unless payload.nil?}"
+      else
+          send(@callback, err, reason, payload)
+      end
+  end
+
+  # @param parchment Hash (required)
+  # @param destination String
+  # @param word String
+  def submits(parchment, destination = 'messages/generic/', word = nil)
+      # Uri
+      uri = URI.parse(@base_url+destination)
+      # Header
+      header = {'Content-Type':'application/json', 'Authorization': 'Token '+@token}
+      begin
+          # Send request
+          response = Net::HTTP.post(uri, parchment.to_json, header)
+          if response.code == "200" or response.code == "201"
+              if word.nil?
+                  informs("Successfully logged message(s)...")
+              else
+                  informs(word)
+              end
+              return true
+          else
+              fails(Exception.new('Message(s) can not be logged! StatusCode:'+response.code), JSON.parse(response.body), parchment)
+              return false
+          end
+      rescue Exception => e
+          fails(e, 'Error during http request', parchment)
+          return false
+      end
+  end
+
+  protected :informs
+  protected :fails
+  protected :submits
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: botanalytics
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Beyhan Esen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: Analytics & engagement gem for chatbots
+email: tech@botanalytics.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/botanalytics.rb
+- lib/botanalytics/amazon.rb
+- lib/botanalytics/facebook.rb
+- lib/botanalytics/generic.rb
+- lib/botanalytics/google.rb
+- lib/botanalytics/slack.rb
+- lib/util/util.rb
+homepage: https://github.com/Botanalyticsco/botanalytics-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Tracker for bots
+test_files: []