hawkei 1.0.0

data/lib/hawkei/processor/worker.rb

@@ -0,0 +1,113 @@
+module Hawkei
+  module Processor
+    class Worker
+
+      FLUSH_INTERVAL_SECONDS = 3
+
+      FLUSH_MESSAGE = Object.new
+      SHUTDOWN_MESSAGE = Object.new
+
+      def initialize(queue, state)
+        @queue = queue
+        @state = state
+
+        @batch = Batch.new
+        @promises = Concurrent::Array.new
+
+        @timer = Concurrent::TimerTask.new(execution_interval: FLUSH_INTERVAL_SECONDS) { @queue << FLUSH_MESSAGE }
+        @timer.execute
+      end
+
+      def run
+        while thread_active?
+          message = @queue.pop
+
+          add_message_to_batch(message)
+        end
+
+        shutdown_worker
+      end
+
+      private
+
+      ##
+      # Add the message to a batch
+      #
+      # - Add message to a batch if it's not a flush message
+      # - flush batch if flush message is receive or batch is full
+      def add_message_to_batch(message)
+        @batch << message if message != FLUSH_MESSAGE
+        flush if message == FLUSH_MESSAGE || @batch.full?
+      end
+
+      ##
+      # Shutdown the worker
+      #
+      # - Close the timer
+      # - Retreive the last messages
+      # - Wait for all the request to be completed
+      #
+      # rubocop:disable Lint/HandleExceptions
+      def shutdown_worker
+        @timer.shutdown
+
+        begin
+          until (message = @queue.pop(true)).nil?
+            add_message_to_batch(message)
+          end
+        rescue ThreadError => _
+        end
+
+        flush
+
+        @promises.each do |promise|
+          promise.wait if promise && !promise.fulfilled?
+        end
+      end
+      # rubocop:enable Lint/HandleExceptions
+
+      def flush
+        return if @batch.empty?
+
+        send_batch(@batch)
+        @batch = Batch.new
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def send_batch(batch)
+        promise =
+          Concurrent::Promise
+          .new { Hawkei::Batch.create(Message.base.merge(data: batch.messages)) }
+          .on_success { @promises.delete(promise) }
+          .rescue do |error|
+            batch.update_retry
+
+            if error.is_a?(Hawkei::RequestError) && [401, 404].include?(error.http_status)
+              return logger.error(error.message)
+            end
+
+            if thread_active? && batch.can_retry?
+              Concurrent::ScheduledTask.new(batch.next_retry) { send_batch(batch) }.execute
+            else
+              @promises.delete(promise)
+            end
+          end
+
+        promise.execute
+        @promises << promise
+      rescue Concurrent::RejectedExecutionError => _
+        logger.error('Impossible to start a thread in closing application')
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def thread_active?
+        @state.true?
+      end
+
+      def logger
+        Hawkei.configurations.logger
+      end
+
+    end
+  end
+end

data/lib/hawkei/request.rb

