securenative 0.1.24 → 0.1.30

data/lib/securenative/context.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module SecureNative
+  class Context
+    attr_reader :client_token, :ip, :remote_ip, :headers, :url, :http_method, :body
+    attr_writer :client_token, :ip, :remote_ip, :headers, :url, :http_method, :body
+
+    SECURENATIVE_COOKIE = '_sn'
+
+    def initialize(client_token: '', ip: '', remote_ip: '', headers: nil, url: '', http_method: '', body: '')
+      @client_token = client_token
+      @ip = ip
+      @remote_ip = remote_ip
+      @headers = headers
+      @url = url
+      @http_method = http_method
+      @body = body
+    end
+
+    def self.default_context_builder
+      SecureNative::Context.new
+    end
+
+    def self.from_http_request(request)
+      client_token = SecureNative::Frameworks::Rails.get_client_token(request)
+      client_token = SecureNative::Frameworks::Sinatra.get_client_token(request) if client_token.nil?
+      client_token = SecureNative::Frameworks::Hanami.get_client_token(request) if client_token.nil?
+
+      begin
+        headers = SecureNative::Frameworks::Rails.get_headers(request)
+        headers = SecureNative::Frameworks::Sinatra.get_headers(request) if headers.nil?
+        headers = SecureNative::Frameworks::Hanami.get_headers(request) if headers.nil?
+
+        # Standard Ruby request
+        headers = request.header.to_hash if headers.nil?
+      rescue StandardError
+        headers = []
+      end
+
+      url = SecureNative::Frameworks::Rails.get_url(request)
+      url = SecureNative::Frameworks::Sinatra.get_url(request) if url.nil?
+      url = SecureNative::Frameworks::Hanami.get_url(request) if url.nil?
+      url = '' if url.nil?
+
+      method = SecureNative::Frameworks::Rails.get_method(request)
+      method = SecureNative::Frameworks::Sinatra.get_method(request) if method.nil?
+      method = SecureNative::Frameworks::Hanami.get_method(request) if method.nil?
+      method = '' if method.nil?
+
+      begin
+        body = request.body.to_s
+      rescue StandardError
+        body = ''
+      end
+
+      if SecureNative::Utils::Utils.null_or_empty?(client_token)
+        client_token = SecureNative::Utils::RequestUtils.get_secure_header_from_request(headers)
+      end
+
+      SecureNative::Context.new(client_token: client_token, ip: SecureNative::Utils::RequestUtils.get_client_ip_from_request(request),
+                     remote_ip: SecureNative::Utils::RequestUtils.get_remote_ip_from_request(request),
+                     headers: headers, url: url, http_method: method || '', body: body)
+    end
+  end
+end

data/lib/securenative/enums/api_route.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module SecureNative
-  module ApiRoute
-    TRACK = 'track'
-    VERIFY = 'verify'
+  module Enums
+    module ApiRoute
+      TRACK = 'track'
+      VERIFY = 'verify'
+    end
   end
 end

data/lib/securenative/enums/risk_level.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
 module SecureNative
-  module RiskLevel
-    LOW = 'low'
-    MEDIUM = 'medium'
-    HIGH = 'high'
+  module Enums
+    module RiskLevel
+      LOW = 'low'
+      MEDIUM = 'medium'
+      HIGH = 'high'
+    end
   end
-end
+end

data/lib/securenative/errors/{securenative_parse_error.rb → parse_error.rb}

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
-module SecureNative
   class SecureNativeParseError < StandardError
   end
-end

data/lib/securenative/event_manager.rb

@@ -1,159 +1,156 @@
 # frozen_string_literal: true
 
-require 'securenative/utils/secure_native_logger'
-require 'securenative/config/securenative_options'
-require 'securenative/http/securenative_http_client'
-require 'securenative/errors/securenative_sdk_error'
-require 'securenative/errors/securenative_http_error'
-
-module SecureNative
-  class QueueItem
-    attr_reader :url, :body, :retry_sending
-    attr_writer :url, :body, :retry_sending
-
-    def initialize(url, body, retry_sending)
-      @url = url
-      @body = body
-      @retry = retry_sending
-    end
+class QueueItem
+  attr_reader :url, :body, :retry_sending
+  attr_writer :url, :body, :retry_sending
+
+  def initialize(url, body, retry_sending)
+    @url = url
+    @body = body
+    @retry = retry_sending
   end
+end
 
-  class EventManager
-    def initialize(options = SecureNativeOptions.new, http_client = nil)
-      if options.api_key.nil?
-        raise SecureNativeSDKError, 'API key cannot be None, please get your API key from SecureNative console.'
-      end
+class EventManager
+  attr_reader :activated
 
