optimizely-sdk 4.0.1 → 5.0.0.pre.beta

data/lib/optimizely/odp/odp_event.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2022, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'json'
+require_relative '../helpers/constants'
+
+module Optimizely
+  class OdpEvent
+    # Representation of an odp event which can be sent to the Optimizely odp platform.
+
+    KEY_FOR_USER_ID = Helpers::Constants::ODP_MANAGER_CONFIG[:KEY_FOR_USER_ID]
+
+    def initialize(type:, action:, identifiers:, data:)
+      @type = type
+      @action = action
+      @identifiers = convert_identifiers(identifiers)
+      @data = add_common_event_data(data)
+    end
+
+    def add_common_event_data(custom_data)
+      data = {
+        idempotence_id: SecureRandom.uuid,
+        data_source_type: 'sdk',
+        data_source: 'ruby-sdk',
+        data_source_version: VERSION
+      }
+      data.update(custom_data)
+      data
+    end
+
+    def convert_identifiers(identifiers)
+      # Convert incorrect case/separator of identifier key `fs_user_id`
+      # (ie. `fs-user-id`, `FS_USER_ID`).
+
+      identifiers.clone.each_key do |key|
+        break if key == KEY_FOR_USER_ID
+
+        if ['fs-user-id', KEY_FOR_USER_ID].include?(key.downcase)
+          identifiers[KEY_FOR_USER_ID] = identifiers.delete(key)
+          break
+        end
+      end
+
+      identifiers
+    end
+
+    def to_json(*_args)
+      {
+        type: @type,
+        action: @action,
+        identifiers: @identifiers,
+        data: @data
+      }.to_json
+    end
+
+    def ==(other)
+      to_json == other.to_json
+    end
+  end
+end

data/lib/optimizely/odp/odp_event_api_manager.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2022, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'json'
+
+module Optimizely
+  class OdpEventApiManager
+    # Interface that handles sending ODP events.
+
+    def initialize(logger: nil, proxy_config: nil, timeout: nil)
+      @logger = logger || NoOpLogger.new
+      @proxy_config = proxy_config
+      @timeout = timeout || Optimizely::Helpers::Constants::ODP_REST_API_CONFIG[:REQUEST_TIMEOUT]
+    end
+
+    # Send events to the ODP Events API.
+    #
+    # @param api_key - public api key
+    # @param api_host - domain url of the host
+    # @param events - array of events to send
+
+    def send_odp_events(api_key, api_host, events)
+      should_retry = false
+      url = "#{api_host}/v3/events"
+
+      headers = {'Content-Type' => 'application/json', 'x-api-key' => api_key.to_s}
+
+      begin
+        response = Helpers::HttpUtils.make_request(
+          url, :post, events.to_json, headers, @timeout, @proxy_config
+        )
+      rescue SocketError, Timeout::Error, Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::EFAULT, Errno::ENETUNREACH, Errno::ENETDOWN, Errno::ECONNREFUSED
+        log_failure('network error')
+        should_retry = true
+        return should_retry
+      rescue StandardError => e
+        log_failure(e)
+        return should_retry
+      end
+
+      status = response.code.to_i
+      if status >= 400
+        log_failure(!response.body.empty? ? response.body : "#{status}: #{response.message}")
+        should_retry = status >= 500
+      end
+      should_retry
+    end
+
+    private
+
+    def log_failure(message, level = Logger::ERROR)
+      @logger.log(level, format(Optimizely::Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], message))
+    end
+  end
+end

