launchdarkly-server-sdk 6.4.0 → 7.0.0

data/lib/ldclient-rb/redis_store.rb

@@ -1,88 +0,0 @@
-require "ldclient-rb/interfaces"
-require "ldclient-rb/impl/integrations/redis_impl"
-
-module LaunchDarkly
-  #
-  # An implementation of the LaunchDarkly client's feature store that uses a Redis
-  # instance.  This object holds feature flags and related data received from the
-  # streaming API.  Feature data can also be further cached in memory to reduce overhead
-  # of calls to Redis.
-  #
-  # To use this class, you must first have the `redis` and `connection-pool` gems
-  # installed.  Then, create an instance and store it in the `feature_store` property
-  # of your client configuration.
-  #
-  # @deprecated Use the factory method in {LaunchDarkly::Integrations::Redis} instead. This specific
-  #   implementation class may be changed or removed in the future.
-  #
-  class RedisFeatureStore
-    include LaunchDarkly::Interfaces::FeatureStore
-
-    # Note that this class is now just a facade around CachingStoreWrapper, which is in turn delegating
-    # to RedisFeatureStoreCore where the actual database logic is. This class was retained for historical
-    # reasons, so that existing code can still call RedisFeatureStore.new. In the future, we will migrate
-    # away from exposing these concrete classes and use factory methods instead.
-
-    #
-    # Constructor for a RedisFeatureStore instance.
-    #
-    # @param opts [Hash] the configuration options
-    # @option opts [String] :redis_url  URL of the Redis instance (shortcut for omitting redis_opts)
-    # @option opts [Hash] :redis_opts  options to pass to the Redis constructor (if you want to specify more than just redis_url)
-    # @option opts [String] :prefix  namespace prefix to add to all hash keys used by LaunchDarkly
-    # @option opts [Logger] :logger  a `Logger` instance; defaults to `Config.default_logger`
-    # @option opts [Integer] :max_connections  size of the Redis connection pool
-    # @option opts [Integer] :expiration  expiration time for the in-memory cache, in seconds; 0 for no local caching
-    # @option opts [Integer] :capacity  maximum number of feature flags (or related objects) to cache locally
-    # @option opts [Object] :pool  custom connection pool, if desired
-    # @option opts [Boolean] :pool_shutdown_on_close whether calling `close` should shutdown the custom connection pool.
-    #
-    def initialize(opts = {})
-      core = LaunchDarkly::Impl::Integrations::Redis::RedisFeatureStoreCore.new(opts)
-      @wrapper = LaunchDarkly::Integrations::Util::CachingStoreWrapper.new(core, opts)
-    end
-
-    #
-    # Default value for the `redis_url` constructor parameter; points to an instance of Redis
-    # running at `localhost` with its default port.
-    #
-    def self.default_redis_url
-      LaunchDarkly::Integrations::Redis::default_redis_url
-    end
-
-    #
-    # Default value for the `prefix` constructor parameter.
-    #
-    def self.default_prefix
-      LaunchDarkly::Integrations::Redis::default_prefix
-    end
-
-    def get(kind, key)
-      @wrapper.get(kind, key)
-    end
-
-    def all(kind)
-      @wrapper.all(kind)
-    end
-
-    def delete(kind, key, version)
-      @wrapper.delete(kind, key, version)
-    end
-
-    def init(all_data)
-      @wrapper.init(all_data)
-    end
-
-    def upsert(kind, item)
-      @wrapper.upsert(kind, item)
-    end
-
-    def initialized?
-      @wrapper.initialized?
-    end
-
-    def stop
-      @wrapper.stop
-    end
-  end
-end

data/lib/ldclient-rb/user_filter.rb

@@ -1,52 +0,0 @@
-require "json"
-require "set"
-
-module LaunchDarkly
-  # @private
-  class UserFilter
-    def initialize(config)
-      @all_attributes_private = config.all_attributes_private
-      @private_attribute_names = Set.new(config.private_attribute_names.map(&:to_sym))
-    end
-
-    def transform_user_props(user_props)
-      return nil if user_props.nil?
-      
-      user_private_attrs = Set.new((user_props[:privateAttributeNames] || []).map(&:to_sym))
-
-      filtered_user_props, removed = filter_values(user_props, user_private_attrs, ALLOWED_TOP_LEVEL_KEYS, IGNORED_TOP_LEVEL_KEYS)
-      custom = user_props[:custom]
-      if !custom.nil?
-        filtered_user_props[:custom], removed_custom = filter_values(custom, user_private_attrs)
-        removed.merge(removed_custom)
-      end
-
-      unless removed.empty?
-        # note, :privateAttributeNames is what the developer sets; :privateAttrs is what we send to the server
-        filtered_user_props[:privateAttrs] = removed.to_a.sort.map { |s| s.to_s }
-      end
-      return filtered_user_props
-    end
-
-    private
-
-    ALLOWED_TOP_LEVEL_KEYS = Set.new([:key, :secondary, :ip, :country, :email,
-                :firstName, :lastName, :avatar, :name, :anonymous, :custom])
-    IGNORED_TOP_LEVEL_KEYS = Set.new([:custom, :key, :anonymous])
-
-    def filter_values(props, user_private_attrs, allowed_keys = [], keys_to_leave_as_is = [])
-      is_valid_key = lambda { |key| allowed_keys.empty? || allowed_keys.include?(key) }
-      removed_keys = Set.new(props.keys.select { |key|
-        # Note that if is_valid_key returns false, we don't explicitly *remove* the key (which would place
-        # it in the privateAttrs list) - we just silently drop it when we calculate filtered_hash.
-        is_valid_key.call(key) && !keys_to_leave_as_is.include?(key) && private_attr?(key, user_private_attrs)
-      })
-      filtered_hash = props.select { |key, value| !removed_keys.include?(key) && is_valid_key.call(key) }
-      [filtered_hash, removed_keys]
-    end
-
-    def private_attr?(name, user_private_attrs)
-      @all_attributes_private || @private_attribute_names.include?(name) || user_private_attrs.include?(name)
-    end
-  end
-end