-      @http_client = if http_client.nil?
-                       SecureNativeHttpClient.new(options)
-                     else
-                       http_client
-                     end
-
-      @queue = []
-      @semaphore = Mutex.new
-      @interval = options.interval
-      @options = options
-      @send_enabled = false
-      @attempt = 0
-      @coefficients = [1, 1, 2, 3, 5, 8, 13]
-
-      @thread = Thread.new { run }
+  def initialize(options = Options.new, http_client = nil)
+    if options.api_key.nil?
+      raise SecureNativeSDKError, 'API key cannot be None, please get your API key from SecureNative console.'
     end
 
-    def send_async(event, resource_path)
-      if @options.disable
-        SecureNativeLogger.warning('SDK is disabled. no operation will be performed')
-        return
-      end
+    @http_client = if http_client.nil?
+                     SecureNative::HttpClient.new(options)
+                   else
+                     http_client
+                   end
+
+    @queue = []
+    @semaphore = Mutex.new
+    @options = options
+    @send_enabled = false
+    @attempt = 0
+    @coefficients = [1, 1, 2, 3, 5, 8, 13]
+    @thread = nil
+  end
 
-      item = QueueItem.new(resource_path, EventManager.serialize(event).to_json, false)
-      @queue.append(item)
+  def send_async(event, resource_path)
+    if @options.disable
+      SecureNative::Log.warning('SDK is disabled. no operation will be performed')
+      return
     end
 
-    def flush
-      @queue.each do |item|
-        @http_client.post(item.url, item.body)
-      end
-    end
+    start_event_persist unless @send_enabled
 
-    def send_sync(event, resource_path, retry_sending)
-      if @options.disable
-        SecureNativeLogger.warning('SDK is disabled. no operation will be performed')
-        return
-      end
+    item = QueueItem.new(resource_path, EventManager.serialize(event).to_json, false)
+    @queue.append(item)
+  end
+
+  def flush
+    @queue.each do |item|
+      @http_client.post(item.url, item.body)
+    end
+  end
 
-      SecureNativeLogger.debug("Attempting to send event #{event}")
-      res = @http_client.post(resource_path, EventManager.serialize(event).to_json)
+  def send_sync(event, resource_path)
+    if @options.disable
+      SecureNative::Log.warning('SDK is disabled. no operation will be performed')
+      return
+    end
 
-      if res.nil? || res.code != '200'
-        SecureNativeLogger.info("SecureNative failed to call endpoint #{resource_path} with event #{event}. adding back to queue")
-        item = QueueItem.new(resource_path, EventManager.serialize(event).to_json, retry_sending)
-        @queue.append(item)
-      end
+    SecureNative::Log.debug("Attempting to send event #{event}")
+    res = @http_client.post(resource_path, EventManager.serialize(event).to_json)
 
-      res
+    if res.nil? || res.code != '200'
+      SecureNative::Log.info("SecureNative failed to call endpoint #{resource_path} with event #{event}. adding back to queue")
     end
 
-    def run
-      loop do
-        @semaphore.synchronize do
-          next unless !@queue.empty? && @send_enabled
-
-          @queue.each do |item|
-            begin
-              res = @http_client.post(item.url, item.body)
-              if res.code == '401'
-                item.retry_sending = false
-              elsif res.code != '200'
-                raise SecureNativeHttpError, res.status_code
-              end
-              SecureNativeLogger.debug("Event successfully sent; #{item.body}")
-              return res
-            rescue StandardError => e
-              SecureNativeLogger.error("Failed to send event; #{e}")
-              if item.retry_sending
-                @attempt = 0 if @coefficients.length == @attempt + 1
-
-                back_off = @coefficients[@attempt] * @options.interval
-                SecureNativeLogger.debug("Automatic back-off of #{back_off}")
-                @send_enabled = false
-                sleep back_off
-                @send_enabled = true
-              end
+    res
+  end
+
+  def run
+    loop do
+      @semaphore.synchronize do
+        if (item = !@queue.empty? && @send_enabled)
+          begin
+            item = @queue.shift
+            res = @http_client.post(item.url, item.body)
+            if res.code == '401'
+              item.retry_sending = false
+            elsif res.code != '200'
+              @queue.append(item)
+              raise SecureNativeHttpError, res.status_code
+            end
+            SecureNative::Log.debug("Event successfully sent; #{item.body}")
+          rescue Exception => e
+            SecureNative::Log.error("Failed to send event; #{e}")
+            if item.retry_sending
+              @attempt = 0 if @coefficients.length == @attempt + 1
+
+              back_off = @coefficients[@attempt] * @options.interval
+              SecureNative::Log.debug("Automatic back-off of #{back_off}")
+              @send_enabled = false
+              sleep back_off
+              @send_enabled = true
             end
           end
         end
-        sleep @interval / 1000
       end
+      sleep @options.interval / 1000 if @queue.empty?
     end
