launchdarkly-server-sdk 7.0.2 → 8.4.2

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module LaunchDarkly
+  module Impl
+
+    #
+    # A generic mechanism for registering event listeners and broadcasting
+    # events to them.
+    #
+    # The SDK maintains an instance of this for each available type of listener
+    # (flag change, data store status, etc.). They are all intended to share a
+    # single executor service; notifications are submitted individually to this
+    # service for each listener.
+    #
+    class Broadcaster
+      def initialize(executor, logger)
+        @listeners = Concurrent::Set.new
+        @executor = executor
+        @logger = logger
+      end
+
+      #
+      # Register a listener to this broadcaster.
+      #
+      # @param listener [#update]
+      #
+      def add_listener(listener)
+        unless listener.respond_to? :update
+          logger.warn("listener (#{listener.class}) does not respond to :update method. ignoring as registered listener")
+          return
+        end
+
+        listeners.add(listener)
+      end
+
+      #
+      # Removes a registered listener from this broadcaster.
+      #
+      def remove_listener(listener)
+        listeners.delete(listener)
+      end
+
+      def has_listeners?
+        !listeners.empty?
+      end
+
+      #
+      # Broadcast the provided event to all registered listeners.
+      #
+      # Each listener will be notified using the broadcasters executor. This
+      # method is non-blocking.
+      #
+      def broadcast(event)
+        listeners.each do |listener|
+          executor.post do
+            begin
+              listener.update(event)
+            rescue StandardError => e
+              logger.error("listener (#{listener.class}) raised exception (#{e}) processing event (#{event.class})")
+            end
+          end
+        end
+      end
+
+
+      private
+
+      # @return [Concurrent::ThreadPoolExecutor]
+      attr_reader :executor
+
+      # @return [Logger]
+      attr_reader :logger
+
+      # @return [Concurrent::Set]
+      attr_reader :listeners
+    end
+  end
+end

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

@@ -40,7 +40,7 @@ module LaunchDarkly
         return ERR_KIND_NON_STRING unless kind.is_a?(String)
         return ERR_KIND_CANNOT_BE_KIND if kind == "kind"
         return ERR_KIND_CANNOT_BE_MULTI if kind == "multi"
-        return ERR_KIND_INVALID_CHARS unless kind.match?(/^[\w.-]+$/)
+        ERR_KIND_INVALID_CHARS unless kind.match?(/^[\w.-]+$/)
       end
 
       #
@@ -51,7 +51,7 @@ module LaunchDarkly
       #
       def self.validate_key(key)
         return ERR_KEY_NON_STRING unless key.is_a?(String)
-        return ERR_KEY_EMPTY if key == ""
+        ERR_KEY_EMPTY if key == ""
       end
 
       #
@@ -61,7 +61,7 @@ module LaunchDarkly
       # @return [String, nil]
       #
       def self.validate_name(name)
-        return ERR_NAME_NON_STRING unless name.nil? || name.is_a?(String)
+        ERR_NAME_NON_STRING unless name.nil? || name.is_a?(String)
       end
 
       #

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

@@ -23,14 +23,32 @@ module LaunchDarkly
       # @return [Hash]
       #
       def filter(context)
-        return filter_single_context(context, true) unless context.multi_kind?
+        internal_filter(context, false)
+      end
+
+      #
+      # Return a hash representation of the provided context with attribute
+      # redaction applied.
+      #
+      # If a context is anonyomous, all attributes will be redacted except
+      # for key, kind, and anonymous.
+      #
+      # @param context [LaunchDarkly::LDContext]
+      # @return [Hash]
+      #
+      def filter_redact_anonymous(context)
+        internal_filter(context, true)
+      end
+
+      private def internal_filter(context, redact_anonymous)
+        return filter_single_context(context, true, redact_anonymous) unless context.multi_kind?
 
         filtered = {kind: 'multi'}
         (0...context.individual_context_count).each do |i|
           c = context.individual_context(i)
           next if c.nil?
 
-          filtered[c.kind] = filter_single_context(c, false)
+          filtered[c.kind] = filter_single_context(c, false, redact_anonymous)
         end
 
         filtered
