optimizely-sdk 4.0.1 → 5.0.0

data/lib/optimizely/helpers/constants.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2020, Optimizely and contributors
+#    Copyright 2016-2020, 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.
@@ -382,6 +382,15 @@ module Optimizely
         'EVALUATING_AUDIENCES_COMBINED' => "Evaluating audiences for rule '%s': %s."
       }.merge(AUDIENCE_EVALUATION_LOGS).freeze
 
+      ODP_LOGS = {
+        FETCH_SEGMENTS_FAILED: 'Audience segments fetch failed (%s).',
+        ODP_EVENT_FAILED: 'ODP event send failed (%s).',
+        ODP_NOT_ENABLED: 'ODP is not enabled.',
+        ODP_NOT_INTEGRATED: 'ODP is not integrated.',
+        ODP_INVALID_DATA: 'ODP data is not valid.',
+        ODP_INVALID_ACTION: 'ODP action is not valid (cannot be empty).'
+      }.freeze
+
       DECISION_NOTIFICATION_TYPES = {
         'AB_TEST' => 'ab-test',
         'FEATURE' => 'feature',
@@ -406,6 +415,41 @@ module Optimizely
         'REQUEST_TIMEOUT' => 10
       }.freeze
 
+      EVENT_DISPATCH_CONFIG = {
+        REQUEST_TIMEOUT: 10
+      }.freeze
+
+      ODP_GRAPHQL_API_CONFIG = {
+        REQUEST_TIMEOUT: 10
+      }.freeze
+
+      ODP_REST_API_CONFIG = {
+        REQUEST_TIMEOUT: 10
+      }.freeze
+
+      ODP_SEGMENTS_CACHE_CONFIG = {
+        DEFAULT_CAPACITY: 10_000,
+        DEFAULT_TIMEOUT_SECONDS: 600
+      }.freeze
+
+      ODP_MANAGER_CONFIG = {
+        KEY_FOR_USER_ID: 'fs_user_id',
+        EVENT_TYPE: 'fullstack'
+      }.freeze
+
+      ODP_CONFIG_STATE = {
+        UNDETERMINED: 'UNDETERMINED',
+        INTEGRATED: 'INTEGRATED',
+        NOT_INTEGRATED: 'NOT_INTEGRATED'
+      }.freeze
+
+      ODP_EVENT_MANAGER = {
+        DEFAULT_QUEUE_CAPACITY: 10_000,
+        DEFAULT_BATCH_SIZE: 10,
+        DEFAULT_FLUSH_INTERVAL_SECONDS: 1,
+        DEFAULT_RETRY_COUNT: 3
+      }.freeze
+
       HTTP_HEADERS = {
         'IF_MODIFIED_SINCE' => 'If-Modified-Since',
         'LAST_MODIFIED' => 'Last-Modified'

data/lib/optimizely/helpers/http_utils.rb

@@ -17,6 +17,7 @@
 #
 
 require 'net/http'
+require_relative '../exceptions'
 
 module Optimizely
   module Helpers
@@ -28,6 +29,8 @@ module Optimizely
         #
         uri = URI.parse(url)
 
+        raise HTTPUriError unless uri.respond_to?(:request_uri)
+
         case http_method
         when :get
           request = Net::HTTP::Get.new(uri.request_uri)

data/lib/optimizely/helpers/sdk_settings.rb

@@ -0,0 +1,61 @@
+# 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_relative 'constants'
+
+module Optimizely
+  module Helpers
+    class OptimizelySdkSettings
+      attr_accessor :odp_disabled, :segments_cache_size, :segments_cache_timeout_in_secs, :odp_segments_cache, :odp_segment_manager,
+                    :odp_event_manager, :fetch_segments_timeout, :odp_event_timeout, :odp_flush_interval
+
+      # Contains configuration used for Optimizely Project initialization.
+      #
+      # @param disable_odp - Set this flag to true (default = false) to disable ODP features.
+      # @param segments_cache_size - The maximum size of audience segments cache (optional. default = 10,000). Set to zero to disable caching.
+      # @param segments_cache_timeout_in_secs - The timeout in seconds of audience segments cache (optional. default = 600). Set to zero to disable timeout.
+      # @param odp_segments_cache - A custom odp segments cache. Required methods include: `save(key, value)`, `lookup(key) -> value`, and `reset()`
+      # @param odp_segment_manager - A custom odp segment manager. Required method is: `fetch_qualified_segments(user_key, user_value, options)`.
+      # @param odp_event_manager - A custom odp event manager. Required method is: `send_event(type:, action:, identifiers:, data:)`
+      # @param odp_segment_request_timeout - Time to wait in seconds for fetch_qualified_segments (optional. default = 10).
+      # @param odp_event_request_timeout - Time to wait in seconds for send_odp_events (optional. default = 10).
+      # @param odp_event_flush_interval - Time to wait in seconds for odp events to accumulate before sending (optional. default = 1).
+      def initialize(
+        disable_odp: false,
+        segments_cache_size: Constants::ODP_SEGMENTS_CACHE_CONFIG[:DEFAULT_CAPACITY],
+        segments_cache_timeout_in_secs: Constants::ODP_SEGMENTS_CACHE_CONFIG[:DEFAULT_TIMEOUT_SECONDS],
+        odp_segments_cache: nil,
+        odp_segment_manager: nil,
+        odp_event_manager: nil,
+        odp_segment_request_timeout: nil,
+        odp_event_request_timeout: nil,
+        odp_event_flush_interval: nil
+      )
+        @odp_disabled = disable_odp
+        @segments_cache_size = segments_cache_size
+        @segments_cache_timeout_in_secs = segments_cache_timeout_in_secs
+        @odp_segments_cache = odp_segments_cache
+        @odp_segment_manager = odp_segment_manager
+        @odp_event_manager = odp_event_manager
+        @fetch_segments_timeout = odp_segment_request_timeout
+        @odp_event_timeout = odp_event_request_timeout
+        @odp_flush_interval = odp_event_flush_interval
+      end
+    end
+  end
+end

data/lib/optimizely/helpers/validator.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2019, 2022, Optimizely and contributors
+#    Copyright 2016-2019, 2022-2023, 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.
@@ -178,6 +178,59 @@ module Optimizely
 
         value.is_a?(Numeric) && value.to_f.finite? && value.abs <= Constants::FINITE_NUMBER_LIMIT
       end
+
+      def odp_data_types_valid?(data)
+        valid_types = [String, Float, Integer, TrueClass, FalseClass, NilClass]
+        data&.values&.all? { |e| valid_types.member? e.class }
+      end
+
+      def segments_cache_valid?(segments_cache)
+        # Determines if a given segments_cache is valid.
+        #
+        # segments_cache - custom cache to be validated.
+        #
+        # Returns boolean depending on whether cache has required methods.
+
+        segments_cache.respond_to?(:reset) &&
+          segments_cache.method(:reset)&.parameters&.empty? &&
+          segments_cache.respond_to?(:lookup) &&
+          segments_cache.method(:lookup)&.parameters&.length&.positive? &&
+          segments_cache.respond_to?(:save) &&
+          segments_cache.method(:save)&.parameters&.length&.positive?
+      end
+
+      def segment_manager_valid?(segment_manager)
+        # Determines if a given segment_manager is valid.
+        #
+        # segment_manager - custom manager to be validated.
+        #
+        # Returns boolean depending on whether manager has required methods.
+
+        segment_manager.respond_to?(:odp_config) &&
+          segment_manager.respond_to?(:reset) &&
+          segment_manager.method(:reset)&.parameters&.empty? &&
+          segment_manager.respond_to?(:fetch_qualified_segments) &&
+          (segment_manager.method(:fetch_qualified_segments)&.parameters&.length || 0) >= 3
+      end
+
+      def event_manager_valid?(event_manager)
+        # Determines if a given event_manager is valid.
+        #
+        # event_manager - custom manager to be validated.
+        #
+        # Returns boolean depending on whether manager has required method and parameters.
+        return false unless
+          event_manager.respond_to?(:send_event) &&
+          event_manager.respond_to?(:start!) &&
+          (event_manager.method(:start!)&.parameters&.length || 0) >= 1 &&
+          event_manager.respond_to?(:update_config) &&
+          event_manager.respond_to?(:stop!)
+
+        required_parameters = Set[%i[keyreq type], %i[keyreq action], %i[keyreq identifiers], %i[keyreq data]]
+        existing_parameters = event_manager.method(:send_event).parameters.to_set
+
+        existing_parameters & required_parameters == required_parameters
+      end
     end
   end
 end

data/lib/optimizely/notification_center_registry.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+#
+#    Copyright 2023, 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 'notification_center'
+require_relative 'exceptions'
+
+module Optimizely
+  class NotificationCenterRegistry
+    private_class_method :new
+    # Class managing internal notification centers.
+    # @api no-doc
+    @notification_centers = {}
+    @mutex = Mutex.new
+
+    # Returns an internal notification center for the given sdk_key, creating one
+    # if none exists yet.
+    #
+    # Args:
+    # sdk_key: A string sdk key to uniquely identify the notification center.
+    # logger: Optional logger.
+
+    # Returns:
+    # nil or NotificationCenter
+    def self.get_notification_center(sdk_key, logger)
+      unless sdk_key
+        logger&.log(Logger::ERROR, "#{MissingSdkKeyError.new.message} ODP may not work properly without it.")
+        return nil
+      end
+
+      notification_center = nil
+
+      @mutex.synchronize do
+        if @notification_centers.key?(sdk_key)
+          notification_center = @notification_centers[sdk_key]
+        else
+          notification_center = NotificationCenter.new(logger, nil)
+          @notification_centers[sdk_key] = notification_center
+        end
+      end
+
+      notification_center
+    end
+
+    # Remove a previously added notification center and clear all its listeners.
+
+    # Args:
+    # sdk_key: The sdk_key of the notification center to remove.
+    def self.remove_notification_center(sdk_key)
+      @mutex.synchronize do
+        @notification_centers
+          .delete(sdk_key)
+          &.clear_all_notification_listeners
+      end
+      nil
+    end
+  end
+end

data/lib/optimizely/odp/lru_cache.rb

@@ -0,0 +1,114 @@
+# 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.
+#
+
+module Optimizely
+  class LRUCache
+    # Least Recently Used cache that invalidates entries older than the timeout.
+
+    attr_reader :capacity, :timeout
+
+    def initialize(capacity, timeout_in_secs)
+      # @param capacity - The max size of the cache. If set <= 0, caching is disabled.
+      # @param timeout_in_secs - Seconds until a cache item is considered stale.
+      #                          If set <= 0, items never expire.
+      @cache_mutex = Mutex.new
+      @map = {}
+      @capacity = capacity
+      @timeout = timeout_in_secs
+    end
+
+    # Retrieve the non stale value from the cache corresponding to the provided key
+    # or nil if key is not found
+    # Moves the key/value pair to the end of the cache
+    #
+    # @param key - The key to retrieve
+
+    def lookup(key)
+      return nil if @capacity <= 0
+
+      @cache_mutex.synchronize do
+        return nil unless @map.include?(key)
+
+        element = @map.delete(key)
+        return nil if element.stale?(@timeout)
+
+        @map[key] = element
+
+        element.value
+      end
+    end
+
+    # Save a key/value pair into the cache
+    # Moves the key/value pair to the end of the cache
+    #
+    # @param key - A user key
+    # @param value - A user value
+
+    def save(key, value)
+      return if @capacity <= 0
+
+      @cache_mutex.synchronize do
+        @map.delete(key) if @map.key?(key)
+
+        @map[key] = CacheElement.new(value)
+
+        @map.delete(@map.first[0]) if @map.size > @capacity
+        nil
+      end
+    end
+
+    # Clears the cache
+
+    def reset
+      return if @capacity <= 0
+
+      @cache_mutex.synchronize { @map.clear }
+      nil
+    end
+
+    # Retrieve a value from the cache for a given key or nil if key is not found
+    # Doesn't update the cache
+    #
+    # @param key - The key to retrieve
+
+    def peek(key)
+      return nil if @capacity <= 0
+
+      @cache_mutex.synchronize { @map[key]&.value }
+    end
+  end
+
+  class CacheElement
+    # Individual element for the LRUCache.
+    attr_reader :value, :timestamp
+
+    def initialize(value)
+      @value = value
+      @timestamp = Time.new
+    end
+
+    def stale?(timeout)
+      # Returns true if the provided timeout has passed since the element's timestamp.
+      #
+      # @param timeout - The duration to check against
+      return false if timeout <= 0
+
+      Time.new - @timestamp >= timeout
+    end
+  end
+end

data/lib/optimizely/odp/odp_config.rb

@@ -0,0 +1,102 @@
+# 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'
+
+module Optimizely
+  class OdpConfig
+    ODP_CONFIG_STATE = Helpers::Constants::ODP_CONFIG_STATE
+    # Contains configuration used for ODP integration.
+    #
+    # @param api_host - The host URL for the ODP audience segments API (optional).
+    # @param api_key - The public API key for the ODP account from which the audience segments will be fetched (optional).
+    # @param segments_to_check - An array of all ODP segments used in the current datafile (associated with api_host/api_key).
+    def initialize(api_key = nil, api_host = nil, segments_to_check = [])
+      @api_key = api_key
+      @api_host = api_host
+      @segments_to_check = segments_to_check
+      @mutex = Mutex.new
+      @odp_state = @api_host.nil? || @api_key.nil? ? ODP_CONFIG_STATE[:UNDETERMINED] : ODP_CONFIG_STATE[:INTEGRATED]
+    end
+
+    # Replaces the existing configuration
+    #
+    # @param api_host - The host URL for the ODP audience segments API (optional).
+    # @param api_key - The public API key for the ODP account from which the audience segments will be fetched (optional).
+    # @param segments_to_check - An array of all ODP segments used in the current datafile (associated with api_host/api_key).
+    #
+    # @return - True if the provided values were different than the existing values.
+
+    def update(api_key = nil, api_host = nil, segments_to_check = [])
+      updated = false
+      @mutex.synchronize do
+        @odp_state = api_host.nil? || api_key.nil? ? ODP_CONFIG_STATE[:NOT_INTEGRATED] : ODP_CONFIG_STATE[:INTEGRATED]
+
+        if @api_key != api_key || @api_host != api_host || @segments_to_check != segments_to_check
+          @api_key = api_key
+          @api_host = api_host
+          @segments_to_check = segments_to_check
+          updated = true
+        end
+      end
+
+      updated
+    end
+
+    # Returns the api host for odp connections
+    #
+    # @return - The api host.
+
+    def api_host
+      @mutex.synchronize { @api_host.clone }
+    end
+
+    # Returns the api key for odp connections
+    #
+    # @return - The api key.
+
+    def api_key
+      @mutex.synchronize { @api_key.clone }
+    end
+
+    # Returns An array of qualified segments for this user
+    #
+    # @return - An array of segments names.
+
+    def segments_to_check
+      @mutex.synchronize { @segments_to_check.clone }
+    end
+
+    # Replace qualified segments with provided segments
+    #
+    # @param segments - An array of segment names
+
+    def segments_to_check=(segments_to_check)
+      @mutex.synchronize { @segments_to_check = segments_to_check.clone }
+    end
+
+    # Returns the state of odp integration (UNDETERMINED, INTEGRATED, NOT_INTEGRATED)
+    #
+    # @return - string
+
+    def odp_state
+      @mutex.synchronize { @odp_state }
+    end
+  end
+end

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