launchdarkly-server-sdk 6.3.0 → 8.0.0

data/lib/ldclient-rb/flags_state.rb

@@ -2,7 +2,7 @@ require 'json'
 
 module LaunchDarkly
   #
-  # A snapshot of the state of all feature flags with regard to a specific user, generated by
+  # A snapshot of the state of all feature flags with regard to a specific context, generated by
   # calling the {LDClient#all_flags_state}. Serializing this object to JSON using
   # `JSON.generate` (or the `to_json` method) will produce the appropriate data structure for
   # bootstrapping the LaunchDarkly JavaScript client.
@@ -16,26 +16,37 @@ module LaunchDarkly
 
     # Used internally to build the state map.
     # @private
-    def add_flag(flag, value, variation, reason = nil, details_only_if_tracked = false)
-      key = flag[:key]
-      @flag_values[key] = value
+    def add_flag(flag_state, with_reasons, details_only_if_tracked)
+      key = flag_state[:key]
+      @flag_values[key] = flag_state[:value]
       meta = {}
-      with_details = !details_only_if_tracked || flag[:trackEvents]
-      if !with_details && flag[:debugEventsUntilDate]
-        with_details = flag[:debugEventsUntilDate] > Impl::Util::current_time_millis
+
+      omit_details = false
+      if details_only_if_tracked
+        if !flag_state[:trackEvents] && !flag_state[:trackReason] && !(flag_state[:debugEventsUntilDate] && flag_state[:debugEventsUntilDate] > Impl::Util::current_time_millis)
+          omit_details = true
+        end
+      end
+
+      reason = (!with_reasons and !flag_state[:trackReason]) ? nil : flag_state[:reason]
+
+      if !reason.nil? && !omit_details
+        meta[:reason] = reason
       end
-      if with_details
-        meta[:version] = flag[:version]
-        meta[:reason] = reason if !reason.nil?
+
+      unless omit_details
+        meta[:version] = flag_state[:version]
       end