@@ -43,22 +61,24 @@ module LaunchDarkly
       # @param include_kind [Boolean]
       # @return [Hash]
       #
-      private def filter_single_context(context, include_kind)
+      private def filter_single_context(context, include_kind, redact_anonymous)
         filtered = {key: context.key}
 
         filtered[:kind] = context.kind if include_kind
-        filtered[:anonymous] = true if context.get_value(:anonymous)
+
+        anonymous = context.get_value(:anonymous)
+        filtered[:anonymous] = true if anonymous
 
         redacted = []
         private_attributes = @private_attributes.concat(context.private_attributes)
 
         name = context.get_value(:name)
-        if !name.nil? && !check_whole_attribute_private(:name, private_attributes, redacted)
+        if !name.nil? && !check_whole_attribute_private(:name, private_attributes, redacted, anonymous && redact_anonymous)
           filtered[:name] = name
         end
 
         context.get_custom_attribute_names.each do |attribute|
-          unless check_whole_attribute_private(attribute, private_attributes, redacted)
+          unless check_whole_attribute_private(attribute, private_attributes, redacted, anonymous && redact_anonymous)
             value = context.get_value(attribute)
             filtered[attribute] = redact_json_value(nil, attribute, value, private_attributes, redacted)
           end
@@ -75,10 +95,11 @@ module LaunchDarkly
       # @param attribute [Symbol]
       # @param private_attributes [Array<Reference>]
       # @param redacted [Array<Symbol>]
+      # @param redact_all [Boolean]
       # @return [Boolean]
       #
-      private def check_whole_attribute_private(attribute, private_attributes, redacted)
-        if @all_attributes_private
+      private def check_whole_attribute_private(attribute, private_attributes, redacted, redact_all)
+        if @all_attributes_private || redact_all
           redacted << attribute
           return true
         end
@@ -142,4 +163,4 @@ module LaunchDarkly
       end
     end
   end
-end
+end

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

