securenative 0.1.22 → 0.1.23

data/out/production/securenative-ruby/config/securenative_options.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require 'enums/failover_strategy'
+
 class SecureNativeOptions
-  attr_reader :api_key, :api_url, :interval, :max_events, :timeout, :auto_send, :disable, :log_level, :fail_over_strategy
-  attr_writer :api_key, :api_url, :interval, :max_events, :timeout, :auto_send, :disable, :log_level, :fail_over_strategy
+  attr_reader :api_key, :api_url, :interval, :max_events, :timeout, :auto_send, :disable, :log_level, :fail_over_strategy, :proxy_headers
+  attr_writer :api_key, :api_url, :interval, :max_events, :timeout, :auto_send, :disable, :log_level, :fail_over_strategy, :proxy_headers
 
-  def initialize(api_key = nil, api_url = "https://api.securenative.com/collector/api/v1", interval = 1000,
-                 max_events = 1000, timeout = 1500, auto_send = true, disable = false, log_level = "FATAL",
-                 fail_over_strategy = FailOverStrategy::FAIL_OPEN)
+  def initialize(api_key: nil, api_url: "https://api.securenative.com/collector/api/v1", interval: 1000,
+                 max_events: 1000, timeout: 1500, auto_send: true, disable: false, log_level: "FATAL",
+                 fail_over_strategy: FailOverStrategy::FAIL_OPEN, proxy_headers: [])
     @api_key = api_key
     @api_url = api_url
     @interval = interval
@@ -16,5 +18,6 @@ class SecureNativeOptions
     @disable = disable
     @log_level = log_level
     @fail_over_strategy = fail_over_strategy
+    @proxy_headers = proxy_headers
   end
 end

data/out/production/securenative-ruby/context/hanami_context.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class HanamiContext
+  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

data/out/production/securenative-ruby/context/rails_context.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class RailsContext
+  SECURENATIVE_COOKIE = '_sn'
+
+  def self.get_client_token(request)
+    begin
+      request.cookies[SECURENATIVE_COOKIE]
+    rescue StandardError
+      nil
+    end
+  end
+
+  def self.get_url(request)
+    begin
+      # Rails >= 3.x
+      request.fullpath
+    rescue StandardError
+      begin
+        # Rails < 3.x & Sinatra
+        request.url if url.nil?
+      rescue StandardError
+        nil
+      end
+    end
+  end
+
+  def self.get_method(request)
+    begin
+      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

data/out/production/securenative-ruby/context/securenative_context.rb

@@ -1,10 +1,18 @@
 # frozen_string_literal: true
 
+require 'utils/request_utils'
+require 'utils/utils'
+require 'context/rails_context'
+require 'context/hanami_context'
+require 'context/sinatra_context'
+
 class SecureNativeContext
   attr_reader :client_token, :ip, :remote_ip, :headers, :url, :http_method, :body
   attr_writer :client_token, :ip, :remote_ip, :headers, :url, :http_method, :body
 
-  def initialize(client_token = nil, ip = nil, remote_ip = nil, headers = nil, url = nil, http_method = nil, body = nil)
+  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
@@ -19,22 +27,41 @@ class SecureNativeContext
   end
 
   def self.from_http_request(request)
+    client_token = RailsContext.get_client_token(request)
+    client_token = SinatraContext.get_client_token(request) if client_token.nil?
+    client_token = HanamiContext.get_client_token(request) if client_token.nil?
+
     begin
-      client_token = request.cookies[RequestUtils.SECURENATIVE_COOKIE]
+      headers = RailsContext.get_headers(request)
+      headers = SinatraContext.get_headers(request) if headers.nil?
+      headers = HanamiContext.get_headers(request) if headers.nil?
+
+      # Standard Ruby request
+      headers = request.header.to_hash if headers.nil?
     rescue StandardError
-      client_token = nil
+      headers = []
     end
 
+    url = RailsContext.get_url(request)
+    url = SinatraContext.get_url(request) if url.nil?
+    url = HanamiContext.get_url(request) if url.nil?
+    url = '' if url.nil?
+
+    method = RailsContext.get_method(request)
+    method = SinatraContext.get_method(request) if method.nil?
+    method = HanamiContext.get_method(request) if method.nil?
+    method = '' if method.nil?
+
     begin
-      headers = request.headers
+      body = request.body.to_s
     rescue StandardError
-      headers = nil
+      body = ''
     end
 
     client_token = RequestUtils.get_secure_header_from_request(headers) if Utils.null_or_empty?(client_token)
 
-    SecureNativeContext.new(url: request.url, method: request.http_method, header: headers, client_token: client_token,
-                            client_ip: RequestUtils.get_client_ip_from_request(request),
-                            remote_ip: RequestUtils.get_remote_ip_from_request(request), body: nil)
+    SecureNativeContext.new(client_token: client_token, ip: RequestUtils.get_client_ip_from_request(request),
+                            remote_ip: RequestUtils.get_remote_ip_from_request(request),
+                            headers: headers, url: url, http_method: method || '', body: body)
   end
 end

