optimizely-sdk 4.0.1 → 5.0.0.pre.beta

data/lib/optimizely/odp/odp_segment_api_manager.rb

@@ -0,0 +1,122 @@
+# 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 '../exceptions'
+
+module Optimizely
+  class OdpSegmentApiManager
+    # Interface that handles fetching audience segments.
+
+    def initialize(logger: nil, proxy_config: nil, timeout: nil)
+      @logger = logger || NoOpLogger.new
+      @proxy_config = proxy_config
+      @timeout = timeout || Optimizely::Helpers::Constants::ODP_GRAPHQL_API_CONFIG[:REQUEST_TIMEOUT]
+    end
+
+    # Fetch segments from the ODP GraphQL API.
+    #
+    # @param api_key - public api key
+    # @param api_host - domain url of the host
+    # @param user_key - vuid or fs_user_id (client device id or fullstack id)
+    # @param user_value - value of user_key
+    # @param segments_to_check - array of segments to check
+
+    def fetch_segments(api_key, api_host, user_key, user_value, segments_to_check)
+      url = "#{api_host}/v3/graphql"
+
+      headers = {'Content-Type' => 'application/json', 'x-api-key' => api_key.to_s}
+
+      payload = {
+        query: 'query($userId: String, $audiences: [String]) {' \
+               "customer(#{user_key}: $userId) " \
+               '{audiences(subset: $audiences) {edges {node {name state}}}}}',
+        variables: {
+          userId: user_value.to_s,
+          audiences: segments_to_check || []
+        }
+      }.to_json
+
+      begin
+        response = Helpers::HttpUtils.make_request(
+          url, :post, payload, headers, @timeout, @proxy_config
+        )
+      rescue SocketError, Timeout::Error, Net::ProtocolError, Errno::ECONNRESET => e
+        @logger.log(Logger::DEBUG, "GraphQL download failed: #{e}")
+        log_segments_failure('network error')
+        return nil
+      rescue Errno::EINVAL, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, HTTPUriError => e
+        log_segments_failure(e)
+        return nil
+      end
+
+      status = response.code.to_i
+      if status >= 400
+        log_segments_failure(status)
+        return nil
+      end
+
+      begin
+        response = JSON.parse(response.body)
+      rescue JSON::ParserError
+        log_segments_failure('JSON decode error')
+        return nil
+      end
+
+      if response.include?('errors')
+        error = response['errors'].first if response['errors'].is_a? Array
+        error_code = extract_component(error, 'extensions', 'code')
+        if error_code == 'INVALID_IDENTIFIER_EXCEPTION'
+          log_segments_failure('invalid identifier', Logger::WARN)
+        else
+          error_class = extract_component(error, 'extensions', 'classification') || 'decode error'
+          log_segments_failure(error_class)
+        end
+        return nil
+      end
+
+      audiences = extract_component(response, 'data', 'customer', 'audiences', 'edges')
+      unless audiences
+        log_segments_failure('decode error')
+        return nil
+      end
+
+      audiences.filter_map do |edge|
+        name = extract_component(edge, 'node', 'name')
+        state = extract_component(edge, 'node', 'state')
+        unless name && state
+          log_segments_failure('decode error')
+          return nil
+        end
+        state == 'qualified' ? name : nil
+      end
+    end
+
+    private
+
+    def log_segments_failure(message, level = Logger::ERROR)
+      @logger.log(level, format(Optimizely::Helpers::Constants::ODP_LOGS[:FETCH_SEGMENTS_FAILED], message))
+    end
+
+    def extract_component(hash, *components)
+      hash.dig(*components) if hash.is_a? Hash
+    rescue TypeError
+      nil
+    end
+  end
+end

data/lib/optimizely/odp/odp_segment_manager.rb