@@ -0,0 +1,188 @@
+require "concurrent"
+require "forwardable"
+require "ldclient-rb/impl/dependency_tracker"
+require "ldclient-rb/interfaces"
+require "set"
+
+module LaunchDarkly
+  module Impl
+    module DataSource
+      class StatusProvider
+        include LaunchDarkly::Interfaces::DataSource::StatusProvider
+
+        extend Forwardable
+        def_delegators :@status_broadcaster, :add_listener, :remove_listener
+
+        def initialize(status_broadcaster, update_sink)
+          # @type [Broadcaster]
+          @status_broadcaster = status_broadcaster
+          # @type [UpdateSink]
+          @data_source_update_sink = update_sink
+        end
+
+        def status
+          @data_source_update_sink.current_status
+        end
+      end
+
+      class UpdateSink
+        include LaunchDarkly::Interfaces::DataSource::UpdateSink
+
+        # @return [LaunchDarkly::Interfaces::DataSource::Status]
+        attr_reader :current_status
+
+        def initialize(data_store, status_broadcaster, flag_change_broadcaster)
+          # @type [LaunchDarkly::Interfaces::FeatureStore]
+          @data_store = data_store
+          # @type [Broadcaster]
+          @status_broadcaster = status_broadcaster
+          # @type [Broadcaster]
+          @flag_change_broadcaster = flag_change_broadcaster
+          @dependency_tracker = LaunchDarkly::Impl::DependencyTracker.new
+
+          @mutex = Mutex.new
+          @current_status = LaunchDarkly::Interfaces::DataSource::Status.new(
+            LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING,
+            Time.now,
+            nil)
+        end
+
+        def init(all_data)
+          old_data = nil
+          monitor_store_update do
+            if @flag_change_broadcaster.has_listeners?
+              old_data = {}
+              LaunchDarkly::ALL_KINDS.each do |kind|
+                old_data[kind] = @data_store.all(kind)
+              end
+            end
+
+            @data_store.init(all_data)
+          end
+
+          update_full_dependency_tracker(all_data)
+
+          return if old_data.nil?
+
+          send_change_events(
+            compute_changed_items_for_full_data_set(old_data, all_data)
+          )
+        end
+
+        def upsert(kind, item)
+          monitor_store_update { @data_store.upsert(kind, item) }
+
+          # TODO(sc-197908): We only want to do this if the store successfully
+          # updates the record.
+          @dependency_tracker.update_dependencies_from(kind, item[:key], item)
+          if @flag_change_broadcaster.has_listeners?
+            affected_items = Set.new
+            @dependency_tracker.add_affected_items(affected_items, {kind: kind, key: item[:key]})
+            send_change_events(affected_items)
+          end
+        end
+
+        def delete(kind, key, version)
+          monitor_store_update { @data_store.delete(kind, key, version) }
+
+          @dependency_tracker.update_dependencies_from(kind, key, nil)
+          if @flag_change_broadcaster.has_listeners?
+            affected_items = Set.new
+            @dependency_tracker.add_affected_items(affected_items, {kind: kind, key: key})
+            send_change_events(affected_items)
+          end
+        end
+
+        def update_status(new_state, new_error)
+          return if new_state.nil?
+
+          status_to_broadcast = nil
+
+          @mutex.synchronize do
+            old_status = @current_status
+
+            if new_state == LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED && old_status.state == LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING
+              # See {LaunchDarkly::Interfaces::DataSource::UpdateSink#update_status} for more information
+              new_state = LaunchDarkly::Interfaces::DataSource::Status::INITIALIZING
+            end
+
+            unless new_state == old_status.state && new_error.nil?
+              @current_status = LaunchDarkly::Interfaces::DataSource::Status.new(
+                new_state,
+                new_state == current_status.state ? current_status.state_since : Time.now,
+                new_error.nil? ? current_status.last_error : new_error
+              )
+              status_to_broadcast = current_status
+            end
+          end
+
+          @status_broadcaster.broadcast(status_to_broadcast) unless status_to_broadcast.nil?
+        end
+
+        private def update_full_dependency_tracker(all_data)
+          @dependency_tracker.reset
+          all_data.each do |kind, items|
+            items.each do |key, item|
+              @dependency_tracker.update_dependencies_from(kind, item.key, item)
+            end
+          end
+        end
+
+
+        #
+        # Method to monitor updates to the store. You provide a block to update
+        # the store. This mthod wraps that block, catching and re-raising all
+        # errors, and notifying all status listeners of the error.
+        #
+        private def monitor_store_update
+          begin
+            yield
+          rescue => e
+            error_info = LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::STORE_ERROR, 0, e.to_s, Time.now)
+            update_status(LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED, error_info)
+            raise
+          end
+        end
+
+
+        #
+        # @param [Hash] old_data
+        # @param [Hash] new_data
+        # @return [Set]
+        #
+        private def compute_changed_items_for_full_data_set(old_data, new_data)
+          affected_items = Set.new
+
+          LaunchDarkly::ALL_KINDS.each do |kind|
+            old_items = old_data[kind] || {}
+            new_items = new_data[kind] || {}
+
+            old_items.keys.concat(new_items.keys).each do |key|
+              old_item = old_items[key]
+              new_item = new_items[key]
+
+              next if old_item.nil? && new_item.nil?
+
+              if old_item.nil? || new_item.nil? || old_item[:version] < new_item[:version]
+                @dependency_tracker.add_affected_items(affected_items, {kind: kind, key: key.to_s})
+              end
+            end
+          end
+
+          affected_items
+        end
+
+        #
+        # @param affected_items [Set]
+        #
+        private def send_change_events(affected_items)
+          affected_items.each do |item|
+            if item[:kind] == LaunchDarkly::FEATURES
+              @flag_change_broadcaster.broadcast(LaunchDarkly::Interfaces::FlagChange.new(item[:key]))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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/evaluation_with_hook_result.rb

