Class: Optimizely::OptimizelyFactory

Inherits:
Object
  • Object
show all
Defined in:
lib/optimizely/optimizely_factory.rb

Class Method Summary collapse

Class Method Details

.blocking_timeout(blocking_timeout) ⇒ Object

Convenience method for setting timeout to block the config call until config has been initialized.



84
85
86
 
# File 'lib/optimizely/optimizely_factory.rb', line 84

def self.blocking_timeout(blocking_timeout)
  @blocking_timeout = blocking_timeout
end

.cmab_cache_size(cache_size, logger = NoOpLogger.new) ⇒ Object

Convenience method for setting CMAB cache size.



91
92
93
94
95
96
97
98
99
100
 
# File 'lib/optimizely/optimizely_factory.rb', line 91

def self.cmab_cache_size(cache_size, logger = NoOpLogger.new)
  unless cache_size.is_a?(Integer) && cache_size.positive?
    logger.log(
      Logger::ERROR,
      "CMAB cache size is invalid, setting to default size #{Optimizely::DefaultCmabCacheOptions::DEFAULT_CMAB_CACHE_SIZE}."
    )
    return
  end
  @cmab_cache_size = cache_size
end

.cmab_cache_ttl(cache_ttl, logger = NoOpLogger.new) ⇒ Object

Convenience method for setting CMAB cache TTL.



105
106
107
108
109
110
111
112
113
114
 
# File 'lib/optimizely/optimizely_factory.rb', line 105

def self.cmab_cache_ttl(cache_ttl, logger = NoOpLogger.new)
  unless cache_ttl.is_a?(Numeric) && cache_ttl.positive?
    logger.log(
      Logger::ERROR,
      "CMAB cache TTL is invalid, setting to default TTL #{Optimizely::DefaultCmabCacheOptions::DEFAULT_CMAB_CACHE_TIMEOUT}."
    )
    return
  end
  @cmab_cache_ttl = cache_ttl
end

.cmab_custom_cache(custom_cache) ⇒ Object

Convenience method for setting custom CMAB cache.



118
119
120
 
# File 'lib/optimizely/optimizely_factory.rb', line 118

def self.cmab_custom_cache(custom_cache)
  @cmab_custom_cache = custom_cache
end

.cmab_prediction_endpoint(prediction_endpoint) ⇒ Object

Convenience method for setting custom CMAB prediction endpoint.



124
125
126
 
# File 'lib/optimizely/optimizely_factory.rb', line 124

def self.cmab_prediction_endpoint(prediction_endpoint)
  @cmab_prediction_endpoint = prediction_endpoint
end

.custom_instance(sdk_key, datafile = nil, event_dispatcher = nil, logger = nil, error_handler = nil, skip_json_validation = false, user_profile_service = nil, config_manager = nil, notification_center = nil, settings = nil) ⇒ Object

Returns a new optimizely instance.

if @max_event_batch_size and @max_event_flush_interval are nil then default batchsize and flush_interval will be used to setup batchEventProcessor.



175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
 
# File 'lib/optimizely/optimizely_factory.rb', line 175

def self.custom_instance( # rubocop:disable Metrics/ParameterLists
  sdk_key,
  datafile = nil,
  event_dispatcher = nil,
  logger = nil,
  error_handler = nil,
  skip_json_validation = false, # rubocop:disable Style/OptionalBooleanParameter
   = nil,
  config_manager = nil,
  notification_center = nil,
  settings = nil
)
  error_handler ||= NoOpErrorHandler.new
  logger ||= NoOpLogger.new
  notification_center = notification_center.is_a?(Optimizely::NotificationCenter) ? notification_center : NotificationCenter.new(logger, error_handler)

  event_processor = BatchEventProcessor.new(
    event_dispatcher: event_dispatcher || EventDispatcher.new,
    batch_size: @max_event_batch_size,
    flush_interval: @max_event_flush_interval,
    logger: logger,
    notification_center: notification_center
  )

  config_manager ||= Optimizely::HTTPProjectConfigManager.new(
    sdk_key: sdk_key,
    polling_interval: @polling_interval,
    blocking_timeout: @blocking_timeout,
    datafile: datafile,
    logger: logger,
    error_handler: error_handler,
    skip_json_validation: skip_json_validation,
    notification_center: notification_center
  )

  # Initialize CMAB components
  cmab_prediction_endpoint = nil
  cmab_prediction_endpoint = settings.cmab_prediction_endpoint if settings&.cmab_prediction_endpoint
  cmab_prediction_endpoint ||= @cmab_prediction_endpoint

  cmab_client = DefaultCmabClient.new(logger: logger, prediction_endpoint: cmab_prediction_endpoint)
  cmab_cache = @cmab_custom_cache || LRUCache.new(
    @cmab_cache_size || Optimizely::DefaultCmabCacheOptions::DEFAULT_CMAB_CACHE_SIZE,
    @cmab_cache_ttl || Optimizely::DefaultCmabCacheOptions::DEFAULT_CMAB_CACHE_TIMEOUT
  )
  cmab_service = DefaultCmabService.new(cmab_cache, cmab_client, logger)

  Optimizely::Project.new(
    datafile: datafile,
    event_dispatcher: event_dispatcher,
    logger: logger,
    error_handler: error_handler,
    skip_json_validation: skip_json_validation,
    user_profile_service: ,
    sdk_key: sdk_key,
    config_manager: config_manager,
    notification_center: notification_center,
    event_processor: event_processor,
    settings: settings,
    cmab_service: cmab_service
  )