@@ -0,0 +1,97 @@
+# 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 'odp_segment_api_manager'
+
+module Optimizely
+  class OdpSegmentManager
+    # Schedules connections to ODP for audience segmentation and caches the results
+    attr_accessor :odp_config
+    attr_reader :segments_cache, :api_manager, :logger
+
+    def initialize(segments_cache, api_manager = nil, logger = nil, proxy_config = nil, timeout: nil)
+      @odp_config = nil
+      @logger = logger || NoOpLogger.new
+      @api_manager = api_manager || OdpSegmentApiManager.new(logger: @logger, proxy_config: proxy_config, timeout: timeout)
+      @segments_cache = segments_cache
+    end
+
+    # Returns qualified segments for the user from the cache or the ODP server if not in the cache.
+    #
+    # @param user_key - The key for identifying the id type.
+    # @param user_value - The id itself.
+    # @param options - An array of OptimizelySegmentOptions used to ignore and/or reset the cache.
+    #
+    # @return - Array of qualified segments.
+    def fetch_qualified_segments(user_key, user_value, options)
+      odp_api_key = @odp_config&.api_key
+      odp_api_host = @odp_config&.api_host
+      segments_to_check = @odp_config&.segments_to_check
+
+      if odp_api_key.nil? || odp_api_host.nil?
+        @logger.log(Logger::ERROR, format(Optimizely::Helpers::Constants::ODP_LOGS[:FETCH_SEGMENTS_FAILED], 'ODP is not enabled'))
+        return nil
+      end
+
+      unless segments_to_check&.size&.positive?
+        @logger.log(Logger::DEBUG, 'No segments are used in the project. Returning empty list')
+        return []
+      end
+
+      cache_key = make_cache_key(user_key, user_value)
+
+      ignore_cache = options.include?(OptimizelySegmentOption::IGNORE_CACHE)
+      reset_cache = options.include?(OptimizelySegmentOption::RESET_CACHE)
+
+      reset if reset_cache
+
+      unless ignore_cache || reset_cache
+        segments = @segments_cache.lookup(cache_key)
+        unless segments.nil?
+          @logger.log(Logger::DEBUG, 'ODP cache hit. Returning segments from cache.')
+          return segments
+        end
+        @logger.log(Logger::DEBUG, 'ODP cache miss.')
+      end
+
+      @logger.log(Logger::DEBUG, 'Making a call to ODP server.')
+
+      segments = @api_manager.fetch_segments(odp_api_key, odp_api_host, user_key, user_value, segments_to_check)
+      @segments_cache.save(cache_key, segments) unless segments.nil? || ignore_cache
+      segments
+    end
+
+    def reset
+      @segments_cache.reset
+      nil
+    end
+
+    private
+
+    def make_cache_key(user_key, user_value)
+      "#{user_key}-$-#{user_value}"
+    end
+  end
+
+  class OptimizelySegmentOption
+    # Options for the OdpSegmentManager
+    IGNORE_CACHE = :IGNORE_CACHE
+    RESET_CACHE = :RESET_CACHE
+  end
+end

data/lib/optimizely/optimizely_config.rb

@@ -201,7 +201,7 @@ module Optimizely
     def stringify_conditions(conditions, audiences_map)
       operand = 'OR'
       conditions_str = ''
-      length = conditions.length()
+      length = conditions.length
       return '' if length.zero?
       return "\"#{lookup_name_from_id(conditions[0], audiences_map)}\"" if length == 1 && !OPERATORS.include?(conditions[0])
 

data/lib/optimizely/optimizely_factory.rb

@@ -126,6 +126,7 @@ module Optimizely
     # @param user_profile_service - Optional UserProfileServiceInterface Provides methods to store and retreive user profiles.
     # @param config_manager - Optional ConfigManagerInterface Responds to 'config' method.
     # @param notification_center - Optional Instance of NotificationCenter.
+    # @param settings: Optional instance of OptimizelySdkSettings for sdk configuration.
     #
     # if @max_event_batch_size and @max_event_flush_interval are nil then default batchsize and flush_interval
     # will be used to setup batchEventProcessor.
@@ -138,7 +139,8 @@ module Optimizely
       skip_json_validation = false, # rubocop:disable Style/OptionalBooleanParameter
       user_profile_service = nil,
       config_manager = nil,
-      notification_center = nil
+      notification_center = nil,
+      settings = nil
     )
 
       error_handler ||= NoOpErrorHandler.new
@@ -174,7 +176,10 @@ module Optimizely
         sdk_key,
         config_manager,
         notification_center,
-        event_processor
+        event_processor,
+        [],
+        {},
+        settings
       )
     end
   end

data/lib/optimizely/optimizely_user_context.rb