data/lib/optimizely/odp/odp_event_manager.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2019, 2022, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+require_relative 'odp_event_api_manager'
+require_relative '../helpers/constants'
+require_relative 'odp_event'
+
+module Optimizely
+  class OdpEventManager
+    # Events passed to the OdpEventManager are immediately added to an EventQueue.
+    # The OdpEventManager maintains a single consumer thread that pulls events off of
+    # the BlockingQueue and buffers them for either a configured batch size or for a
+    # maximum duration before the resulting OdpEvent is sent to Odp.
+
+    attr_reader :batch_size, :api_manager, :logger
+    attr_accessor :odp_config
+
+    def initialize(
+      api_manager: nil,
+      logger: NoOpLogger.new,
+      proxy_config: nil,
+      request_timeout: nil,
+      flush_interval: nil
+    )
+      @odp_config = nil
+      @api_host = nil
+      @api_key = nil
+
+      @mutex = Mutex.new
+      @event_queue = SizedQueue.new(Optimizely::Helpers::Constants::ODP_EVENT_MANAGER[:DEFAULT_QUEUE_CAPACITY])
+      @queue_capacity = Helpers::Constants::ODP_EVENT_MANAGER[:DEFAULT_QUEUE_CAPACITY]
+      # received signal should be sent after adding item to event_queue
+      @received = ConditionVariable.new
+      @logger = logger
+      @api_manager = api_manager || OdpEventApiManager.new(logger: @logger, proxy_config: proxy_config, timeout: request_timeout)
+      @flush_interval = flush_interval || Helpers::Constants::ODP_EVENT_MANAGER[:DEFAULT_FLUSH_INTERVAL_SECONDS]
+      @batch_size = @flush_interval&.zero? ? 1 : Helpers::Constants::ODP_EVENT_MANAGER[:DEFAULT_BATCH_SIZE]
+      @flush_deadline = 0
+      @retry_count = Helpers::Constants::ODP_EVENT_MANAGER[:DEFAULT_RETRY_COUNT]
+      # current_batch should only be accessed by processing thread
+      @current_batch = []
+      @thread = nil
+      @thread_exception = false
+    end
+
+    def start!(odp_config)
+      if running?
+        @logger.log(Logger::WARN, 'Service already started.')
+        return
+      end
+
+      @odp_config = odp_config
+      @api_host = odp_config.api_host
+      @api_key = odp_config.api_key
+
+      @thread = Thread.new { run }
+      @logger.log(Logger::INFO, 'Starting scheduler.')
+    end
+
+    def flush
+      begin
+        @event_queue.push(:FLUSH_SIGNAL, true)
+      rescue ThreadError
+        @logger.log(Logger::ERROR, 'Error flushing ODP event queue.')
+        return
+      end
+
+      @mutex.synchronize do
+        @received.signal
+      end
+    end
+
+    def update_config
+      begin
+        # Adds update config signal to event_queue.
+        @event_queue.push(:UPDATE_CONFIG, true)
+      rescue ThreadError
+        @logger.log(Logger::ERROR, 'Error updating ODP config for the event queue')
+      end
+
+      @mutex.synchronize do
+        @received.signal
+      end
+    end
+
+    def dispatch(event)
+      if @thread_exception
+        @logger.log(Logger::ERROR, format(Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], 'Queue is down'))
+        return
+      end
+
+      # if the processor has been explicitly stopped. Don't accept tasks
+      unless running?
+        @logger.log(Logger::WARN, 'ODP event queue is shutdown, not accepting events.')
+        return
+      end
+
+      begin
+        @logger.log(Logger::DEBUG, 'ODP event queue: adding event.')
+        @event_queue.push(event, true)
+      rescue => e
+        @logger.log(Logger::WARN, format(Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], e.message))
+        return
+      end
+
+      @mutex.synchronize do
+        @received.signal
+      end
+    end
+
+    def send_event(type:, action:, identifiers:, data:)
+      case @odp_config&.odp_state
+      when nil
+        @logger.log(Logger::DEBUG, 'ODP event queue: cannot send before config has been set.')
+        return
+      when OdpConfig::ODP_CONFIG_STATE[:UNDETERMINED]
+        @logger.log(Logger::DEBUG, 'ODP event queue: cannot send before the datafile has loaded.')
+        return
+      when OdpConfig::ODP_CONFIG_STATE[:NOT_INTEGRATED]
+        @logger.log(Logger::DEBUG, Helpers::Constants::ODP_LOGS[:ODP_NOT_INTEGRATED])
+        return
+      end
+
+      event = Optimizely::OdpEvent.new(type: type, action: action, identifiers: identifiers, data: data)
+      dispatch(event)
+    end
+
+    def stop!
+      return unless running?
+
+      begin
+        @event_queue.push(:SHUTDOWN_SIGNAL, true)
+      rescue ThreadError
+        @logger.log(Logger::ERROR, 'Error stopping ODP event queue.')
+        return
+      end
+
+      @event_queue.close
+
+      @mutex.synchronize do
+        @received.signal
+      end
+
+      @logger.log(Logger::INFO, 'Stopping ODP event queue.')
+
+      @thread.join
+
+      @logger.log(Logger::ERROR, format(Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], @current_batch.to_json)) unless @current_batch.empty?
+    end
+
+    def running?
+      !!@thread && !!@thread.status && !@event_queue.closed?
+    end
+
+    private
+
+    def run
+      loop do
+        @mutex.synchronize do
+          @received.wait(@mutex, queue_timeout) if @event_queue.empty?
+        end
+
+        begin
+          item = @event_queue.pop(true)
+        rescue ThreadError => e
+          raise unless e.message == 'queue empty'
+
+          item = nil
+        end
+
+        case item
+        when :SHUTDOWN_SIGNAL
+          @logger.log(Logger::DEBUG, 'ODP event queue: received shutdown signal.')
+          break
+
+        when :FLUSH_SIGNAL
+          @logger.log(Logger::DEBUG, 'ODP event queue: received flush signal.')
+          flush_batch!
+
+        when :UPDATE_CONFIG
+          @logger.log(Logger::DEBUG, 'ODP event queue: received update config signal.')
+          process_config_update
+
+        when Optimizely::OdpEvent
+          add_to_batch(item)
+
+        when nil && !@current_batch.empty?
+          @logger.log(Logger::DEBUG, 'ODP event queue: flushing on interval.')
+          flush_batch!
+        end
+      end
+    rescue SignalException
+      @thread_exception = true
+      @logger.log(Logger::ERROR, 'Interrupted while processing ODP events.')
+    rescue => e
+      @thread_exception = true
+      @logger.log(Logger::ERROR, "Uncaught exception processing ODP events. Error: #{e.message}")
+    ensure
+      @logger.log(Logger::INFO, 'Exiting ODP processing loop. Attempting to flush pending events.')
+      flush_batch!
+    end
+
+    def flush_batch!
+      if @current_batch.empty?
+        @logger.log(Logger::DEBUG, 'ODP event queue: nothing to flush.')
+        return
+      end
+
+      if @api_key.nil? || @api_host.nil?
+        @logger.log(Logger::DEBUG, Helpers::Constants::ODP_LOGS[:ODP_NOT_INTEGRATED])
+        @current_batch.clear
+        return
+      end
+
+      @logger.log(Logger::DEBUG, "ODP event queue: flushing batch size #{@current_batch.length}.")
+      should_retry = false
+
+      i = 0
+      while i < @retry_count
+        begin
+          should_retry = @api_manager.send_odp_events(@api_key, @api_host, @current_batch)
+        rescue StandardError => e
+          should_retry = false
+          @logger.log(Logger::ERROR, format(Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], "Error: #{e.message} #{@current_batch.to_json}"))
+        end
+        break unless should_retry
+
+        @logger.log(Logger::DEBUG, 'Error dispatching ODP events, scheduled to retry.') if i < @retry_count
+        i += 1
+      end
+
+      @logger.log(Logger::ERROR, format(Helpers::Constants::ODP_LOGS[:ODP_EVENT_FAILED], "Failed after #{i} retries: #{@current_batch.to_json}")) if should_retry
+
+      @current_batch.clear
+    end
+
+    def add_to_batch(event)
+      set_flush_deadline if @current_batch.empty?
+
+      @current_batch << event
+      return unless @current_batch.length >= @batch_size
+
+      @logger.log(Logger::DEBUG, 'ODP event queue: flushing on batch size.')
+      flush_batch!
+    end
+
+    def set_flush_deadline
+      # Sets time that next flush will occur.
+      @flush_deadline = Time.new + @flush_interval
+    end
+
+    def time_till_flush
+      # Returns seconds until next flush; no less than 0.
+      [0, @flush_deadline - Time.new].max
+    end
+
+    def queue_timeout
+      # Returns seconds until next flush or None if current batch is empty.
+      return nil if @current_batch.empty?
+
+      time_till_flush
+    end
+
+    def process_config_update
+      # Updates the configuration used to send events.
+      flush_batch! unless @current_batch.empty?
+
+      @api_key = @odp_config&.api_key
+      @api_host = @odp_config&.api_host
+    end
+  end
+end