+  end
 
-    def start_event_persist
-      SecureNativeLogger.debug('Starting automatic event persistence')
-      if @options.auto_send || @send_enabled
+  def start_event_persist
+    SecureNative::Log.debug('Starting automatic event persistence')
+    if @options.auto_send
+      begin
+        @thread = Thread.new { run }
         @send_enabled = true
-      else
-        SecureNativeLogger.debug('Automatic event persistence is disabled, you should persist events manually')
+      rescue StandardError => e
+        SecureNative::Log.error("Could not start event scheduler; #{e}")
+        @send_enabled = false
       end
+    else
+      SecureNative::Log.debug('Automatic event persistence is disabled, you should persist events manually')
     end
+  end
 
-    def stop_event_persist
-      if @send_enabled
-        SecureNativeLogger.debug('Attempting to stop automatic event persistence')
-        begin
-          flush
-          @thread&.stop?
-          SecureNativeLogger.debug('Stopped event persistence')
-        rescue StandardError => e
-          SecureNativeLogger.error("Could not stop event scheduler; #{e}")
-        end
+  def stop_event_persist
+    if @send_enabled
+      SecureNative::Log.debug('Attempting to stop automatic event persistence')
+      begin
+        flush
+        @thread&.stop?
+        SecureNative::Log.debug('Stopped event persistence')
+      rescue StandardError => e
+        SecureNative::Log.error("Could not stop event scheduler; #{e}")
       end
     end
+  end
 
-    def self.serialize(obj)
-      {
-          rid: obj.rid,
-          eventType: obj.event_type,
-          userId: obj.user_id,
-          userTraits: {
-              name: obj.user_traits.name,
-              email: obj.user_traits.email,
-              phone: obj.user_traits.phone,
-              createdAt: obj.user_traits.created_at
-          },
-          request: {
-              cid: obj.request.cid,
-              vid: obj.request.vid,
-              fp: obj.request.fp,
-              ip: obj.request.ip,
-              remoteIp: obj.request.remote_ip,
-              method: obj.request.http_method || '',
-              url: obj.request.url,
-              headers: obj.request.headers
-          },
-          timestamp: obj.timestamp,
-          properties: obj.properties
-      }
-    end
+  def self.serialize(obj)
+    {
+      rid: obj.rid,
+      eventType: obj.event_type,
+      userId: obj.user_id,
+      userTraits: {
+        name: obj.user_traits.name,
+        email: obj.user_traits.email,
+        phone: obj.user_traits.phone,
+        createdAt: obj.user_traits.created_at
+      },
+      request: {
+        cid: obj.request.cid,
+        vid: obj.request.vid,
+        fp: obj.request.fp,
+        ip: obj.request.ip,
+        remoteIp: obj.request.remote_ip,
+        method: obj.request.http_method || '',
+        url: obj.request.url,
+        headers: obj.request.headers
+      },
+      timestamp: obj.timestamp,
+      properties: obj.properties
+    }
   end
 end

data/lib/securenative/{models/event_options.rb → event_options.rb}

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require 'securenative/models/event_options'
-require 'securenative/models/user_traits'
-require 'securenative/errors/securenative_invalid_options_error'
-
 module SecureNative
   class EventOptions
     attr_reader :event, :user_id, :user_traits, :context, :properties, :timestamp
@@ -18,11 +14,11 @@ module SecureNative
 
       if user_traits.nil?
         if user_name && email && phone && created_at
-          user_traits = UserTraits(user_name, email, phone, created_at)
+          user_traits = SecureNative::UserTraits(user_name, email, phone, created_at)
         elsif user_name && email && phone
-          user_traits = UserTraits(user_name, email, phone)
+          user_traits = SecureNative::UserTraits(user_name, email, phone)
         elsif user_name && email
-          user_traits = UserTraits(user_name, email)
+          user_traits = SecureNative::UserTraits(user_name, email)
         else
           user_traits = UserTraits.new
         end

data/lib/securenative/frameworks/hanami.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SecureNative
+  module Frameworks
+    class Hanami
+      SECURENATIVE_COOKIE = '_sn'
+
+      def self.get_client_token(request)
+        begin
+          request.env[SECURENATIVE_COOKIE]
+        rescue StandardError
+          begin
+            request.cookies[SECURENATIVE_COOKIE]
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      def self.get_url(request)
+        begin
+          request.env['REQUEST_PATH']
+        rescue StandardError
+          nil
+        end
+      end
+
+      def self.get_method(request)
+        begin
+          request.request_method
+        rescue StandardError
+          nil
+        end
+      end
+
+      def self.get_headers(request)
+        begin
+          # Note: At the moment we're filtering out everything but user-agent since ruby's payload is way too big
+          { 'user-agent' => request.env['HTTP_USER_AGENT'] }
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end