@@ -0,0 +1,134 @@
+module Hawkei
+  ##
+  # == Hawkei \Request
+  #
+  # Build request
+  class Request
+    class << self
+
+      def execute(params = {})
+        klass = new(params)
+
+        if params[:method] == :post
+          klass.post
+        elsif params[:method] == :put
+          klass.put
+        elsif params[:method] == :delete
+          klass.delete
+        elsif params[:method] == :get
+          klass.get
+        else
+          raise Hawkei::UnknownRequestMethod, "#{params[:method]} haven't been implemented"
+        end
+      end
+
+      def post(params = {})
+        new(params).post
+      end
+
+      def put(params = {})
+        new(params).put
+      end
+
+      def get(params = {})
+        new(params).get
+      end
+
+      def delete(params = {})
+        new(params).delete
+      end
+    end
+
+    attr_reader :params, :http, :request
+
+    def initialize(params = {})
+      @params = params
+      @http   = Net::HTTP.new(uri.host, uri.port, uri_proxy.host, uri_proxy.port)
+
+      setup_ssl if params[:use_ssl]
+    end
+
+    def post
+      @request = Net::HTTP::Post.new(uri.path)
+
+      set_header
+      request.body = params[:payload]
+
+      handle_request
+    end
+
+    def put
+      @request = Net::HTTP::Put.new(uri.path)
+
+      set_header
+      request.body = params[:payload]
+
+      handle_request
+    end
+
+    def get
+      @request = Net::HTTP::Get.new(uri)
+
+      set_header
+
+      handle_request
+    end
+
+    def delete
+      @request = Net::HTTP::Delete.new(uri.path)
+
+      set_header
+      request.body = params[:payload]
+
+      handle_request
+    end
+
+    private
+
+    def handle_request
+      response = http.request(request)
+
+      case [response.code_type]
+      when [Net::HTTPOK], [Net::HTTPCreated], [Net::HTTPAccepted]
+        response
+      when [Net::HTTPUnauthorized]
+        raise RequestError.new(response, message: 'Unauthorized, please check your api key')
+      when [Net::HTTPNotFound]
+        raise RequestError.new(response, message: 'Requested Resource not found')
+      when [Net::HTTPRequestTimeOut]
+        raise RequestError.new(response, message: 'Server timeout, verify status of the server')
+      when [Net::HTTPInternalServerError]
+        raise RequestError.new(response, message: 'Server Error, please check with Hawkei')
+      else
+        raise RequestError, response
+      end
+    end
+
+    def set_header
+      params[:headers].each do |(type, value)|
+        formated_type = type.to_s.split(/_/).map(&:capitalize).join('-')
+        request[formated_type] = value
+      end
+    end
+
+    def setup_ssl
+      http.use_ssl     = true
+      http.ca_file     = params[:ca_file]
+      http.verify_mode = params[:verify_mode]
+    end
+
+    def uri
+      @uri ||= URI(params[:url])
+    end
+
+    def uri_proxy
+      @uri_proxy ||=
+        if params[:proxy]
+          URI(params[:proxy])
+        else
+          OpenStruct.new
+        end
+    end
+
+  end
+end

data/lib/hawkei/store.rb

@@ -0,0 +1,49 @@
+module Hawkei
+  ##
+  # == Hawkei \Store
+  #
+  # Store environment data
+  #
+  class Store
+    class << self
+
+      def store
+        Thread.current[:request_store] ||= {}
+      end
+
+      def clear!
+        Thread.current[:request_store] = {}
+      end
+
+      def load_from_hash(object = {})
+        clear!
+        bulk_set(Util.deep_symbolize_key(object)) if object.is_a?(Hash)
+      end
+
+      def get(key)
+        store[key]
+      end
+      alias [] get
+
+      def set(key, value)
+        store[key] = value
+      end
+      alias []= set
+
+      def bulk_set(attributes = {})
+        attributes.each do |(key, value)|
+          set(key, value)
+        end
+      end
+
+      def exist?(key)
+        store.key?(key)
+      end
+
+      def delete(key, &block)
+        store.delete(key, &block)
+      end
+
+    end
+  end
+end

data/lib/hawkei/util.rb