@@ -0,0 +1,34 @@
+module LaunchDarkly
+  module Impl
+    #
+    # Simple helper class for returning formatted data.
+    #
+    # The variation methods make use of the new hook support. Those methods all need to return an evaluation detail, and
+    # some other unstructured bit of data.
+    #
+    class EvaluationWithHookResult
+      #
+      # Return the evaluation detail that was generated as part of the evaluation.
+      #
+      # @return [LaunchDarkly::EvaluationDetail]
+      #
+      attr_reader :evaluation_detail
+
+      #
+      # All purpose container for additional return values from the wrapping method
+      #
+      # @return [any]
+      #
+      attr_reader :results
+
+      #
+      # @param evaluation_detail [LaunchDarkly::EvaluationDetail]
+      # @param results [any]
+      #
+      def initialize(evaluation_detail, results = nil)
+        @evaluation_detail = evaluation_detail
+        @results = results
+      end
+    end
+  end
+end

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

@@ -64,6 +64,7 @@ module LaunchDarkly
                 begin
                   res_time = Time.httpdate(response.headers["date"])
                 rescue ArgumentError
+                  # Ignored
                 end
               end
               return EventSenderResult.new(true, false, res_time)

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

@@ -1,23 +1,33 @@
+require 'set'
+
 module LaunchDarkly
   module Impl
     class Event
       # @param timestamp [Integer]
       # @param context [LaunchDarkly::LDContext]
-      def initialize(timestamp, context)
+      # @param sampling_ratio [Integer, nil]
+      # @param exclude_from_summaries [Boolean]
+      def initialize(timestamp, context, sampling_ratio = nil, exclude_from_summaries = false)
         @timestamp = timestamp
         @context = context
+        @sampling_ratio = sampling_ratio
+        @exclude_from_summaries = exclude_from_summaries
       end
 
       # @return [Integer]
       attr_reader :timestamp
       # @return [LaunchDarkly::LDContext]
       attr_reader :context
+      # @return [Integer, nil]
+      attr_reader :sampling_ratio
+      # @return [Boolean]
+      attr_reader :exclude_from_summaries
     end
 
     class EvalEvent < Event
       def initialize(timestamp, context, key, version = nil, variation = nil, value = nil, reason = nil, default = nil,
-        track_events = false, debug_until = nil, prereq_of = nil)
-        super(timestamp, context)
+        track_events = false, debug_until = nil, prereq_of = nil, sampling_ratio = nil, exclude_from_summaries = false)
+        super(timestamp, context, sampling_ratio, exclude_from_summaries)
         @key = key
         @version = version
         @variation = variation
@@ -41,6 +51,54 @@ module LaunchDarkly
       attr_reader :prereq_of
     end
 
+    class MigrationOpEvent < Event
+      #
+      # A migration op event represents the results of a migration-assisted read or write operation.
+      #
+      # The event includes optional measurements reporting on consistency checks, error reporting, and operation latency
+      # values.
+      #
+      # @param timestamp [Integer]
+      # @param context [LaunchDarkly::LDContext]
+      # @param key [string]
+      # @param flag [LaunchDarkly::Impl::Model::FeatureFlag, nil]
+      # @param operation [Symbol]
+      # @param default_stage [Symbol]
+      # @param evaluation [LaunchDarkly::EvaluationDetail]
+      # @param invoked [Set]
+      # @param consistency_check [Boolean, nil]
+      # @param consistency_check_ratio [Integer, nil]
+      # @param errors [Set]
+      # @param latencies [Hash<Symbol, Float>]
+      #
+      def initialize(timestamp, context, key, flag, operation, default_stage, evaluation, invoked, consistency_check, consistency_check_ratio, errors, latencies)
+        super(timestamp, context)
+        @operation = operation
+        @key = key
+        @version = flag&.version
+        @sampling_ratio = flag&.sampling_ratio
+        @default = default_stage
+        @evaluation = evaluation
+        @consistency_check = consistency_check
+        @consistency_check_ratio = consistency_check.nil? ? nil : consistency_check_ratio
+        @invoked = invoked
+        @errors = errors
+        @latencies = latencies
+      end
+
+      attr_reader :operation
+      attr_reader :key
+      attr_reader :version
+      attr_reader :sampling_ratio
+      attr_reader :default
+      attr_reader :evaluation
+      attr_reader :consistency_check
+      attr_reader :consistency_check_ratio
+      attr_reader :invoked
+      attr_reader :errors
+      attr_reader :latencies
+    end
+
     class IdentifyEvent < Event
       def initialize(timestamp, context)
         super(timestamp, context)