optimizely-sdk 4.0.1 → 5.0.0.pre.beta

data/lib/optimizely/config_manager/http_project_config_manager.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2019-2020, 2022, Optimizely and contributors
+#    Copyright 2019-2020, 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.
@@ -33,12 +33,12 @@ module Optimizely
   class HTTPProjectConfigManager < ProjectConfigManager
     # Config manager that polls for the datafile and updated ProjectConfig based on an update interval.
 
-    attr_reader :stopped
+    attr_reader :stopped, :sdk_key
 
     # Initialize config manager. One of sdk_key or url has to be set to be able to use.
     #
-    # sdk_key - Optional string uniquely identifying the datafile. It's required unless a URL is passed in.
-    # datafile: Optional JSON string representing the project.
+    # sdk_key - Optional string uniquely identifying the datafile. It's required unless a datafile with sdk_key is passed in.
+    # datafile - Optional JSON string representing the project. If nil, sdk_key is required.
     # polling_interval - Optional floating point number representing time interval in seconds
     #                  at which to request datafile and set ProjectConfig.
     # blocking_timeout - Optional Time in seconds to block the config call until config object has been initialized.
@@ -83,6 +83,10 @@ module Optimizely
       @notification_center = notification_center.is_a?(Optimizely::NotificationCenter) ? notification_center : NotificationCenter.new(@logger, @error_handler)
       @optimizely_config = nil
       @config = datafile.nil? ? nil : DatafileProjectConfig.create(datafile, @logger, @error_handler, @skip_json_validation)
+      @sdk_key = sdk_key || @config&.sdk_key
+
+      raise MissingSdkKeyError if @sdk_key.nil?
+
       @mutex = Mutex.new
       @resource = ConditionVariable.new
       @async_scheduler = AsyncScheduler.new(method(:fetch_datafile_config), @polling_interval, auto_update, @logger)
@@ -222,6 +226,10 @@ module Optimizely
 
       @notification_center.send_notifications(NotificationCenter::NOTIFICATION_TYPES[:OPTIMIZELY_CONFIG_UPDATE])
 
+      NotificationCenterRegistry
+        .get_notification_center(@sdk_key, @logger)
+        &.send_notifications(NotificationCenter::NOTIFICATION_TYPES[:OPTIMIZELY_CONFIG_UPDATE])
+
       @logger.log(Logger::DEBUG, 'Received new datafile and updated config. ' \
         "Old revision number: #{previous_revision}. New revision number: #{@config.revision}.")
     end

data/lib/optimizely/config_manager/project_config_manager.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2019, Optimizely and contributors
+#    Copyright 2019, 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.
@@ -20,5 +20,6 @@ module Optimizely
     # Interface for fetching ProjectConfig instance.
 
     def config; end
+    def sdk_key; end
   end
 end

data/lib/optimizely/config_manager/static_project_config_manager.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2019-2020, 2022, Optimizely and contributors
+#    Copyright 2019-2020, 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.
@@ -23,7 +23,7 @@ require_relative 'project_config_manager'
 module Optimizely
   class StaticProjectConfigManager < ProjectConfigManager
     # Implementation of ProjectConfigManager interface.
-    attr_reader :config
+    attr_reader :config, :sdk_key
 
     def initialize(datafile, logger, error_handler, skip_json_validation)
       # Looks up and sets datafile and config based on response body.
@@ -41,6 +41,7 @@ module Optimizely
         error_handler,
         skip_json_validation
       )
+      @sdk_key = @config&.sdk_key
       @optimizely_config = nil
     end
 

data/lib/optimizely/event_dispatcher.rb

@@ -17,6 +17,7 @@
 #
 require_relative 'exceptions'
 require_relative 'helpers/http_utils'
+require_relative 'helpers/constants'
 
 module Optimizely
   class NoOpEventDispatcher
@@ -26,9 +27,6 @@ module Optimizely
   end
 
   class EventDispatcher
-    # @api constants
-    REQUEST_TIMEOUT = 10
-
     def initialize(logger: nil, error_handler: nil, proxy_config: nil)
       @logger = logger || NoOpLogger.new
       @error_handler = error_handler || NoOpErrorHandler.new
@@ -40,7 +38,7 @@ module Optimizely
     # @param event - Event object
     def dispatch_event(event)
       response = Helpers::HttpUtils.make_request(
-        event.url, event.http_verb, event.params.to_json, event.headers, REQUEST_TIMEOUT, @proxy_config
+        event.url, event.http_verb, event.params.to_json, event.headers, Helpers::Constants::EVENT_DISPATCH_CONFIG[:REQUEST_TIMEOUT], @proxy_config
       )
 
       error_msg = "Event failed to dispatch with response code: #{response.code}"

data/lib/optimizely/exceptions.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2020, 2022, Optimizely and contributors
+#    Copyright 2016-2020, 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.
@@ -25,6 +25,20 @@ module Optimizely
     end
   end
 
+  class HTTPUriError < Error
+    # Raised when a provided URI is invalid.
+    def initialize(msg = 'Provided URI was invalid.')
+      super
+    end
+  end
+
+  class MissingSdkKeyError < Error
+    # Raised when a provided URI is invalid.
+    def initialize(msg = 'SDK key not provided/cannot be found in the datafile.')
+      super
+    end
+  end
+
   class InvalidAudienceError < Error
     # Raised when an invalid audience is provided
 

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

@@ -178,6 +178,61 @@ 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