data/lib/optimizely/odp/odp_manager.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2022, Optimizely and contributors
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+
+require 'optimizely/logger'
+require_relative '../helpers/constants'
+require_relative '../helpers/validator'
+require_relative '../exceptions'
+require_relative 'odp_config'
+require_relative 'lru_cache'
+require_relative 'odp_segment_manager'
+require_relative 'odp_event_manager'
+
+module Optimizely
+  class OdpManager
+    ODP_LOGS = Helpers::Constants::ODP_LOGS
+    ODP_MANAGER_CONFIG = Helpers::Constants::ODP_MANAGER_CONFIG
+    ODP_CONFIG_STATE = Helpers::Constants::ODP_CONFIG_STATE
+
+    # update_odp_config must be called to complete initialization
+    def initialize(
+      disable:,
+      segments_cache: nil,
+      segment_manager: nil,
+      event_manager: nil,
+      fetch_segments_timeout: nil,
+      odp_event_timeout: nil,
+      odp_flush_interval: nil,
+      logger: nil
+    )
+      @enabled = !disable
+      @segment_manager = segment_manager
+      @event_manager = event_manager
+      @logger = logger || NoOpLogger.new
+      @odp_config = OdpConfig.new
+
+      unless @enabled
+        @logger.log(Logger::INFO, ODP_LOGS[:ODP_NOT_ENABLED])
+        return
+      end
+
+      unless @segment_manager
+        segments_cache ||= LRUCache.new(
+          Helpers::Constants::ODP_SEGMENTS_CACHE_CONFIG[:DEFAULT_CAPACITY],
+          Helpers::Constants::ODP_SEGMENTS_CACHE_CONFIG[:DEFAULT_TIMEOUT_SECONDS]
+        )
+        @segment_manager = Optimizely::OdpSegmentManager.new(segments_cache, nil, @logger, timeout: fetch_segments_timeout)
+      end
+
+      @event_manager ||= Optimizely::OdpEventManager.new(logger: @logger, request_timeout: odp_event_timeout, flush_interval: odp_flush_interval)
+
+      @segment_manager.odp_config = @odp_config
+    end
+
+    def fetch_qualified_segments(user_id:, options:)
+      # Returns qualified segments for the user from the cache or the ODP server if not in the cache.
+      #
+      # @param user_id - The user id.
+      # @param options - An array of OptimizelySegmentOptions used to ignore and/or reset the cache.
+      #
+      # @return - Array of qualified segments or nil.
+      options ||= []
+      unless @enabled
+        @logger.log(Logger::ERROR, ODP_LOGS[:ODP_NOT_ENABLED])
+        return nil
+      end
+
+      if @odp_config.odp_state == ODP_CONFIG_STATE[:UNDETERMINED]
+        @logger.log(Logger::ERROR, 'Cannot fetch segments before the datafile has loaded.')
+        return nil
+      end
+
+      @segment_manager.fetch_qualified_segments(ODP_MANAGER_CONFIG[:KEY_FOR_USER_ID], user_id, options)
+    end
+
+    def identify_user(user_id:)
+      unless @enabled
+        @logger.log(Logger::DEBUG, 'ODP identify event is not dispatched (ODP disabled).')
+        return
+      end
+
+      case @odp_config.odp_state
+      when ODP_CONFIG_STATE[:UNDETERMINED]
+        @logger.log(Logger::DEBUG, 'ODP identify event is not dispatched (datafile not ready).')
+        return
+      when ODP_CONFIG_STATE[:NOT_INTEGRATED]
+        @logger.log(Logger::DEBUG, 'ODP identify event is not dispatched (ODP not integrated).')
+        return
+      end
+
+      @event_manager.send_event(
+        type: ODP_MANAGER_CONFIG[:EVENT_TYPE],
+        action: 'identified',
+        identifiers: {ODP_MANAGER_CONFIG[:KEY_FOR_USER_ID] => user_id},
+        data: {}
+      )
+    end
+
+    def send_event(type:, action:, identifiers:, data:)
+      # Send an event to the ODP server.
+      #
+      # @param type - the event type.
+      # @param action - the event action name.
+      # @param identifiers - a hash for identifiers.
+      # @param data - a hash for associated data. The default event data will be added to this data before sending to the ODP server.
+      unless @enabled
+        @logger.log(Logger::ERROR, ODP_LOGS[:ODP_NOT_ENABLED])
+        return
+      end
+
+      unless Helpers::Validator.odp_data_types_valid?(data)
+        @logger.log(Logger::ERROR, ODP_LOGS[:ODP_INVALID_DATA])
+        return
+      end
+
+      @event_manager.send_event(type: type, action: action, identifiers: identifiers, data: data)
+    end
+
+    def update_odp_config(api_key, api_host, segments_to_check)
+      # Update the odp config, reset the cache and send signal to the event processor to update its config.
+      # Start the event manager if odp is integrated.
+      return unless @enabled
+
+      config_changed = @odp_config.update(api_key, api_host, segments_to_check)
+      unless config_changed
+        @logger.log(Logger::DEBUG, 'Odp config was not changed.')
+        return
+      end
+
+      @segment_manager.reset
+
+      if @event_manager.running?
+        @event_manager.update_config
+      elsif @odp_config.odp_state == ODP_CONFIG_STATE[:INTEGRATED]
+        @event_manager.start!(@odp_config)
+      end
+    end
+
+    def stop!
+      return unless @enabled
+
+      @event_manager.stop!
+    end
+  end
+end