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/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, Feature, TargetGroup

Constant Summary collapse

VERSION = 
'2.3.0'

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.feature_cache ⇒ Object (readonly)

Returns the value of attribute feature_cache.



10
11
12
 
# File 'lib/determinator.rb', line 10

def feature_cache
  @feature_cache
end

.retrieval ⇒ Object (readonly)

Returns the value of attribute retrieval.



10
11
12
 
# File 'lib/determinator.rb', line 10

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



15
16
17
18
19
20
21
 
# File 'lib/determinator.rb', line 15

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.



61
62
63
 
# File 'lib/determinator.rb', line 61

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

.instance ⇒ Determinator::Control

Returns the currently configured Determinator::Control instance

Returns:



27
28
29
30
 
# File 'lib/determinator.rb', line 27

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

.invalidate_cache(name) ⇒ Object 



95
96
97
 
# File 'lib/determinator.rb', line 95

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

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



82
83
84
85
 
# File 'lib/determinator.rb', line 82

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



67
68
69
70
71
72
 
# File 'lib/determinator.rb', line 67

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



76
77
78
79
80
 
# File 'lib/determinator.rb', line 76

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



54
55
56
 
# File 'lib/determinator.rb', line 54

def on_determination(&block)
  @determination_callback = block
end

.on_error(&block) ⇒ Object

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



33
34
35
 
# File 'lib/determinator.rb', line 33

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.



39
40
41
 
# File 'lib/determinator.rb', line 39

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.



89
90
91
92
93
 
# File 'lib/determinator.rb', line 89

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

  @feature_cache.call(name) { yield }
end