data/out/production/securenative-ruby/context/sinatra_context.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class SinatraContext
+  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_URI']
+    rescue StandardError
+      nil
+    end
+  end
+
+  def self.get_method(request)
+    begin
+      request.env['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

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

@@ -4,6 +4,7 @@ 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
@@ -36,7 +37,7 @@ class EventManager
     @attempt = 0
     @coefficients = [1, 1, 2, 3, 5, 8, 13]
 
-    @thread = Thread.new {run}
+    @thread = Thread.new { run }
   end
 
   def send_async(event, resource_path)
@@ -45,7 +46,7 @@ class EventManager
       return
     end
 
-    item = QueueItem(resource_path, JSON.parse(EventManager.serialize(event)), false)
+    item = QueueItem.new(resource_path, EventManager.serialize(event).to_json, false)
     @queue.append(item)
   end
 
@@ -62,11 +63,11 @@ class EventManager
     end
 
     SecureNativeLogger.debug("Attempting to send event #{event}")
-    res = @http_client.post(resource_path, JSON.parse(EventManager.serialize(event)))
+    res = @http_client.post(resource_path, EventManager.serialize(event).to_json)
 
-    if res.status_code != 200
-      SecureNativeLogger.info('SecureNative failed to call endpoint {} with event {}. adding back to queue'.format(resource_path, event))
-      item = QueueItem(resource_path, JSON.parse(EventManager.serialize(event)), retry_sending)
+    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
 
@@ -81,20 +82,20 @@ class EventManager
         @queue.each do |item|
           begin
             res = @http_client.post(item.url, item.body)
-            if res.status_code == 401
+            if res.code == '401'
               item.retry_sending = false
-            elsif res.status_code != 200
+            elsif res.code != '200'
               raise SecureNativeHttpError, res.status_code
             end
-            SecureNativeLogger.debug('Event successfully sent; {}'.format(item.body))
+            SecureNativeLogger.debug("Event successfully sent; #{item.body}")
             return res
           rescue StandardError => e
-            SecureNativeLogger.error('Failed to send event; {}'.format(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 {}'.format(back_off))
+              SecureNativeLogger.debug("Automatic back-off of #{back_off}")
               @send_enabled = false
               sleep back_off
               @send_enabled = true
@@ -120,10 +121,10 @@ class EventManager
       SecureNativeLogger.debug('Attempting to stop automatic event persistence')
       begin
         flush
-        @thread&.stop
+        @thread&.stop?
         SecureNativeLogger.debug('Stopped event persistence')
       rescue StandardError => e
-        SecureNativeLogger.error('Could not stop event scheduler; {}'.format(e))
+        SecureNativeLogger.error("Could not stop event scheduler; #{e}")
       end
     end
   end
@@ -145,7 +146,7 @@ class EventManager
         fp: obj.request.fp,
         ip: obj.request.ip,
         remoteIp: obj.request.remote_ip,
-        http_method: obj.request.http_method,
+        method: obj.request.http_method || '',
         url: obj.request.url,
         headers: obj.request.headers
       },

data/out/production/securenative-ruby/http/{http_response.rb → secure_native_http_response.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class HttpResponse
+class SecureNativeHttpResponse
   attr_reader :ok, :status_code, :body
   attr_writer :ok, :status_code, :body
 

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

@@ -1,18 +1,21 @@
 # frozen_string_literal: true
 
-require 'httpclient'
+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-python'
+  USER_AGENT_HEADER_VALUE = 'SecureNative-ruby'
   CONTENT_TYPE_HEADER = 'Content-Type'
   CONTENT_TYPE_HEADER_VALUE = 'application/json'
 
   def initialize(securenative_options)
     @options = securenative_options
-    @client = HTTPClient.new
   end
 
   def _headers
@@ -25,8 +28,23 @@ class SecureNativeHttpClient
   end
 
   def post(path, body)
-    url = "#{@options.api_url}/#{path}"
+    uri = URI.parse("#{@options.api_url}/#{path}")
     headers = _headers
-    @client.post(url, body, 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/event_options.rb

@@ -1,10 +1,32 @@
 # 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
 
-  def initialize(event, user_id = nil, user_traits = nil, context = nil, properties = nil, timestamp = nil)
+  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

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

@@ -4,7 +4,7 @@ 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, method = nil)
+  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
@@ -12,7 +12,7 @@ class RequestContext
     @remote_ip = remote_ip
     @headers = headers
     @url = url
-    @method = method
+    @method = http_method
   end
 end
 

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

@@ -1,14 +1,29 @@
 # 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
-                 ContextBuilder.default_context_builder
+                 SecureNativeContext.default_context_builder
                end
 
     client_token = EncryptionUtils.decrypt(@context.client_token, securenative_options.api_key)
@@ -17,10 +32,11 @@ class SDKEvent
     @event_type = event_options.event
     @user_id = event_options.user_id
     @user_traits = event_options.user_traits
-    @request = RequestContext(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, method = @context.http_method, url = @context.url,
-                              headers = @context.headers)
+    @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
@@ -28,6 +44,6 @@ class SDKEvent
 
   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}"
+    user_traits: #{@user_traits}, request: #{@request}, timestamp: #{@timestamp}, properties: #{@properties}"
   end
 end