launchdarkly-server-sdk 6.3.0 → 8.0.0

data/lib/ldclient-rb/impl/data_store.rb

@@ -0,0 +1,59 @@
+require 'concurrent'
+require "ldclient-rb/interfaces"
+
+module LaunchDarkly
+  module Impl
+    module DataStore
+      class StatusProvider
+        include LaunchDarkly::Interfaces::DataStore::StatusProvider
+
+        def initialize(store, update_sink)
+          # @type [LaunchDarkly::Impl::FeatureStoreClientWrapper]
+          @store = store
+          # @type [UpdateSink]
+          @update_sink = update_sink
+        end
+
+        def status
+          @update_sink.last_status.get
+        end
+
+        def monitoring_enabled?
+          @store.monitoring_enabled?
+        end
+
+        def add_listener(listener)
+          @update_sink.broadcaster.add_listener(listener)
+        end
+
+        def remove_listener(listener)
+          @update_sink.broadcaster.remove_listener(listener)
+        end
+      end
+
+      class UpdateSink
+        include LaunchDarkly::Interfaces::DataStore::UpdateSink
+
+        # @return [LaunchDarkly::Impl::Broadcaster]
+        attr_reader :broadcaster
+
+        # @return [Concurrent::AtomicReference]
+        attr_reader :last_status
+
+        def initialize(broadcaster)
+          @broadcaster = broadcaster
+          @last_status = Concurrent::AtomicReference.new(
+            LaunchDarkly::Interfaces::DataStore::Status.new(true, false)
+          )
+        end
+
+        def update_status(status)
+          return if status.nil?
+
+          old_status = @last_status.get_and_set(status)
+          @broadcaster.broadcast(status) unless old_status == status
+        end
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/dependency_tracker.rb

@@ -0,0 +1,102 @@
+module LaunchDarkly
+  module Impl
+    class DependencyTracker
+      def initialize
+        @from = {}
+        @to = {}
+      end
+
+      #
+      # Updates the dependency graph when an item has changed.
+      #
+      # @param from_kind [Object] the changed item's kind
+      # @param from_key [String] the changed item's key
+      # @param from_item [Object] the changed item
+      #
+      def update_dependencies_from(from_kind, from_key, from_item)
+        from_what = { kind: from_kind, key: from_key }
+        updated_dependencies = DependencyTracker.compute_dependencies_from(from_kind, from_item)
+
+        old_dependency_set = @from[from_what]
+        unless old_dependency_set.nil?
+          old_dependency_set.each do |kind_and_key|
+            deps_to_this_old_dep = @to[kind_and_key]
+            deps_to_this_old_dep&.delete(from_what)
+          end
+        end
+
+        @from[from_what] = updated_dependencies
+        updated_dependencies.each do |kind_and_key|
+          deps_to_this_new_dep = @to[kind_and_key]
+          if deps_to_this_new_dep.nil?
+            deps_to_this_new_dep = Set.new
+            @to[kind_and_key] = deps_to_this_new_dep
+          end
+          deps_to_this_new_dep.add(from_what)
+        end
+      end
+
+      def self.segment_keys_from_clauses(clauses)
+        clauses.flat_map do |clause|
+          if clause.op == :segmentMatch
+            clause.values.map { |value| {kind: LaunchDarkly::SEGMENTS, key: value }}
+          else
+            []
+          end
+        end
+      end
+
+      #
+      # @param from_kind [String]
+      # @param from_item [LaunchDarkly::Impl::Model::FeatureFlag, LaunchDarkly::Impl::Model::Segment]
+      # @return [Set]
+      #
+      def self.compute_dependencies_from(from_kind, from_item)
+        return Set.new if from_item.nil?
+
+        if from_kind == LaunchDarkly::FEATURES
+          prereq_keys = from_item.prerequisites.map { |prereq| {kind: from_kind, key: prereq.key} }
+          segment_keys = from_item.rules.flat_map { |rule| DependencyTracker.segment_keys_from_clauses(rule.clauses) }
+
+          results = Set.new(prereq_keys)
+          results.merge(segment_keys)
+        elsif from_kind == LaunchDarkly::SEGMENTS
+          kind_and_keys  = from_item.rules.flat_map do |rule|
+            DependencyTracker.segment_keys_from_clauses(rule.clauses)
+          end
+          Set.new(kind_and_keys)
+        else
+          Set.new
+        end
+      end
+
+      #
+      # Clear any tracked dependencies and reset the tracking state to a clean slate.
+      #
+      def reset
+        @from.clear
+        @to.clear
+      end
+
+      #
+      # Populates the given set with the union of the initial item and all items that directly or indirectly
+      # depend on it (based on the current state of the dependency graph).
+      #
+      # @param items_out [Set]
+      # @param initial_modified_item [Object]
+      #
+      def add_affected_items(items_out, initial_modified_item)
+        return if items_out.include? initial_modified_item
+
+        items_out.add(initial_modified_item)
+        affected_items = @to[initial_modified_item]
+
+        return if affected_items.nil?
+
+        affected_items.each do |affected_item|
+          add_affected_items(items_out, affected_item)
+        end
+      end
+    end
+  end
+end

