launchdarkly-server-sdk 8.19.1 → 8.20.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (36) hide show
  1. checksums.yaml +4 -4
  2. data/lib/ldclient-rb/config.rb +11 -1
  3. data/lib/ldclient-rb/data_system/config_builder.rb +35 -1
  4. data/lib/ldclient-rb/data_system.rb +4 -4
  5. data/lib/ldclient-rb/evaluation_detail.rb +37 -4
  6. data/lib/ldclient-rb/events.rb +24 -16
  7. data/lib/ldclient-rb/impl/data_store/store.rb +80 -3
  8. data/lib/ldclient-rb/impl/data_system/fdv1.rb +5 -0
  9. data/lib/ldclient-rb/impl/data_system/fdv2.rb +84 -0
  10. data/lib/ldclient-rb/impl/data_system/polling.rb +18 -0
  11. data/lib/ldclient-rb/impl/data_system/protocolv2.rb +18 -0
  12. data/lib/ldclient-rb/impl/data_system/streaming.rb +16 -4
  13. data/lib/ldclient-rb/impl/data_system.rb +13 -0
  14. data/lib/ldclient-rb/impl/evaluator.rb +62 -18
  15. data/lib/ldclient-rb/impl/event_summarizer.rb +13 -2
  16. data/lib/ldclient-rb/impl/event_types.rb +11 -1
  17. data/lib/ldclient-rb/impl/file_data/document.rb +267 -0
  18. data/lib/ldclient-rb/impl/file_data/merge.rb +160 -0
  19. data/lib/ldclient-rb/impl/file_data/poller.rb +87 -0
  20. data/lib/ldclient-rb/impl/file_data/reloader.rb +578 -0
  21. data/lib/ldclient-rb/impl/file_data/watcher.rb +519 -0
  22. data/lib/ldclient-rb/impl/file_data.rb +7 -0
  23. data/lib/ldclient-rb/impl/integrations/file_override_source.rb +174 -0
  24. data/lib/ldclient-rb/impl/model/feature_flag.rb +34 -0
  25. data/lib/ldclient-rb/impl/model/segment.rb +34 -0
  26. data/lib/ldclient-rb/impl/overrides/layer.rb +133 -0
  27. data/lib/ldclient-rb/impl/overrides/overlay.rb +71 -0
  28. data/lib/ldclient-rb/impl/overrides/sink.rb +240 -0
  29. data/lib/ldclient-rb/impl/overrides.rb +5 -0
  30. data/lib/ldclient-rb/integrations/file_data.rb +181 -3
  31. data/lib/ldclient-rb/integrations/test_data/flag_builder.rb +1 -1
  32. data/lib/ldclient-rb/interfaces/overrides.rb +90 -0
  33. data/lib/ldclient-rb/interfaces.rb +1 -0
  34. data/lib/ldclient-rb/ldclient.rb +109 -28
  35. data/lib/ldclient-rb/version.rb +1 -1
  36. metadata +14 -2
@@ -25,6 +25,7 @@ module LaunchDarkly
25
25
  @key = data[:key]
26
26
  @version = data[:version]
27
27
  @deleted = !!data[:deleted]
28
+ @override = false
28
29
  return if @deleted
29
30
  migration_settings = data[:migration] || {}
30
31
  @migration_settings = MigrationSettings.new(migration_settings[:checkRatio])
@@ -96,6 +97,35 @@ module LaunchDarkly
96
97
  # @return [String]
97
98
  attr_reader :salt
98
99
 
100
+ #
101
+ # True if this definition came from the SDK's override store rather than from LaunchDarkly
102
+ # data. The marker is not part of the flag data and is never serialized. Only the SDK
103
+ # components that manage override entries set it, through {#as_override}. Evaluation reads
104
+ # it to mark the evaluations it affects. Every other reader treats a marked definition the
105
+ # same as any other.
106
+ #
107
+ # Flag overrides are currently experimental and subject to change.
108
+ #
109
+ # @return [Boolean]
110
+ #
111
+ def override?
112
+ @override
113
+ end
114
+
115
+ #
116
+ # Returns a shallow copy of this flag that carries the override marker. The copy shares its
117
+ # data with this flag. Nothing writes to that data. This flag is not changed.
118
+ #
119
+ # Flag overrides are currently experimental and subject to change.
120
+ #
121
+ # @return [FeatureFlag]
122
+ #
123
+ def as_override
124
+ copy = dup
125
+ copy.override = true
126
+ copy
127
+ end
128
+
99
129
  # This method allows us to read properties of the object as if it's just a hash. Currently this is
