launchdarkly-server-sdk 8.8.3-java

data/lib/ldclient-rb/flags_state.rb

@@ -0,0 +1,88 @@
+require 'json'
+
+module LaunchDarkly
+  #
+  # 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.
+  #
+  class FeatureFlagsState
+    def initialize(valid)
+      @flag_values = {}
+      @flag_metadata = {}
+      @valid = valid
+    end
+
+    # Used internally to build the state map.
+    # @private
+    def add_flag(flag_state, with_reasons, details_only_if_tracked)
+      key = flag_state[:key]
+      @flag_values[key] = flag_state[:value]
+      meta = {}
+
+      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
+
+      unless omit_details
+        meta[:version] = flag_state[:version]
+      end
+
+      meta[:prerequisites] = flag_state[:prerequisites] unless flag_state[:prerequisites].nil? || flag_state[:prerequisites].empty?
+      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 context).
+    def valid?
+      @valid
+    end
+
+    # Returns the value of an individual feature flag at the time the state was recorded.
+    # Returns nil if the flag returned the default value, or if there was no such flag.
+    def flag_value(key)
+      @flag_values[key]
+    end
+
+    # Returns a map of flag keys to flag values. If a flag would have evaluated to the default value,
+    # its value will be nil.
+    #
+    # Do not use this method if you are passing data to the front end to "bootstrap" the JavaScript client.
+    # Instead, use as_json.
+    def values_map
+      @flag_values
+    end
+
+    # Returns a hash that can be used as a JSON representation of the entire state map, in the format
+    # used by the LaunchDarkly JavaScript SDK. Use this method if you are passing data to the front end
+    # in order to "bootstrap" the JavaScript client.
+    #
+    # Do not rely on the exact shape of this data, as it may change in future to support the needs of
+    # the JavaScript client.
+    def as_json(*) # parameter is unused, but may be passed if we're using the json gem
+      ret = @flag_values.clone
+      ret['$flagsState'] = @flag_metadata
+      ret['$valid'] = @valid
+      ret
+    end
+
+    # Same as as_json, but converts the JSON structure into a string.
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+require "ldclient-rb/config"
+require "ldclient-rb/expiring_cache"
+require "ldclient-rb/impl/repeating_task"
+require "ldclient-rb/interfaces"
+require "ldclient-rb/util"
+
+require "digest"
+
+module LaunchDarkly
+  module Impl
+    BigSegmentMembershipResult = Struct.new(:membership, :status)
+
+    class BigSegmentStoreManager
+      # use this as a singleton whenever a membership query returns nil; it's safe to reuse it because
+      # we will never modify the membership properties after they're queried
+      EMPTY_MEMBERSHIP = {}
+
+      def initialize(big_segments_config, logger)
+        @store = big_segments_config.store
+        @stale_after_millis = big_segments_config.stale_after * 1000
+        @status_provider = BigSegmentStoreStatusProviderImpl.new(-> { get_status })
+        @logger = logger
+        @last_status = nil
+
+        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
+      end
+
+      attr_reader :status_provider
+
+      def stop
+        @poll_worker.stop unless @poll_worker.nil?
+        @store.stop unless @store.nil?
+      end
+
+      def get_context_membership(context_key)
+        return nil unless @store
+        membership = @cache[context_key]
+        unless membership
+          begin
+            membership = @store.get_membership(BigSegmentStoreManager.hash_for_context_key(context_key))
+            membership = EMPTY_MEMBERSHIP if membership.nil?
+            @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 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)
+      end
+
+      def get_status
+        @last_status || poll_store_and_update_status
+      end
+
+      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
+        unless @store.nil?
+          begin
+            metadata = @store.get_metadata
+            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 stale?(timestamp)
+        !timestamp || ((Impl::Util.current_time_millis - timestamp) >= @stale_after_millis)
+      end
+
+      def self.hash_for_context_key(context_key)
+        Digest::SHA256.base64digest(context_key)
+      end
+    end
+
+    #
+    # Default implementation of the BigSegmentStoreStatusProvider interface.
+    #
+    # There isn't much to this because the real implementation is in BigSegmentStoreManager - we pass in a lambda
+    # that allows us to get the current status from that class. Also, the standard Observer methods such as
+    # add_observer are provided for us because BigSegmentStoreStatusProvider mixes in Observer, so all we need to
+    # to do make notifications happen is to call the Observer methods "changed" and "notify_observers".
+    #
+    class BigSegmentStoreStatusProviderImpl
+      include LaunchDarkly::Interfaces::BigSegmentStoreStatusProvider
+
+      def initialize(status_fn)
+        @status_fn = status_fn
+        @last_status = nil
+      end
+
+      def status
+        @status_fn.call
+      end
+
+      def update_status(new_status)
+        if !@last_status || new_status != @last_status
+          @last_status = new_status
+          changed
+          notify_observers(new_status)
+        end
+      end
+    end
+  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,166 @@
+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)
+        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, redact_anonymous)
+        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, redact_anonymous)
+        filtered = {key: context.key}
+
+        filtered[:kind] = context.kind if include_kind
+
+        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, anonymous && redact_anonymous)
+          filtered[:name] = name
+        end
+
+        context.get_custom_attribute_names.each do |attribute|
+          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
+        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>]
+      # @param redact_all [Boolean]
+      # @return [Boolean]
+      #
+      private def check_whole_attribute_private(attribute, private_attributes, redacted, redact_all)
+        if @all_attributes_private || redact_all
+          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