@@ -26,7 +26,7 @@ module Optimizely
 
     OptimizelyDecisionContext = Struct.new(:flag_key, :rule_key)
     OptimizelyForcedDecision = Struct.new(:variation_key)
-    def initialize(optimizely_client, user_id, user_attributes)
+    def initialize(optimizely_client, user_id, user_attributes, identify: true)
       @attr_mutex = Mutex.new
       @forced_decision_mutex = Mutex.new
       @qualified_segment_mutex = Mutex.new
@@ -34,13 +34,15 @@ module Optimizely
       @user_id = user_id
       @user_attributes = user_attributes.nil? ? {} : user_attributes.clone
       @forced_decisions = {}
-      @qualified_segments = []
+      @qualified_segments = nil
+
+      @optimizely_client&.identify_user(user_id: user_id) if identify
     end
 
     def clone
-      user_context = OptimizelyUserContext.new(@optimizely_client, @user_id, user_attributes)
+      user_context = OptimizelyUserContext.new(@optimizely_client, @user_id, user_attributes, identify: false)
       @forced_decision_mutex.synchronize { user_context.instance_variable_set('@forced_decisions', @forced_decisions.dup) unless @forced_decisions.empty? }
-      @qualified_segment_mutex.synchronize { user_context.instance_variable_set('@qualified_segments', @qualified_segments.dup) unless @qualified_segments.empty? }
+      @qualified_segment_mutex.synchronize { user_context.instance_variable_set('@qualified_segments', @qualified_segments.dup) unless @qualified_segments.nil? }
       user_context
     end
 
@@ -194,11 +196,43 @@ module Optimizely
     # Checks if user is qualified for the provided segment.
     #
     # @param segment - A segment name
+    # @return true if qualified.
 
     def qualified_for?(segment)
-      return false if @qualified_segments.empty?
+      qualified = false
+      @qualified_segment_mutex.synchronize do
+        break if @qualified_segments.nil? || @qualified_segments.empty?
+
+        qualified = @qualified_segments.include?(segment)
+      end
+      qualified
+    end
+
+    # Fetch all qualified segments for the user context.
+    #
+    # The segments fetched will be saved in `@qualified_segments` and can be accessed any time.
+    #
+    # @param options - A set of options for fetching qualified segments (optional).
+    # @param block - An optional block to call after segments have been fetched.
+    #                If a block is provided, segments will be fetched on a separate thread.
+    #                Block will be called with a boolean indicating if the fetch succeeded.
+    # @return If no block is provided, a boolean indicating whether the fetch was successful.
+    #         Otherwise, returns a thread handle and the status boolean is passed to the block.
 
-      @qualified_segment_mutex.synchronize { @qualified_segments.include?(segment) }
+    def fetch_qualified_segments(options: [], &block)
+      fetch_segments = lambda do |opts, callback|
+        segments = @optimizely_client&.fetch_qualified_segments(user_id: @user_id, options: opts)
+        self.qualified_segments = segments
+        success = !segments.nil?
+        callback&.call(success)
+        success
+      end
+
+      if block_given?
+        Thread.new(options, block, &fetch_segments)
+      else
+        fetch_segments.call(options, nil)
+      end
     end
   end
 end

data/lib/optimizely/user_condition_evaluator.rb

@@ -331,7 +331,7 @@ module Optimizely
     end
 
     def qualified_evaluator(condition)
-      # Evaluate the given match condition for the given user qaulified segments.
+      # Evaluate the given match condition for the given user qualified segments.
       # Returns boolean true if condition value is in the user's qualified segments,
       #                 false if the condition value is not in the user's qualified segments,
       #                 nil if the condition value isn't a string.

data/lib/optimizely/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2019, Optimizely and contributors
+#    Copyright 2016-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.
@@ -17,5 +17,5 @@
 #
 module Optimizely
   CLIENT_ENGINE = 'ruby-sdk'
-  VERSION = '4.0.1'
+  VERSION = '5.0.0-beta'
 end

data/lib/optimizely.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 #
-#    Copyright 2016-2022, Optimizely and contributors
+#    Copyright 2016-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,7 +25,7 @@ require_relative 'optimizely/decide/optimizely_decision_message'
 require_relative 'optimizely/decision_service'
 require_relative 'optimizely/error_handler'
 require_relative 'optimizely/event_builder'
