securenative 0.1.17 → 0.1.23

data/out/production/securenative-ruby/enums/risk_level.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RiskLevel
+  LOW = 'low'
+  MEDIUM = 'medium'
+  HIGH = 'high'
+end

data/out/production/securenative-ruby/errors/securenative_config_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class SecureNativeConfigError < StandardError
+end

data/out/production/securenative-ruby/errors/securenative_http_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class SecureNativeHttpError < StandardError
+end

data/out/production/securenative-ruby/errors/securenative_invalid_options_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class SecureNativeInvalidOptionsError < StandardError
+end

data/out/production/securenative-ruby/errors/securenative_invalid_uri_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class SecureNativeInvalidUriError < StandardError
+end

data/out/production/securenative-ruby/errors/securenative_parse_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class SecureNativeParseError < StandardError
+end

data/out/production/securenative-ruby/errors/securenative_sdk_Illegal_state_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class SecureNativeSDKIllegalStateError < StandardError
+end

data/out/production/securenative-ruby/errors/securenative_sdk_error.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class SecureNativeSDKError < StandardError
+end

data/out/production/securenative-ruby/event_manager.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require 'utils/secure_native_logger'
+require 'config/securenative_options'
+require 'http/securenative_http_client'
+require 'errors/securenative_sdk_error'
+require 'errors/securenative_http_error'
+
+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
+
+    @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 }
+  end
+
+  def send_async(event, resource_path)
+    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
+
+  def send_sync(event, resource_path, retry_sending)
+    if @options.disable
+      SecureNativeLogger.warning('SDK is disabled. no operation will be performed')
+      return
+    end
+
+    SecureNativeLogger.debug("Attempting to send event #{event}")
+    res = @http_client.post(resource_path, EventManager.serialize(event).to_json)
+
+    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
+
+    res
+  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
+          end
+        end
+      end
+      sleep @interval / 1000
+    end
+  end
+
+  def start_event_persist
+    SecureNativeLogger.debug('Starting automatic event persistence')
+    if @options.auto_send || @send_enabled
+      @send_enabled = true
+    else
+      SecureNativeLogger.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
+    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
+end

data/out/production/securenative-ruby/http/secure_native_http_response.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class SecureNativeHttpResponse
+  attr_reader :ok, :status_code, :body
+  attr_writer :ok, :status_code, :body
+
+  def initialize(ok, status_code, body)
+    @ok = ok
+    @status_code = status_code
+    @body = body
+  end
+end

data/out/production/securenative-ruby/http/securenative_http_client.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'utils/version_utils'
+require 'utils/secure_native_logger'
+
+class SecureNativeHttpClient
+  AUTHORIZATION_HEADER = 'Authorization'
+  VERSION_HEADER = 'SN-Version'
+  USER_AGENT_HEADER = 'User-Agent'
+  USER_AGENT_HEADER_VALUE = 'SecureNative-ruby'
+  CONTENT_TYPE_HEADER = 'Content-Type'
+  CONTENT_TYPE_HEADER_VALUE = 'application/json'
+
+  def initialize(securenative_options)
+    @options = securenative_options
+  end
+
+  def _headers
+    {
+      CONTENT_TYPE_HEADER => CONTENT_TYPE_HEADER_VALUE,
+      USER_AGENT_HEADER => USER_AGENT_HEADER_VALUE,
+      VERSION_HEADER => VersionUtils.version,
+      AUTHORIZATION_HEADER => @options.api_key
+    }
+  end
+
+  def post(path, body)
+    uri = URI.parse("#{@options.api_url}/#{path}")
+    headers = _headers
+
+    client = Net::HTTP.new(uri.host, uri.port)
+    client.use_ssl = true
+    client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+    request = Net::HTTP::Post.new(uri.request_uri, headers)
+    request.body = body
+
+    res = nil
+    begin
+      res = client.request(request)
+    rescue StandardError => e
+      SecureNativeLogger.error("Failed to send request; #{e}")
+      return res
+    end
+    res
+  end
+end

data/out/production/securenative-ruby/models/client_token.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class ClientToken
+  attr_reader :cid, :vid, :fp
+  attr_writer :cid, :vid, :fp
+
+  def initialize(cid, vid, fp)
+    @cid = cid
+    @vid = vid
+    @fp = fp
+  end
+end

data/out/production/securenative-ruby/models/device.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Device
+  attr_reader :device_id
+  attr_writer :device_id
+
+  def initialize(device_id)
+    @device_id = device_id
+  end
+end