@@ -0,0 +1,180 @@
+module Hawkei
+  module Util
+    class << self
+
+      DATE_FORMAT = '%Y/%m/%d'.freeze
+      OBFUSCATED = '[HIDDEN]'.freeze
+      DEFAULT_OBJECT_DEF = %w[id name].freeze
+
+      ##
+      # Remove keys from a Hash
+      #
+      # @param [Hash] to be excepted
+      # @param [List[String]] to be excepted
+      #
+      # @return [Hash]
+      def except_keys(hash, *keys)
+        hash.dup.delete_if { |(key, _value)| keys.include?(key) }
+      end
+
+      ##
+      # Convert string to camelize
+      #
+      # @param [String]
+      #
+      # @example
+      #   camelize('my_model') => 'MyModel'
+      def camelize(string)
+        string.split('_').map(&:capitalize).join
+      end
+
+      ##
+      # Remove nil value from hash
+      #
+      # @return [Hash]
+      def compact(hash)
+        hash.reject { |_, value| value.nil? }
+      end
+
+      ##
+      # Remove nil value from hash recursively
+      #
+      # @return [Hash]
+      def deep_compact(object)
+        object.each_with_object({}) do |(key, value), result|
+          if value.is_a?(Hash)
+            value = deep_compact(value)
+            result[key] = value if !value.nil? && !value.empty?
+          else
+            result[key] = value unless value.nil?
+          end
+        end
+      end
+
+      ##
+      # Encodes a hash of parameters in a way that's suitable for use as query
+      # parameters in a URI or as form parameters in a request body. This mainly
+      # involves escaping special characters from parameter keys and values (e.g.
+      # `&`).
+      def encode_parameters(params = {})
+        params.map { |k, v| "#{url_encode(k)}=#{url_encode(v)}" }.join('&')
+      end
+
+      ##
+      # Encodes a string in a way that makes it suitable for use in a set of
+      # query parameters in a URI or in a set of form parameters in a request
+      # body.
+      def url_encode(key)
+        CGI.escape(key.to_s).gsub('%5B', '[').gsub('%5D', ']')
+      end
+
+      ##
+      # Convert string to underscore
+      #
+      # @param [String]
+      #
+      # @example
+      #   underscore('MyModel') => 'my_model'
+      def underscore(string)
+        string
+          .gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      end
+
+      ##
+      # Deep convert hash to underscore case keys
+      #
+      # @param [Hash] hash to transform
+      #
+      # @return [Hash] transformed
+      def deep_underscore_key(hash_object)
+        deep_transform_keys_in_object(hash_object) do |key|
+          begin
+            underscore(key).to_sym
+          rescue StandardError => _e
+            key
+          end
+        end
+      end
+
+      ##
+      # Deep convert hash to string keys
+      #
+      # @param [Hash] hash to transform
+      #
+      # @return [Hash] transformed
+      def deep_stringify_key(hash_object)
+        deep_transform_keys_in_object(hash_object) do |key|
+          begin
+            key.to_s
+          rescue StandardError => _e
+            key
+          end
+        end
+      end
+
+      ##
+      # Deep convert hash to symbol keys
+      #
+      # @param [Hash] hash to transform
+      #
+      # @return [Hash] transformed
+      def deep_symbolize_key(hash_object)
+        deep_transform_keys_in_object(hash_object) do |key|
+          begin
+            key.to_sym
+          rescue StandardError => _e
+            key
+          end
+        end
+      end
+
+      ##
+      # Deep remove key from hash
+      #
+      # @param [Hash] hash to obfuscate
+      #
+      # @return [Hash] hash obfuscated
+      def deep_obfuscate_value(object, fields, obfuscate_name = OBFUSCATED)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[key] = fields.include?(key.to_s) ? obfuscate_name : deep_obfuscate_value(value, fields)
+          end
+        when Array
+          object.map { |e| deep_obfuscate_value(e, fields) }
+        else
+          object
+        end
+      end
+
+      ##
+      # Parse JSON without raise
+      #
+      def safe_json_parse(data)
+        JSON.parse(data.to_s)
+      rescue JSON::ParserError
+        {}
+      end
+
+      private
+
+      def deep_transform_keys_in_object(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[yield(key)] = deep_transform_keys_in_object(value, &block)
+          end
+        when Array
+          object.map { |e| deep_transform_keys_in_object(e, &block) }
+        else
+          object
+        end
+      end
+
+    end
+  end
+end

data/lib/hawkei/version.rb

@@ -0,0 +1,3 @@
+module Hawkei # :nodoc:
+  VERSION = '1.0.0'.freeze
+end

data/lib/hawkei/watcher.rb

@@ -0,0 +1,15 @@
+module Hawkei
+  ##
+  # == Hawkei \Watcher
+  #
+  # Create and update groups
+  #
+  # @example: Usage
+  #
+  #   request = Hawkei::Watcher.create(template_flow: 'My Hawkei', expected_times: 42) #=> #<Hawkei::Response...>
+  #
+  class Watcher < APIResource
+    include Hawkei::APIOperation::Save
+    include Hawkei::APIOperation::Delete
+  end
+end

data/lib/hawkei.rb

@@ -0,0 +1,170 @@
+# Lib
+require 'securerandom'
+require 'net/http'
+require 'ostruct'
+require 'json'
+require 'time'
+require 'cgi'
+require 'logger'
+require 'concurrent'
+
+# Base
+require 'hawkei/version'
+require 'hawkei/formated_logger'
+require 'hawkei/library_name'
+require 'hawkei/util'
+require 'hawkei/config'
+require 'hawkei/errors'
+require 'hawkei/hawkei_object'
+require 'hawkei/request'
+require 'hawkei/api_resource'
+require 'hawkei/store'
+require 'hawkei/message'
+
+# Processor
+require 'hawkei/processor/async'
+require 'hawkei/processor/worker'
+require 'hawkei/processor/batch'
+
+# Operations
+require 'hawkei/api_operation/save'
+require 'hawkei/api_operation/delete'
+
+# Resources
+require 'hawkei/watcher'
+require 'hawkei/batch'
+
+# Plugins
+require 'hawkei/plugins'
+
+##
+# Implementation of the Hawkei
+module Hawkei
+  class << self
+
+    TRACK_EVENTS_CREATE = 'track_events:create'.freeze
+    IDENTIFY_EVENTS_CREATE = 'identify_events:create'.freeze
+    GROUP_EVENTS_CREATE = 'group_events:create'.freeze
+    WATCHERS_CREATE_ACTION = 'watchers:create'.freeze
+
+    ##
+    # @return [Hawkei::Config] configurations
+    attr_reader :configurations
+
+    ##
+    # Configures the Hawkei API
+    #
+    # @example Default configuration
+    #   Hawkei.configure do |config|
+    #      config.api_key = 'acc_xx'
+    #      config.space_name = 'Hawkei'
+    #      config.environment_name = 'production'
+    #   end
+    def configure
+      yield @configurations = Hawkei::Config.new
+
+      Hawkei.configurations.valid!
+    end
+
+    ##
+    # Send a track event to the server
+    #
+    # @param [String] event name
+    # @param [Hash] payload to be send
+    # @param [Hash] options for the request
+    #
+    # @return [Boolean] status of the request
+    def track(name, payload = {}, options = {})
+      return true unless configurations.enabled
+
+      payload[:name] = name
+      Hawkei::Plugins::Rails::Data.store_data if defined?(Hawkei::Plugins::Rails::Data)
+
+      payload = Message.extended.merge(payload)
+
+      processor.enqueue(
+        action: TRACK_EVENTS_CREATE,
+        payload: payload,
+        options: options.select { |k, _v| %i[space_name environment_name].include?(k) },
+      )
+    end
+
+    ##
+    # Send an identify event to the server
+    #
+    # @param [String] user id from your database
+    # @param [Hash] payload to be send
+    # @param [Hash] options for the request
+    #
+    # @return [Boolean] status of the request
+    def identify(user_id, payload = {}, options = {})
+      return true unless configurations.enabled
+
+      payload[:user_id] = user_id
+      Hawkei::Plugins::Rails::Data.store_data if defined?(Hawkei::Plugins::Rails::Data)
+
+      payload = Message.extended.merge(payload)
+
+      processor.enqueue(
+        action: IDENTIFY_EVENTS_CREATE,
+        payload: payload,
+        options: options.select { |k, _v| %i[space_name environment_name].include?(k) },
+      )
+    end
+
+    ##
+    # Send a create/update for a group
+    #
+    # @param [String] group id from your database
+    # @param [Hash] payload to be send
+    # @param [Hash] options for the request
+    #
+    # @return [Boolean] status of the request
+    def group(group_id, payload = {}, options = {})
+      return true unless configurations.enabled
+
+      payload = Message.base.merge(payload)
+      payload[:group_id] = group_id
+
+      processor.enqueue(
+        action: GROUP_EVENTS_CREATE,
+        payload: payload,
+        options: options.select { |k, _v| %i[space_name environment_name].include?(k) },
+      )
+    end
+
+    ##
+    # Send a create a watcher
+    #
+    # @param [String|Integer] template hawkei name or id
+    # @param [Hash] payload to be send
+    # @param [Hash] options for the request
+    #
+    # @return [Boolean|Watcher] status of the request
+    def watch(flow, payload = {}, options = {})
+      return true unless configurations.enabled
+
+      payload[:template_flow] = flow
+      payload = Message.base.merge(payload)
+
+      payload.delete(:session_tracker_id) if payload.delete(:without_session)
+
+      if options[:sync]
+        Watcher.create(payload, options)
+      else
+        processor.enqueue(
+          action: WATCHERS_CREATE_ACTION,
+          payload: payload,
+          options: options.select { |k, _v| %i[space_name environment_name].include?(k) },
+        )
+      end
+    end
+
+    private
+
+    def processor
+      @processor ||= Processor::Async.new
+    end
+
+  end
+end