-require_relative 'optimizely/event/forwarding_event_processor'
+require_relative 'optimizely/event/batch_event_processor'
 require_relative 'optimizely/event/event_factory'
 require_relative 'optimizely/event/user_event_factory'
 require_relative 'optimizely/event_dispatcher'
@@ -36,8 +36,12 @@ require_relative 'optimizely/helpers/validator'
 require_relative 'optimizely/helpers/variable_type'
 require_relative 'optimizely/logger'
 require_relative 'optimizely/notification_center'
+require_relative 'optimizely/notification_center_registry'
 require_relative 'optimizely/optimizely_config'
 require_relative 'optimizely/optimizely_user_context'
+require_relative 'optimizely/odp/lru_cache'
+require_relative 'optimizely/odp/odp_manager'
+require_relative 'optimizely/helpers/sdk_settings'
 
 module Optimizely
   class Project
@@ -46,7 +50,7 @@ module Optimizely
     attr_reader :notification_center
     # @api no-doc
     attr_reader :config_manager, :decision_service, :error_handler, :event_dispatcher,
-                :event_processor, :logger, :stopped
+                :event_processor, :logger, :odp_manager, :stopped
 
     # Constructor for Projects.
     #
@@ -62,6 +66,9 @@ module Optimizely
     # @param config_manager - Optional Responds to 'config' method.
     # @param notification_center - Optional Instance of NotificationCenter.
     # @param event_processor - Optional Responds to process.
+    # @param default_decide_options: Optional default decision options.
+    # @param event_processor_options: Optional hash of options to be passed to the default batch event processor.
+    # @param settings: Optional instance of OptimizelySdkSettings for sdk configuration.
 
     def initialize( # rubocop:disable Metrics/ParameterLists
       datafile = nil,
@@ -74,13 +81,16 @@ module Optimizely
       config_manager = nil,
       notification_center = nil,
       event_processor = nil,
-      default_decide_options = []
+      default_decide_options = [],
+      event_processor_options = {},
+      settings = nil
     )
       @logger = logger || NoOpLogger.new
       @error_handler = error_handler || NoOpErrorHandler.new
       @event_dispatcher = event_dispatcher || EventDispatcher.new(logger: @logger, error_handler: @error_handler)
       @user_profile_service = user_profile_service
       @default_decide_options = []
+      @sdk_settings = settings
 
       if default_decide_options.is_a? Array
         @default_decide_options = default_decide_options.clone
@@ -89,6 +99,11 @@ module Optimizely
         @default_decide_options = []
       end
 
+      unless event_processor_options.is_a? Hash
+        @logger.log(Logger::DEBUG, 'Provided event processor options is not a hash.')
+        event_processor_options = {}
+      end
+
       begin
         validate_instantiation_options
       rescue InvalidInputError => e
@@ -98,7 +113,7 @@ module Optimizely
 
       @notification_center = notification_center.is_a?(Optimizely::NotificationCenter) ? notification_center : NotificationCenter.new(@logger, @error_handler)
 