data/out/production/securenative-ruby/models/event_options.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'models/event_options'
+require 'models/user_traits'
+require 'errors/securenative_invalid_options_error'
+
+class EventOptions
+  attr_reader :event, :user_id, :user_traits, :context, :properties, :timestamp
+  attr_writer :event, :user_id, :user_traits, :context, :properties, :timestamp
+
+  MAX_PROPERTIES_SIZE = 10
+
+  def initialize(event: nil, user_id: nil, user_traits: nil, user_name: nil, email: nil, phone: nil, created_at: nil, context: nil, properties: nil, timestamp: nil)
+    if !properties.nil? && properties.length > MAX_PROPERTIES_SIZE
+      raise SecureNativeInvalidOptionsError, "You can have only up to #{MAX_PROPERTIES_SIZE} custom properties"
+    end
+
+    if user_traits.nil?
+      if user_name && email && phone && created_at
+        user_traits = UserTraits(user_name, email, phone, created_at)
+      elsif user_name && email && phone
+        user_traits = UserTraits(user_name, email, phone)
+      elsif user_name && email
+        user_traits = UserTraits(user_name, email)
+      else
+        user_traits = UserTraits.new
+      end
+    end
+
+    @event = event
+    @user_id = user_id
+    @user_traits = user_traits
+    @context = context
+    @properties = properties
+    @timestamp = timestamp
+  end
+end

data/out/production/securenative-ruby/models/request_context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class RequestContext
+  attr_reader :cid, :vid, :fp, :ip, :remote_ip, :headers, :url, :http_method
+  attr_writer :cid, :vid, :fp, :ip, :remote_ip, :headers, :url, :http_method
+
+  def initialize(cid: nil, vid: nil, fp: nil, ip: nil, remote_ip: nil, headers: nil, url: nil, http_method: nil)
+    @cid = cid
+    @vid = vid
+    @fp = fp
+    @ip = ip
+    @remote_ip = remote_ip
+    @headers = headers
+    @url = url
+    @method = http_method
+  end
+end
+

data/out/production/securenative-ruby/models/request_options.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class RequestOptions
+  attr_reader :url, :body, :retry_sending
+  attr_writer :url, :body, :retry_sending
+
+  def initialize(url, body, retry_sending)
+    @url = url
+    @body = body
+    @retry_sending = retry_sending
+  end
+end

data/out/production/securenative-ruby/models/sdk_event.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'context/securenative_context'
+require 'errors/securenative_invalid_options_error'
+require 'utils/encryption_utils'
+require 'utils/date_utils'
+require 'models/request_context'
+require 'securerandom'
+
+class SDKEvent
+  attr_reader :context, :rid, :event_type, :user_id, :user_traits, :request, :timestamp, :properties
+  attr_writer :context, :rid, :event_type, :user_id, :user_traits, :request, :timestamp, :properties
+
+  def initialize(event_options, securenative_options)
+    if event_options.user_id.nil? || event_options.user_id.length <= 0 || event_options.user_id == ''
+      raise SecureNativeInvalidOptionsError.new, 'Invalid event structure; User Id is missing'
+    end
+
+    if event_options.event.nil? || event_options.event.length <= 0 || event_options.event == ''
+      raise SecureNativeInvalidOptionsError.new, 'Invalid event structure; Event Type is missing'
+    end
+
+    @context = if !event_options.context.nil?
+                 event_options.context
+               else
+                 SecureNativeContext.default_context_builder
+               end
+
+    client_token = EncryptionUtils.decrypt(@context.client_token, securenative_options.api_key)
+
+    @rid = SecureRandom.uuid.to_str
+    @event_type = event_options.event
+    @user_id = event_options.user_id
+    @user_traits = event_options.user_traits
+    @request = RequestContext.new(cid: client_token ? client_token.cid : '', vid: client_token ? client_token.vid : '',
+                                  fp: client_token ? client_token.fp : '', ip: @context.ip,
+                                  remote_ip: @context.remote_ip, headers: @context.headers,
+                                  url: @context.url, http_method: @context.http_method)
+
+
+    @timestamp = DateUtils.to_timestamp(event_options.timestamp)
+    @properties = event_options.properties
+  end
+
+  def to_s
+    "context: #{@context}, rid: #{@rid}, event_type: #{@event_type}, user_id: #{@user_id},
+    user_traits: #{@user_traits}, request: #{@request}, timestamp: #{@timestamp}, properties: #{@properties}"
+  end
+end

data/out/production/securenative-ruby/models/user_traits.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class UserTraits
+  attr_reader :name, :email, :phone, :created_at
+  attr_writer :name, :email, :phone, :created_at
+
+  def initialize(name: nil, email: nil, phone: nil, created_at: nil)
+    @name = name
+    @email = email
+    @created_at = created_at
+    @phone = phone
+  end
+end

data/out/production/securenative-ruby/models/verify_result.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class VerifyResult
+  attr_reader :risk_level, :score, :triggers
+  attr_writer :risk_level, :score, :triggers
+
+  def initialize(risk_level: nil, score: nil, triggers: nil)
+    @risk_level = risk_level
+    @score = score
+    @triggers = triggers
+  end
+
+  def to_s
+    "risk_level: #{@risk_level}, score: #{@score}, triggers: #{@triggers}"
+  end
+end