end

.default_instance(sdk_key, datafile = nil) ⇒ Object

Returns a new optimizely instance.



132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/optimizely/optimizely_factory.rb', line 132

def self.default_instance(sdk_key, datafile = nil)
  error_handler = NoOpErrorHandler.new
  logger = NoOpLogger.new
  notification_center = NotificationCenter.new(logger, error_handler)

  config_manager = Optimizely::HTTPProjectConfigManager.new(
    sdk_key: sdk_key,
    polling_interval: @polling_interval,
    blocking_timeout: @blocking_timeout,
    datafile: datafile,
    logger: logger,
    error_handler: error_handler,
    notification_center: notification_center
  )

  Optimizely::Project.new(
    datafile: datafile, logger: logger, error_handler: error_handler, sdk_key: sdk_key, config_manager: config_manager, notification_center: notification_center
  )
end

.default_instance_with_config_manager(config_manager) ⇒ Object

Returns a new optimizely instance.



155
156
157
 
# File 'lib/optimizely/optimizely_factory.rb', line 155

def self.default_instance_with_config_manager(config_manager)
  Optimizely::Project.new(config_manager: config_manager)
end

.max_event_batch_size(batch_size, logger = NoOpLogger.new) ⇒ Object

Convenience method for setting the maximum number of events contained within a batch.



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/optimizely/optimizely_factory.rb', line 33

def self.max_event_batch_size(batch_size, logger = NoOpLogger.new)
  unless batch_size.is_a? Integer
    logger.log(
      Logger::ERROR,
      "Batch size is invalid, setting to default batch size #{BatchEventProcessor::DEFAULT_BATCH_SIZE}."
    )
    return
  end

  unless batch_size.positive?
    logger.log(
      Logger::ERROR,
      "Batch size is negative, setting to default batch size #{BatchEventProcessor::DEFAULT_BATCH_SIZE}."
    )
    return
  end
  @max_event_batch_size = batch_size
end

.max_event_flush_interval(flush_interval, logger = NoOpLogger.new) ⇒ Object

Convenience method for setting the maximum time interval in milliseconds between event dispatches.



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
# File 'lib/optimizely/optimizely_factory.rb', line 55

def self.max_event_flush_interval(flush_interval, logger = NoOpLogger.new)
  unless flush_interval.is_a? Numeric
    logger.log(
      Logger::ERROR,
      "Flush interval is invalid, setting to default flush interval #{BatchEventProcessor::DEFAULT_BATCH_INTERVAL}."
    )
    return
  end

  unless flush_interval.positive?
    logger.log(
      Logger::ERROR,
      "Flush interval is negative, setting to default flush interval #{BatchEventProcessor::DEFAULT_BATCH_INTERVAL}."
    )
    return
  end
  @max_event_flush_interval = flush_interval
end

.polling_interval(polling_interval) ⇒ Object

Convenience method for setting frequency at which datafile has to be polled and ProjectConfig updated.



77
78
79
 
# File 'lib/optimizely/optimizely_factory.rb', line 77

def self.polling_interval(polling_interval)
  @polling_interval = polling_interval
end