Module: Determinator

Defined in:
lib/determinator.rb,
lib/determinator/control.rb,
lib/determinator/feature.rb,
lib/determinator/version.rb,
lib/determinator/target_group.rb,
lib/determinator/actor_control.rb,
lib/determinator/retrieve/file.rb,
lib/determinator/error_response.rb,
lib/determinator/missing_response.rb,
lib/determinator/serializers/json.rb,
lib/determinator/retrieve/dynaconf.rb,
lib/determinator/cache/fetch_wrapper.rb,
lib/determinator/retrieve/http_retriever.rb,
lib/determinator/retrieve/null_retriever.rb,
lib/determinator/retrieve/in_memory_retriever.rb

Defined Under Namespace

Modules: Cache, Retrieve, Serializers Classes: ActorControl, Control, ErrorResponse, Feature, MissingResponse, TargetGroup

Constant Summary collapse

VERSION = 
'2.3.1'

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.feature_cache ⇒ Object (readonly)

Returns the value of attribute feature_cache.



13
14
15
 
# File 'lib/determinator.rb', line 13

def feature_cache
  @feature_cache
end

.retrieval ⇒ Object (readonly)

Returns the value of attribute retrieval.



13
14
15
 
# File 'lib/determinator.rb', line 13

def retrieval
  @retrieval
end

Class Method Details

.configure(retrieval:, errors: nil, missing_feature: nil, feature_cache: nil) ⇒ Object

Parameters:

  • :retrieval (Determinator::Retrieve::Routemaster) —

    A retrieval instance for Features

  • :errors (#call, nil) —

    a proc, accepting an error, which will be called with any errors which occur while determinating

  • :missing_feature (#call, nil) —

    a proc, accepting a feature name, which will be called any time a feature is requested but isn’t available

  • :feature_cache (#call, nil) —

    a caching proc, accepting a feature name, which will return the named feature or yield (and store) if not available



18
19
20
21
22
23
24
 
# File 'lib/determinator.rb', line 18

def configure(retrieval:, errors: nil, missing_feature: nil, feature_cache: nil)
  self.on_error(&errors) if errors
  self.on_missing_feature(&missing_feature) if missing_feature
  @feature_cache = feature_cache if feature_cache.respond_to?(:call)
  @retrieval = retrieval
  @instance = Control.new(retrieval: retrieval)
end

.feature_details(name) ⇒ Object

Returns the feature with the given name as Determinator uses it. This is useful for debugging issues with the retrieval mechanism which delivers features to Determinator.



64
65
66
 
# File 'lib/determinator.rb', line 64

def feature_details(name)
  with_retrieval_cache(name) { instance.retrieval.retrieve(name) }
end

.instance ⇒ Determinator::Control

Returns the currently configured Determinator::Control instance

Returns:



30
31
32
33
 
# File 'lib/determinator.rb', line 30

def instance
  raise "No singleton Determinator instance defined" unless @instance
  @instance
end

.invalidate_cache(name) ⇒ Object 



98
99
100
 
# File 'lib/determinator.rb', line 98

def invalidate_cache(name)
  @feature_cache.expire(name)
end

.notice_determination(id, guid, feature, determination) ⇒ Object 



85
86
87
88
 
# File 'lib/determinator.rb', line 85

def notice_determination(id, guid, feature, determination)
  return unless @determination_callback
  @determination_callback.call(id, guid, feature, determination)
end

.notice_error(error) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Allows Determinator to track that an error has happened with determination



70
71
72
73
74
75
 
# File 'lib/determinator.rb', line 70

def notice_error(error)
  return unless @error_logger

  error = RuntimeError.new(error) unless error.is_a?(StandardError)
  @error_logger.call(error)
end

.notice_missing_feature(name) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Allows Determinator to track that a feature was requested but was missing



79
80
81
82
83
 
# File 'lib/determinator.rb', line 79

def notice_missing_feature(name)
  return unless @missing_feature_logger

  @missing_feature_logger.call(name)
end

.on_determination {|id, guid, feature, determination| ... } ⇒ Object

Defines code that should execute when a determination is completed. This is particularly helpful for preparing or sending events to record that an actor has seen a particular experiment variant.

Please note that this block will be executed synchronously before delivering the determination to the callsite.

Yields:

  • (id, guid, feature, determination) —

    Will be called when a determination was requested for the specified feature, for the actor with id and guid, and received the determination determination.

Yield Parameters:

  • id (String, nil) —

    The ID that was used to request the determination

  • guid (String, nil) —

    The GUID that was used to request the determination

  • feature (Determinator::Feature) —

    The feature that was requested

  • determination (String, Boolean) —

    The result of the determination



57
58
59
 
# File 'lib/determinator.rb', line 57

def on_determination(&block)
  @determination_callback = block
end

.on_error(&block) ⇒ Object

Defines how errors that shouldn’t break your application should be logged



36
37
38
 
# File 'lib/determinator.rb', line 36

def on_error(&block)
  @error_logger = block
end

.on_missing_feature(&block) ⇒ Object

Defines how to record the moment when a feature which doesn’t exist is requested. If this happens a lot it indicates poor set up, so can be useful for tracking.



42
43
44
 
# File 'lib/determinator.rb', line 42

def on_missing_feature(&block)
  @missing_feature_logger = block
end

.with_retrieval_cache(name) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Allows access to the chosen caching mechanism for any retrieval plugin.



92
93
94
95
96
 
# File 'lib/determinator.rb', line 92

def with_retrieval_cache(name)
  return yield unless @feature_cache.respond_to?(:call)

  @feature_cache.call(name) { yield }
end