-      @config_manager = if config_manager.respond_to?(:config)
+      @config_manager = if config_manager.respond_to?(:config) && config_manager.respond_to?(:sdk_key)
                           config_manager
                         elsif sdk_key
                           HTTPProjectConfigManager.new(
@@ -113,12 +128,20 @@ module Optimizely
                           StaticProjectConfigManager.new(datafile, @logger, @error_handler, skip_json_validation)
                         end
 
+      setup_odp!(@config_manager.sdk_key)
+
       @decision_service = DecisionService.new(@logger, @user_profile_service)
 
       @event_processor = if event_processor.respond_to?(:process)
                            event_processor
                          else
-                           ForwardingEventProcessor.new(@event_dispatcher, @logger, @notification_center)
+                           BatchEventProcessor.new(
+                             event_dispatcher: @event_dispatcher,
+                             logger: @logger,
+                             notification_center: @notification_center,
+                             batch_size: event_processor_options[:batch_size] || BatchEventProcessor::DEFAULT_BATCH_SIZE,
+                             flush_interval: event_processor_options[:flush_interval] || BatchEventProcessor::DEFAULT_BATCH_INTERVAL
+                           )
                          end
     end
 
@@ -507,7 +530,7 @@ module Optimizely
         return false
       end
 
-      user_context = create_user_context(user_id, attributes)
+      user_context = OptimizelyUserContext.new(self, user_id, attributes, identify: false)
       decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
 
       feature_enabled = false
@@ -747,7 +770,7 @@ module Optimizely
         return nil
       end
 
-      user_context = create_user_context(user_id, attributes)
+      user_context = OptimizelyUserContext.new(self, user_id, attributes, identify: false)
       decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
       variation = decision ? decision['variation'] : nil
       feature_enabled = variation ? variation['featureEnabled'] : false
@@ -816,6 +839,7 @@ module Optimizely
       @stopped = true
       @config_manager.stop! if @config_manager.respond_to?(:stop!)
       @event_processor.stop! if @event_processor.respond_to?(:stop!)
+      @odp_manager.stop!
     end
 
     def get_optimizely_config
@@ -869,6 +893,52 @@ module Optimizely
       end
     end
 
+    # Send an event to the ODP server.
+    #
+    # @param action - the event action name. Cannot be nil or empty string.
+    # @param identifiers - a hash for identifiers. The caller must provide at least one key-value pair.
+    # @param type - the event type (default = "fullstack").
+    # @param data - a hash for associated data. The default event data will be added to this data before sending to the ODP server.
+
+    def send_odp_event(action:, identifiers:, type: Helpers::Constants::ODP_MANAGER_CONFIG[:EVENT_TYPE], data: {})
+      unless identifiers.is_a?(Hash) && !identifiers.empty?
+        @logger.log(Logger::ERROR, 'ODP events must have at least one key-value pair in identifiers.')
+        return
+      end
+
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('send_odp_event').message)
+        return
+      end
+
+      if action.nil? || action.empty?
+        @logger.log(Logger::ERROR, Helpers::Constants::ODP_LOGS[:ODP_INVALID_ACTION])
+        return
+      end
+
+      type = Helpers::Constants::ODP_MANAGER_CONFIG[:EVENT_TYPE] if type.nil? || type.empty?
+
+      @odp_manager.send_event(type: type, action: action, identifiers: identifiers, data: data)
+    end
+
+    def identify_user(user_id:)
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('identify_user').message)
+        return
+      end
+
+      @odp_manager.identify_user(user_id: user_id)
+    end
+
+    def fetch_qualified_segments(user_id:, options: [])
+      unless is_valid
+        @logger.log(Logger::ERROR, InvalidProjectConfigError.new('fetch_qualified_segments').message)
+        return
+      end
+
+      @odp_manager.fetch_qualified_segments(user_id: user_id, options: options)
+    end
+
     private
 
     def get_variation_with_config(experiment_key, user_id, attributes, config)
@@ -888,7 +958,7 @@ module Optimizely
 
       return nil unless user_inputs_valid?(attributes)
 
-      user_context = create_user_context(user_id, attributes)
+      user_context = OptimizelyUserContext.new(self, user_id, attributes, identify: false)
       variation_id, = @decision_service.get_variation(config, experiment_id, user_context)
       variation = config.get_variation_from_id(experiment_key, variation_id) unless variation_id.nil?
       variation_key = variation['key'] if variation
@@ -955,7 +1025,7 @@ module Optimizely
         return nil
       end
 
-      user_context = create_user_context(user_id, attributes)
+      user_context = OptimizelyUserContext.new(self, user_id, attributes, identify: false)
       decision, = @decision_service.get_variation_for_feature(config, feature_flag, user_context)
       variation = decision ? decision['variation'] : nil
       feature_enabled = variation ? variation['featureEnabled'] : false
@@ -1126,5 +1196,67 @@ module Optimizely
     def project_config
       @config_manager.config
     end