data/lib/ldclient-rb/impl/diagnostic_events.rb

@@ -9,7 +9,7 @@ module LaunchDarkly
       def self.create_diagnostic_id(sdk_key)
         {
           diagnosticId: SecureRandom.uuid,
-          sdkKeySuffix: sdk_key[-6..-1] || sdk_key
+          sdkKeySuffix: sdk_key[-6..-1] || sdk_key,
         }
       end
 
@@ -25,16 +25,16 @@ module LaunchDarkly
       end
 
       def create_init_event(config)
-        return {
+        {
           kind: 'diagnostic-init',
           creationDate: Util.current_time_millis,
           id: @id,
           configuration: DiagnosticAccumulator.make_config_data(config),
           sdk: DiagnosticAccumulator.make_sdk_data(config),
-          platform: DiagnosticAccumulator.make_platform_data
+          platform: DiagnosticAccumulator.make_platform_data,
         }
       end
-      
+
       def record_stream_init(timestamp, failed, duration_millis)
         @lock.synchronize do
           @stream_inits.push({ timestamp: timestamp, failed: failed, durationMillis: duration_millis })
@@ -57,7 +57,7 @@ module LaunchDarkly
           droppedEvents: dropped_events,
           deduplicatedUsers: deduplicated_users,
           eventsInLastBatch: events_in_last_batch,
-          streamInits: previous_stream_inits
+          streamInits: previous_stream_inits,
         }
         @data_since_date = current_time
         event
@@ -73,12 +73,11 @@ module LaunchDarkly
           diagnosticRecordingIntervalMillis: self.seconds_to_millis(config.diagnostic_recording_interval),
           eventsCapacity: config.capacity,
           eventsFlushIntervalMillis: self.seconds_to_millis(config.flush_interval),
-          inlineUsersInEvents: config.inline_users_in_events,
           pollingIntervalMillis: self.seconds_to_millis(config.poll_interval),
           socketTimeoutMillis: self.seconds_to_millis(config.read_timeout),
           streamingDisabled: !config.stream?,
-          userKeysCapacity: config.user_keys_capacity,
-          userKeysFlushIntervalMillis: self.seconds_to_millis(config.user_keys_flush_interval),
+          userKeysCapacity: config.context_keys_capacity,
+          userKeysFlushIntervalMillis: self.seconds_to_millis(config.context_keys_flush_interval),
           usingProxy: ENV.has_key?('http_proxy') || ENV.has_key?('https_proxy') || ENV.has_key?('HTTP_PROXY') || ENV.has_key?('HTTPS_PROXY'),
           usingRelayDaemon: config.use_ldd?,
         }
@@ -88,7 +87,7 @@ module LaunchDarkly
       def self.make_sdk_data(config)
         ret = {
           name: 'ruby-server-sdk',
-          version: LaunchDarkly::VERSION
+          version: LaunchDarkly::VERSION,
         }
         if config.wrapper_name
           ret[:wrapperName] = config.wrapper_name
@@ -105,7 +104,7 @@ module LaunchDarkly
           osName: self.normalize_os_name(conf['host_os']),
           osVersion: 'unknown', # there seems to be no portable way to detect this in Ruby
           rubyVersion: conf['ruby_version'],
-          rubyImplementation: Object.constants.include?(:RUBY_ENGINE) ? RUBY_ENGINE : 'unknown'
+          rubyImplementation: Object.constants.include?(:RUBY_ENGINE) ? RUBY_ENGINE : 'unknown',
         }
       end