-      meta[:variation] = variation if !variation.nil?
-      meta[:trackEvents] = true if flag[:trackEvents]
-      meta[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
+
+      meta[:variation] = flag_state[:variation] unless flag_state[:variation].nil?
+      meta[:trackEvents] = true if flag_state[:trackEvents]
+      meta[:trackReason] = true if flag_state[:trackReason]
+      meta[:debugEventsUntilDate] = flag_state[:debugEventsUntilDate] if flag_state[:debugEventsUntilDate]
       @flag_metadata[key] = meta
     end
 
     # Returns true if this object contains a valid snapshot of feature flag state, or false if the
-    # state could not be computed (for instance, because the client was offline or there was no user).
+    # state could not be computed (for instance, because the client was offline or there was no context).
     def valid?
       @valid
     end
@@ -70,7 +81,7 @@ module LaunchDarkly
 
     # Same as as_json, but converts the JSON structure into a string.
     def to_json(*a)
-      as_json.to_json(a)
+      as_json.to_json(*a)
     end
   end
 end

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

@@ -22,8 +22,8 @@ module LaunchDarkly
         @logger = logger
         @last_status = nil
 
-        if !@store.nil?
-          @cache = ExpiringCache.new(big_segments_config.user_cache_size, big_segments_config.user_cache_time)
+        unless @store.nil?
+          @cache = ExpiringCache.new(big_segments_config.context_cache_size, big_segments_config.context_cache_time)
           @poll_worker = RepeatingTask.new(big_segments_config.status_poll_interval, 0, -> { poll_store_and_update_status }, logger)
           @poll_worker.start
         end
@@ -32,25 +32,25 @@ module LaunchDarkly
       attr_reader :status_provider
 
       def stop
-        @poll_worker.stop if !@poll_worker.nil?
-        @store.stop if !@store.nil?
+        @poll_worker.stop unless @poll_worker.nil?
+        @store.stop unless @store.nil?
       end
 
-      def get_user_membership(user_key)
-        return nil if !@store
-        membership = @cache[user_key]
-        if !membership
+      def get_context_membership(context_key)
+        return nil unless @store
+        membership = @cache[context_key]
+        unless membership
           begin
-            membership = @store.get_membership(BigSegmentStoreManager.hash_for_user_key(user_key))
+            membership = @store.get_membership(BigSegmentStoreManager.hash_for_context_key(context_key))
             membership = EMPTY_MEMBERSHIP if membership.nil?
-            @cache[user_key] = membership
+            @cache[context_key] = membership
           rescue => e
             LaunchDarkly::Util.log_exception(@logger, "Big Segment store membership query returned error", e)
             return BigSegmentMembershipResult.new(nil, BigSegmentsStatus::STORE_ERROR)
           end
         end
-        poll_store_and_update_status if !@last_status
-        if !@last_status.available
+        poll_store_and_update_status unless @last_status
+        unless @last_status.available
           return BigSegmentMembershipResult.new(membership, BigSegmentsStatus::STORE_ERROR)
         end
         BigSegmentMembershipResult.new(membership, @last_status.stale ? BigSegmentsStatus::STALE : BigSegmentsStatus::HEALTHY)
@@ -62,26 +62,26 @@ module LaunchDarkly
 
       def poll_store_and_update_status
         new_status = Interfaces::BigSegmentStoreStatus.new(false, false) # default to "unavailable" if we don't get a new status below
-        if !@store.nil?
+        unless @store.nil?
           begin
             metadata = @store.get_metadata
-            new_status = Interfaces::BigSegmentStoreStatus.new(true, !metadata || is_stale(metadata.last_up_to_date))
+            new_status = Interfaces::BigSegmentStoreStatus.new(true, !metadata || stale?(metadata.last_up_to_date))
           rescue => e
             LaunchDarkly::Util.log_exception(@logger, "Big Segment store status query returned error", e)
           end
         end
         @last_status = new_status
         @status_provider.update_status(new_status)
-        
+
         new_status
       end
 
-      def is_stale(timestamp)
+      def stale?(timestamp)
         !timestamp || ((Impl::Util.current_time_millis - timestamp) >= @stale_after_millis)
       end
 
-      def self.hash_for_user_key(user_key)
-        Digest::SHA256.base64digest(user_key)
+      def self.hash_for_context_key(context_key)
+        Digest::SHA256.base64digest(context_key)
       end
     end
 

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

@@ -0,0 +1,96 @@
+require "erb"
+
+module LaunchDarkly
+  module Impl
+    module Context
+      ERR_KIND_NON_STRING = 'context kind must be a string'
+      ERR_KIND_CANNOT_BE_KIND = '"kind" is not a valid context kind'
+      ERR_KIND_CANNOT_BE_MULTI = '"multi" is not a valid context kind'
+      ERR_KIND_INVALID_CHARS = 'context kind contains disallowed characters'
+
+      ERR_KEY_NON_STRING = 'context key must be a string'
+      ERR_KEY_EMPTY = 'context key must not be empty'
+
+      ERR_NAME_NON_STRING = 'context name must be a string'
+
+      ERR_ANONYMOUS_NON_BOOLEAN = 'context anonymous must be a boolean'
+
+      #
+      # We allow consumers of this SDK to provide us with either a Hash or an
+      # instance of an LDContext. This is convenient for them but not as much
+      # for us. To make the conversion slightly more convenient for us, we have
+      # created this method.
+      #
+      # @param context [Hash, LDContext]
+      # @return [LDContext]
+      #
+      def self.make_context(context)
+        return context if context.is_a?(LDContext)
+
+        LDContext.create(context)
+      end
+
+      #
+      # Returns an error message if the kind is invalid; nil otherwise.
+      #
+      # @param kind [any]
+      # @return [String, nil]
+      #
+      def self.validate_kind(kind)
+        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"
+        ERR_KIND_INVALID_CHARS unless kind.match?(/^[\w.-]+$/)
+      end
+
+      #
+      # Returns an error message if the key is invalid; nil otherwise.
+      #
+      # @param key [any]
+      # @return [String, nil]
+      #
+      def self.validate_key(key)
+        return ERR_KEY_NON_STRING unless key.is_a?(String)
+        ERR_KEY_EMPTY if key == ""
+      end
+
+      #
+      # Returns an error message if the name is invalid; nil otherwise.
+      #
+      # @param name [any]
+      # @return [String, nil]
+      #
+      def self.validate_name(name)
+        ERR_NAME_NON_STRING unless name.nil? || name.is_a?(String)
+      end
+
+      #
+      # Returns an error message if anonymous is invalid; nil otherwise.
+      #
+      # @param anonymous [any]
+      # @param allow_nil [Boolean]
+      # @return [String, nil]
+      #
+      def self.validate_anonymous(anonymous, allow_nil)
+        return nil if anonymous.nil? && allow_nil
+        return nil if [true, false].include? anonymous
+
+        ERR_ANONYMOUS_NON_BOOLEAN
+      end
+
+      #
+      # @param kind [String]
+      # @param key [String]
+      # @return [String]
+      #
+      def self.canonicalize_key_for_kind(kind, key)
+        # When building a FullyQualifiedKey, ':' and '%' are percent-escaped;
+        # we do not use a full URL-encoding function because implementations of
+        # this are inconsistent across platforms.
+        encoded = key.gsub("%", "%25").gsub(":", "%3A")
+
+        "#{kind}:#{encoded}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+module LaunchDarkly
+  module Impl
+    class ContextFilter
+      #
+      # @param all_attributes_private [Boolean]
+      # @param private_attributes [Array<String>]
+      #
+      def initialize(all_attributes_private, private_attributes)
+        @all_attributes_private = all_attributes_private
+
+        @private_attributes = []
+        private_attributes.each do |attribute|
+          reference = LaunchDarkly::Reference.create(attribute)
+          @private_attributes << reference if reference.error.nil?
+        end
+      end
+
+      #
+      # Return a hash representation of the provided context with attribute
+      # redaction applied.
+      #
+      # @param context [LaunchDarkly::LDContext]
+      # @return [Hash]
+      #
+      def filter(context)
+        return filter_single_context(context, true) 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)
+        end
+
+        filtered
+      end
+
+      #
+      # Apply redaction rules for a single context.
+      #
+      # @param context [LaunchDarkly::LDContext]
+      # @param include_kind [Boolean]
+      # @return [Hash]
+      #
+      private def filter_single_context(context, include_kind)
+        filtered = {key: context.key}
+
+        filtered[:kind] = context.kind if include_kind
+        filtered[:anonymous] = true if context.get_value(: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)
+          filtered[:name] = name
+        end
+
+        context.get_custom_attribute_names.each do |attribute|
+          unless check_whole_attribute_private(attribute, private_attributes, redacted)
+            value = context.get_value(attribute)
+            filtered[attribute] = redact_json_value(nil, attribute, value, private_attributes, redacted)
+          end
+        end
+
+        filtered[:_meta] = {redactedAttributes: redacted} unless redacted.empty?
+
+        filtered
+      end
+
+      #
+      # Check if an entire attribute should be redacted.
+      #
+      # @param attribute [Symbol]
+      # @param private_attributes [Array<Reference>]
+      # @param redacted [Array<Symbol>]
+      # @return [Boolean]
+      #
+      private def check_whole_attribute_private(attribute, private_attributes, redacted)
+        if @all_attributes_private
+          redacted << attribute
+          return true
+        end
+
+        private_attributes.each do |private_attribute|
+          if private_attribute.component(0) == attribute && private_attribute.depth == 1
+            redacted << attribute
+            return true
+          end
+        end
+
+        false
+      end
+
+      #
+      # Apply redaction rules to the provided value.
+      #
+      # @param parent_path [Array<String>, nil]
+      # @param name [String]
+      # @param value [any]
+      # @param private_attributes [Array<Reference>]
+      # @param redacted [Array<Symbol>]
+      # @return [any]
+      #
+      private def redact_json_value(parent_path, name, value, private_attributes, redacted)
+        return value unless value.is_a?(Hash)
+
+        ret = {}
+        current_path = parent_path.clone || []
+        current_path << name
+
+        value.each do |k, v|
+          was_redacted = false
+          private_attributes.each do |private_attribute|
+            next unless private_attribute.depth == (current_path.count + 1)
+
+            component = private_attribute.component(current_path.count)
+            next unless component == k
+
+            match = true
+            (0...current_path.count).each do |i|
+              unless private_attribute.component(i) == current_path[i]
+                match = false
+                break
+              end
+            end
+
+            if match
+              redacted << private_attribute.raw_path.to_sym
+              was_redacted = true
+              break
+            end
+          end
+
+          unless was_redacted
+            ret[k] = redact_json_value(current_path, k, v, private_attributes, redacted)
+          end
+        end
+
+        ret
+      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