launchdarkly-server-sdk 8.19.1-java → 8.20.0-java
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.
- checksums.yaml +4 -4
- data/lib/ldclient-rb/config.rb +11 -1
- data/lib/ldclient-rb/data_system/config_builder.rb +35 -1
- data/lib/ldclient-rb/data_system.rb +4 -4
- data/lib/ldclient-rb/evaluation_detail.rb +37 -4
- data/lib/ldclient-rb/events.rb +24 -16
- data/lib/ldclient-rb/impl/data_store/store.rb +80 -3
- data/lib/ldclient-rb/impl/data_system/fdv1.rb +5 -0
- data/lib/ldclient-rb/impl/data_system/fdv2.rb +84 -0
- data/lib/ldclient-rb/impl/data_system/polling.rb +18 -0
- data/lib/ldclient-rb/impl/data_system/protocolv2.rb +18 -0
- data/lib/ldclient-rb/impl/data_system/streaming.rb +16 -4
- data/lib/ldclient-rb/impl/data_system.rb +13 -0
- data/lib/ldclient-rb/impl/evaluator.rb +62 -18
- data/lib/ldclient-rb/impl/event_summarizer.rb +13 -2
- data/lib/ldclient-rb/impl/event_types.rb +11 -1
- data/lib/ldclient-rb/impl/file_data/document.rb +267 -0
- data/lib/ldclient-rb/impl/file_data/merge.rb +160 -0
- data/lib/ldclient-rb/impl/file_data/poller.rb +87 -0
- data/lib/ldclient-rb/impl/file_data/reloader.rb +578 -0
- data/lib/ldclient-rb/impl/file_data/watcher.rb +519 -0
- data/lib/ldclient-rb/impl/file_data.rb +7 -0
- data/lib/ldclient-rb/impl/integrations/file_override_source.rb +174 -0
- data/lib/ldclient-rb/impl/model/feature_flag.rb +34 -0
- data/lib/ldclient-rb/impl/model/segment.rb +34 -0
- data/lib/ldclient-rb/impl/overrides/layer.rb +133 -0
- data/lib/ldclient-rb/impl/overrides/overlay.rb +71 -0
- data/lib/ldclient-rb/impl/overrides/sink.rb +240 -0
- data/lib/ldclient-rb/impl/overrides.rb +5 -0
- data/lib/ldclient-rb/integrations/file_data.rb +181 -3
- data/lib/ldclient-rb/integrations/test_data/flag_builder.rb +1 -1
- data/lib/ldclient-rb/interfaces/overrides.rb +90 -0
- data/lib/ldclient-rb/interfaces.rb +1 -0
- data/lib/ldclient-rb/ldclient.rb +109 -28
- data/lib/ldclient-rb/version.rb +1 -1
- 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
|