100
130
  # necessary because some data store logic is still written to expect hashes; we can remove it once
101
131
  # we migrate entirely to using attributes of the class.
@@ -115,6 +145,10 @@ module LaunchDarkly
115
145
  def to_json(*a)
116
146
  as_json.to_json(*a)
117
147
  end
148
+
149
+ protected
150
+
151
+ attr_writer :override
118
152
  end
119
153
 
120
154
  class Prerequisite
@@ -17,6 +17,7 @@ module LaunchDarkly
17
17
  @key = data[:key]
18
18
  @version = data[:version]
19
19
  @deleted = !!data[:deleted]
20
+ @override = false
20
21
  return if @deleted
21
22
  @included = data[:included] || []
22
23
  @excluded = data[:excluded] || []
@@ -67,6 +68,35 @@ module LaunchDarkly
67
68
  # @return [String]
68
69
  attr_reader :salt
69
70
 
71
+ #
72
+ # True if this definition came from the SDK's override store rather than from LaunchDarkly
73
+ # data. The marker is not part of the segment data and is never serialized. Only the SDK
74
+ # components that manage override entries set it, through {#as_override}. Evaluation reads
75
+ # it to mark the evaluations it affects. Every other reader treats a marked definition the
76
+ # same as any other.
77
+ #
78
+ # Flag overrides are currently experimental and subject to change.
79
+ #
80
+ # @return [Boolean]
81
+ #
82
+ def override?
83
+ @override
84
+ end
85
+
86
+ #
87
+ # Returns a shallow copy of this segment that carries the override marker. The copy shares
88
+ # its data with this segment. Nothing writes to that data. This segment is not changed.
89
+ #
90
+ # Flag overrides are currently experimental and subject to change.
91
+ #
92
+ # @return [Segment]
93
+ #
94
+ def as_override
95
+ copy = dup
96
+ copy.override = true
97
+ copy
98
+ end
99
+
70
100
  # This method allows us to read properties of the object as if it's just a hash. Currently this is
71
101
  # necessary because some data store logic is still written to expect hashes; we can remove it once
72
102
  # we migrate entirely to using attributes of the class.
@@ -86,6 +116,10 @@ module LaunchDarkly
86
116
  def to_json(*a)
87
117
  as_json.to_json(*a)
88
118
  end
119
+
120
+ protected
121
+
122
+ attr_writer :override
89
123
  end
90
124
 
91
125
  class SegmentTarget
@@ -0,0 +1,133 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "ldclient-rb/impl/data_store"
4
+ require "ldclient-rb/impl/dependency_tracker"
5
+
6
+ require "concurrent/atomics"
7
+
8
+ module LaunchDarkly
9
+ module Impl
10
+ #
11
+ # The flag and segment override layer. The layer is a runtime-mutable collection of flag and
12
+ # segment definitions, supplied by an override source. Those definitions take precedence over
13
+ # LaunchDarkly data at evaluation time.
14
+ #
15
+ # @private
16
+ #
17
+ module Overrides
18
+ #
19
+ # A thread-safe store of override entries, replaced as a whole on each update from an
20
+ # override source. Reads are lock-free: the contents are an immutable hash held in an
21
+ # atomic reference and swapped on update, so the layer holds exactly one snapshot at any
22
+ # instant.
23
+ #
24
+ # Each snapshot also carries the dependency graph of its entries. The store consults it so
25
+ # that a LaunchDarkly change to a prerequisite or a segment also notifies the override
26
+ # entries that depend on it.
27
+ #
28
+ class Layer
29
+ EMPTY_CONTENTS = {
30
+ DataStore::FEATURES => {}.freeze,
31
+ DataStore::SEGMENTS => {}.freeze,
32
+ }.freeze
33
+ private_constant :EMPTY_CONTENTS
34
+
35
+ # The layer contents keyed by data kind, with the dependency graph of those entries.
36
+ Snapshot = Struct.new(:contents, :dependencies)
37
+ private_constant :Snapshot
38
+
39
+ def initialize
40
+ @snapshot = Concurrent::AtomicReference.new(Snapshot.new(EMPTY_CONTENTS, DependencyTracker.new).freeze)
41
+ end
42
+
43
+ #
44
+ # Atomically replaces the entire layer contents. Empty hashes clear the layer.
45
+ #
46
+ # Each flag or segment is stored as a marked shallow copy. The copy shares its data with the
47
+ # caller's object, and the layer never writes to it. The caller's object is never marked.
48
+ #
49
+ # @param flags [Hash{Symbol => LaunchDarkly::Impl::Model::FeatureFlag}]
50
+ # @param segments [Hash{Symbol => LaunchDarkly::Impl::Model::Segment}]
51
+ # @return [Array(Hash, Hash)] the previous and the new contents, keyed by data kind. The
52
+ # returned hashes must not be modified.
53
+ #
54
+ def set_all(flags, segments)
55
+ replacement = {
56
+ DataStore::FEATURES => flags.transform_values(&:as_override).freeze,
57
+ DataStore::SEGMENTS => segments.transform_values(&:as_override).freeze,
58
+ }.freeze
59
+ dependencies = DependencyTracker.new
60
+ replacement.each do |kind, items|
61
+ items.each do |key, item|
62
+ # The graph keys items by string, the form in which the data model names
63
+ # prerequisites and segments.
64
+ dependencies.update_dependencies_from(kind, key.to_s, item)
65
+ rescue StandardError
66
+ # An entry whose dependency fields cannot be read contributes no edges. It is still
67
+ # served, and the remaining entries are still tracked.
68
+ end
69
+ end
70
+ previous = @snapshot.get_and_set(Snapshot.new(replacement, dependencies).freeze)
71
+ [previous.contents, replacement]
72
+ end
73
+
74
+ #
75
+ # Adds the given item and every override entry that directly or indirectly depends on it
76
+ # to the set. The item itself need not be an override entry: a LaunchDarkly flag or
77
+ # segment that an override entry references is a valid starting point. Items are
78
+ # `{ kind:, key: }` hashes. The key given may be a string or a symbol; the items added
79
+ # carry string keys.
80
+ #
81
+ # @param items_out [Set<Hash>]
82
+ # @param item [Hash] `{ kind:, key: }`
83
+ # @return [void]
84
+ #
85
+ def add_affected_items(items_out, item)
86
+ @snapshot.get.dependencies.add_affected_items(items_out, { kind: item[:kind], key: item[:key].to_s })
87
+ end
88
+
89
+ #
90
+ # Returns the override entry for a key, or nil.
91
+ #
92
+ # @param kind [LaunchDarkly::Impl::DataStore::DataKind]
93
+ # @param key [String, Symbol]
94
+ # @return [Object, nil]
95
+ #
96
+ def get(kind, key)
97
+ items = @snapshot.get.contents[kind]
98
+ return nil if items.nil?
99
+
100
+ items[key.to_sym]
101
+ end
102
+
103
+ #
104
+ # Returns the entries of the given kind. The returned hash must not be modified.
105
+ #
106
+ # @param kind [LaunchDarkly::Impl::DataStore::DataKind]
107
+ # @return [Hash{Symbol => Object}]
108
+ #
109
+ def all(kind)
110
+ @snapshot.get.contents[kind] || {}
111
+ end
112
+
113
+ #
114
+ # Returns the current contents, keyed by data kind. The returned hash must not be modified.
115
+ #
116
+ # @return [Hash]
117
+ #
118
+ def contents
119
+ @snapshot.get.contents
120
+ end
121
+
122
+ #
123
+ # Returns true if the layer contains no entries.
124
+ #
125
+ # @return [Boolean]
126
+ #
127
+ def empty?
128
+ @snapshot.get.contents.each_value.all?(&:empty?)
129
+ end
130
+ end
131
+ end
132
+ end
133
+ end
@@ -0,0 +1,71 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "ldclient-rb/impl/overrides/layer"
4
+ require "ldclient-rb/interfaces/data_system"
5
+
6
+ module LaunchDarkly
7
+ module Impl
8
+ module Overrides
9
+ #
10
+ # Merges an override {Layer} over a base store. A read for a key returns the override entry
11
+ # when one exists, and the base entry otherwise. The overlay sits at the store read boundary.
12
+ # That placement makes targeting rules, prerequisites, and segment matches behave identically
13
+ # for overridden and ordinary data. They are the same reads through the same boundary.
14
+ #
15
+ # @private
16
+ #
17
+ class Overlay
18
+ include LaunchDarkly::Interfaces::DataSystem::ReadOnlyStore
19
+
20
+ #
21
+ # @param base [#get, #all, #initialized?] the store that holds LaunchDarkly data
22
+ # @param layer [Layer]
23
+ #
24
+ def initialize(base, layer)
25
+ @base = base
26
+ @layer = layer
27
+ end
28
+
29
+ #
30
+ # Returns the override entry for the key if one exists, and otherwise delegates to the base
31
+ # store. This works even when the base store is uninitialized, because an uninitialized
32
+ # base reports not-found rather than failing.
33
+ #
34
+ # (see LaunchDarkly::Interfaces::DataSystem::ReadOnlyStore#get)
35
+ #
36
+ def get(kind, key)
37
+ item = @layer.get(kind, key)
38
+ return item unless item.nil?
39
+
40
+ @base.get(kind, key)
41
+ end
42
+
43
+ #
44
+ # Returns the union of the base store's items and the layer's items. The override entry
45
+ # wins for any key present in both. This includes keys the base holds only as deleted
46
+ # items. A failure of the base store is raised, as it is without the overlay: the layer's
47
+ # entries alone would be an incomplete result.
48
+ #
49
+ # (see LaunchDarkly::Interfaces::DataSystem::ReadOnlyStore#all)
50
+ #
51
+ def all(kind)
52
+ base_items = @base.all(kind)
53
+ overrides = @layer.all(kind)
54
+ return base_items if overrides.empty?
55
+
56
+ base_items.merge(overrides)
57
+ end
58
+
59
+ #
60
+ # Delegates to the base store: the override layer never affects initialization status or
61
+ # data availability.
62
+ #
63
+ # (see LaunchDarkly::Interfaces::DataSystem::ReadOnlyStore#initialized?)
64
+ #
65
+ def initialized?
66
+ @base.initialized?
67
+ end
68
+ end
69
+ end
70
+ end
71
+ end
@@ -0,0 +1,240 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "ldclient-rb/impl/data_store"
4
+ require "ldclient-rb/impl/dependency_tracker"
5
+ require "ldclient-rb/impl/model/serialization"
6
+ require "ldclient-rb/impl/overrides/layer"
7
+ require "ldclient-rb/interfaces/flag_tracker"
8
+ require "ldclient-rb/interfaces/overrides"
9
+
10
+ require "set"
11
+
12
+ module LaunchDarkly
13
+ module Impl
14
+ module Overrides
15
+ #
16
+ # Applies override layer replacements supplied by an override source, and notifies flag
17
+ # change listeners of the flags affected by each replacement.
18
+ #
19
+ # @private
20
+ #
21
+ class Sink
22
+ include LaunchDarkly::Interfaces::Overrides::OverrideSink
23
+
24
+ KINDS = [DataStore::FEATURES, DataStore::SEGMENTS].freeze
25
+ # The name of each kind in messages, as users know it.
26
+ KIND_NAMES = { DataStore::FEATURES => "flag", DataStore::SEGMENTS => "segment" }.freeze
27
+ private_constant :KINDS, :KIND_NAMES
28
+
29
+ #
30
+ # @param layer [Layer] the layer to write to
31
+ # @param base [#all] the store holding LaunchDarkly data, without the overlay. Merged-view
32
+ # snapshots for change computation are built from it plus the layer.
33
+ # @param flag_change_broadcaster [LaunchDarkly::Impl::Broadcaster]
34
+ # @param logger [Logger]
35
+ #
36
+ def initialize(layer, base, flag_change_broadcaster, logger)
37
+ @layer = layer
38
+ @base = base
39
+ @flag_change_broadcaster = flag_change_broadcaster
40
+ @logger = logger
41
+ @lock = Mutex.new
42
+ @closed = false
43
+ end
44
+
45
+ #
46
+ # Atomically replaces the entire override layer, then notifies listeners of every flag
47
+ # whose merged-view evaluation may have changed. Calls are serialized, so overlapping
48
+ # updates from a source cannot interleave.
49
+ #
50
+ # (see LaunchDarkly::Interfaces::Overrides::OverrideSink#set_overrides)
51
+ #
52
+ def set_overrides(flags, segments)
53
+ return log_ignored_snapshot if @closed
54
+
55
+ flag_items = index_items(DataStore::FEATURES, flags)
56
+ segment_items = index_items(DataStore::SEGMENTS, segments)
57
+
58
+ @lock.synchronize do
59
+ return log_ignored_snapshot if @closed
60
+
61
+ apply(flag_items, segment_items)
62
+ end
63
+ end
64
+
65
+ #
66
+ # Stops accepting snapshots. Used when the client closes: a snapshot that the source
67
+ # supplies while it stops is ignored. The layer keeps its contents.
68
+ #
69
+ # @return [void]
70
+ #
71
+ def close
72
+ @lock.synchronize do
73
+ @closed = true
74
+ end
75
+ end
76
+
77
+ #
78
+ # Stops accepting snapshots and clears the layer. Used when the source failed to start: a
79
+ # snapshot the source supplied before failing is removed, so the client runs without
80
+ # overrides, and a late snapshot from the stopped source is ignored.
81
+ #
82
+ # @return [void]
83
+ #
84
+ def close_and_clear
85
+ @lock.synchronize do
86
+ @closed = true
87
+ apply({}, {})
88
+ end
89
+ end
90
+
91
+ #
92
+ # Returns the keys of all flags whose merged-view evaluation may have changed when the
93
+ # override layer was replaced. The result includes the flags whose override entries were
94
+ # added, removed, or changed. Dependency fan-out adds every flag that depends, directly or
95
+ # transitively, on any added, removed, or changed entry of either kind.
96
+ #
97
+ # Dependency edges are computed over both the old and the new merged views, because a
98
+ # replacement can rewire dependencies. For example, removing a flag override restores the
99
+ # prerequisite edges of the LaunchDarkly definition.
100
+ #
101
+ # @param previous [Hash] layer contents before the replacement
102
+ # @param current [Hash] layer contents after the replacement
103
+ # @param old_merged [Hash] merged view before the replacement
104
+ # @param new_merged [Hash] merged view after the replacement
105
+ # @return [Array<String>]
106
+ #
107
+ def self.affected_flag_keys(previous, current, old_merged, new_merged)
108
+ seeds = changed_entries(previous, current)
109
+ return [] if seeds.empty?
110
+
111
+ old_tracker = tracker_for(old_merged)
112
+ new_tracker = tracker_for(new_merged)
113
+ affected = Set.new
114
+ seeds.each do |seed|
115
+ old_tracker.add_affected_items(affected, seed)
116
+ new_tracker.add_affected_items(affected, seed)
117
+ end
118
+
119
+ affected.select { |item| item[:kind] == DataStore::FEATURES }.map { |item| item[:key] }
120
+ end
121
+
122
+ #
123
+ # Returns an item reference for each key whose override entry differs between the two
124
+ # layer snapshots. An added or removed entry is always a change, even when its content
125
+ # matches the underlying LaunchDarkly data. The override marker alone changes the served
126
+ # entry. Entries present in both snapshots are compared by their data.
127
+ #
128
+ private_class_method def self.changed_entries(previous, current)
129
+ seeds = []
130
+ KINDS.each do |kind|
131
+ old_items = previous[kind] || {}
132
+ new_items = current[kind] || {}
133
+ old_items.each do |key, old_item|
134
+ new_item = new_items[key]
135
+ seeds << { kind: kind, key: key.to_s } if new_item.nil? || old_item != new_item || old_item.version != new_item.version
136
+ end
137
+ new_items.each_key do |key|
138
+ seeds << { kind: kind, key: key.to_s } unless old_items.key?(key)
139
+ end
140
+ end
141
+ seeds
142
+ end
143
+
144
+ #
145
+ # Builds a dependency tracker over a merged view. The tracker keys items by string, the
146
+ # same form in which the data model names prerequisites and segments.
147
+ #
148
+ private_class_method def self.tracker_for(view)
149
+ tracker = DependencyTracker.new
150
+ KINDS.each do |kind|
151
+ view[kind].each do |key, item|
152
+ tracker.update_dependencies_from(kind, key.to_s, item)
153
+ rescue StandardError
154
+ # An item whose dependency fields cannot be read contributes no edges, as in the
155
+ # layer's own graph, and the remaining items are still tracked.
156
+ end
157
+ end
158
+ tracker
159
+ end
160
+
161
+ #
162
+ # Replaces the layer and notifies listeners of the affected flags. Called inside @lock.
163
+ #
164
+ private def apply(flag_items, segment_items)
165
+ # Computing affected flags requires snapshots of the merged view before and after the
166
+ # replacement. Skip all of that work when nothing is listening.
167
+ unless @flag_change_broadcaster.has_listeners?
168
+ @layer.set_all(flag_items, segment_items)
169
+ return
170
+ end
171
+
172
+ previous, current = @layer.set_all(flag_items, segment_items)
173
+ old_merged = merged_view(previous)
174
+ new_merged = merged_view(current)
175
+
176
+ affected = Sink.affected_flag_keys(previous, current, old_merged, new_merged)
177
+ @logger.debug { "[LDClient] Override update affected #{affected.length} flag(s)" } unless affected.empty?
178
+ affected.each do |key|
179
+ @flag_change_broadcaster.broadcast(LaunchDarkly::Interfaces::FlagChange.new(key))
180
+ end
181
+ end
182
+
183
+ private def log_ignored_snapshot
184
+ @logger.debug { "[LDClient] Ignoring an override snapshot supplied after the override source was closed" }
185
+ end
186
+
187
+ #
188
+ # Converts the definitions passed to the sink into a hash keyed by symbol. A hash entry is
189
+ # deserialized into the data model. A model object is used as is. A snapshot with a deleted
190
+ # entry is rejected before the layer is replaced: an override defines a flag or segment, and
191
+ # a deleted one would shadow the LaunchDarkly item with one that cannot be evaluated.
192
+ #
193
+ private def index_items(kind, items)
194
+ name = KIND_NAMES[kind]
195
+ result = {}
196
+ (items || []).each do |item|
197
+ model = Model.deserialize(kind, item, @logger)
198
+ key = model.respond_to?(:key) ? model.key : nil
199
+ raise ArgumentError, "an override #{name} has no key" if key.nil? || key.to_s.empty?
200
+ reject_deleted(name, key) if model.respond_to?(:deleted) && model.deleted
201
+
202
+ result[key.to_sym] = model
203
+ end
204
+ result
205
+ end
206
+
207
+ #
208
+ # Rejects a snapshot that contains a deleted item. The rejection is logged as well as
209
+ # raised: a source that supplies a snapshot after it has started may not log the error it
210
+ # receives.
211
+ #
212
+ private def reject_deleted(name, key)
213
+ message = "override #{name} \"#{key}\" is marked as deleted; leave the #{name} out of the snapshot to remove its override"
214
+ @logger.error { "[LDClient] Rejected an override snapshot, keeping the overrides in effect: #{message}" }
215
+ raise ArgumentError, message
216
+ end
217
+
218
+ #
219
+ # Captures the merged view of the base store and a layer snapshot: base data with override
220
+ # entries overlaid. A base read failure for a kind yields just the overrides for that kind.
221
+ # This degrades the dependency fan-out but never loses the directly changed keys.
222
+ #
223
+ private def merged_view(layer_contents)
224
+ view = {}
225
+ KINDS.each do |kind|
226
+ items = {}
227
+ begin
228
+ @base.all(kind).each { |key, item| items[key.to_sym] = item }
229
+ rescue => e
230
+ @logger.warn { "[LDClient] Unable to read #{kind.namespace} for override change detection: #{e.message}" }
231
+ end
232
+ (layer_contents[kind] || {}).each { |key, item| items[key.to_sym] = item }
233
+ view[kind] = items
234
+ end
235
+ view
236
+ end
237
+ end
238
+ end
239
+ end
240
+ end
@@ -0,0 +1,5 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "ldclient-rb/impl/overrides/layer"
4
+ require "ldclient-rb/impl/overrides/overlay"
5
+ require "ldclient-rb/impl/overrides/sink"