+
+    def update_odp_config_on_datafile_update
+      # if datafile isn't ready, expects to be called again by the internal notification_center
+      return if @config_manager.respond_to?(:ready?) && !@config_manager.ready?
+
+      config = @config_manager&.config
+      return unless config
+
+      @odp_manager.update_odp_config(config.public_key_for_odp, config.host_for_odp, config.all_segments)
+    end
+
+    def setup_odp!(sdk_key)
+      unless @sdk_settings.is_a? Optimizely::Helpers::OptimizelySdkSettings
+        @logger.log(Logger::DEBUG, 'Provided sdk_settings is not an OptimizelySdkSettings instance.') unless @sdk_settings.nil?
+        @sdk_settings = Optimizely::Helpers::OptimizelySdkSettings.new
+      end
+
+      if !@sdk_settings.odp_segment_manager.nil? && !Helpers::Validator.segment_manager_valid?(@sdk_settings.odp_segment_manager)
+        @logger.log(Logger::ERROR, 'Invalid ODP segment manager, reverting to default.')
+        @sdk_settings.odp_segment_manager = nil
+      end
+
+      if !@sdk_settings.odp_event_manager.nil? && !Helpers::Validator.event_manager_valid?(@sdk_settings.odp_event_manager)
+        @logger.log(Logger::ERROR, 'Invalid ODP event manager, reverting to default.')
+        @sdk_settings.odp_event_manager = nil
+      end
+
+      if !@sdk_settings.odp_segments_cache.nil? && !Helpers::Validator.segments_cache_valid?(@sdk_settings.odp_segments_cache)
+        @logger.log(Logger::ERROR, 'Invalid ODP segments cache, reverting to default.')
+        @sdk_settings.odp_segments_cache = nil
+      end
+
+      # no need to instantiate a cache if a custom cache or segment manager is provided.
+      if !@sdk_settings.odp_disabled && @sdk_settings.odp_segment_manager.nil?
+        @sdk_settings.odp_segments_cache ||= LRUCache.new(
+          @sdk_settings.segments_cache_size,
+          @sdk_settings.segments_cache_timeout_in_secs
+        )
+      end
+
+      @odp_manager = OdpManager.new(
+        disable: @sdk_settings.odp_disabled,
+        segment_manager: @sdk_settings.odp_segment_manager,
+        event_manager: @sdk_settings.odp_event_manager,
+        segments_cache: @sdk_settings.odp_segments_cache,
+        fetch_segments_timeout: @sdk_settings.fetch_segments_timeout,
+        odp_event_timeout: @sdk_settings.odp_event_timeout,
+        odp_flush_interval: @sdk_settings.odp_flush_interval,
+        logger: @logger
+      )
+
+      return if @sdk_settings.odp_disabled
+
+      Optimizely::NotificationCenterRegistry
+        .get_notification_center(sdk_key, @logger)
+        &.add_notification_listener(
+          NotificationCenter::NOTIFICATION_TYPES[:OPTIMIZELY_CONFIG_UPDATE],
+          method(:update_odp_config_on_datafile_update)
+        )
+
+      update_odp_config_on_datafile_update
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: optimizely-sdk
 version: !ruby/object:Gem::Version
-  version: 4.0.1
+  version: 5.0.0.pre.beta
 platform: ruby
 authors:
 - Optimizely
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-13 00:00:00.000000000 Z
+date: 2023-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -169,10 +169,20 @@ files:
 - lib/optimizely/helpers/event_tag_utils.rb
 - lib/optimizely/helpers/group.rb
 - lib/optimizely/helpers/http_utils.rb
+- lib/optimizely/helpers/sdk_settings.rb
 - lib/optimizely/helpers/validator.rb
 - lib/optimizely/helpers/variable_type.rb
 - lib/optimizely/logger.rb
 - lib/optimizely/notification_center.rb
+- lib/optimizely/notification_center_registry.rb
+- lib/optimizely/odp/lru_cache.rb
+- lib/optimizely/odp/odp_config.rb
+- lib/optimizely/odp/odp_event.rb
+- lib/optimizely/odp/odp_event_api_manager.rb
+- lib/optimizely/odp/odp_event_manager.rb
+- lib/optimizely/odp/odp_manager.rb
+- lib/optimizely/odp/odp_segment_api_manager.rb
+- lib/optimizely/odp/odp_segment_manager.rb
 - lib/optimizely/optimizely_config.rb
 - lib/optimizely/optimizely_factory.rb
 - lib/optimizely/optimizely_user_context.rb
@@ -197,9 +207,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.7
 signing_key: