launchdarkly-server-sdk 6.3.0 → 8.0.0

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

@@ -1,126 +0,0 @@
-
-module LaunchDarkly
-  module Impl
-    # Event constructors are centralized here to avoid mistakes and repetitive logic.
-    # The LDClient owns two instances of EventFactory: one that always embeds evaluation reasons
-    # in the events (for when variation_detail is called) and one that doesn't.
-    #
-    # Note that these methods do not set the "creationDate" property, because in the Ruby client,
-    # that is done by EventProcessor.add_event().
-    class EventFactory
-      def initialize(with_reasons)
-        @with_reasons = with_reasons
-      end
-
-      def new_eval_event(flag, user, detail, default_value, prereq_of_flag = nil)
-        add_experiment_data = is_experiment(flag, detail.reason)
-        e = {
-          kind: 'feature',
-          key: flag[:key],
-          user: user,
-          variation: detail.variation_index,
-          value: detail.value,
-          default: default_value,
-          version: flag[:version]
-        }
-        # the following properties are handled separately so we don't waste bandwidth on unused keys
-        e[:trackEvents] = true if add_experiment_data || flag[:trackEvents]
-        e[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
-        e[:prereqOf] = prereq_of_flag[:key] if !prereq_of_flag.nil?
-        e[:reason] = detail.reason if add_experiment_data || @with_reasons
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      def new_default_event(flag, user, default_value, reason)
-        e = {
-          kind: 'feature',
-          key: flag[:key],
-          user: user,
-          value: default_value,
-          default: default_value,
-          version: flag[:version]
-        }
-        e[:trackEvents] = true if flag[:trackEvents]
-        e[:debugEventsUntilDate] = flag[:debugEventsUntilDate] if flag[:debugEventsUntilDate]
-        e[:reason] = reason if @with_reasons
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      def new_unknown_flag_event(key, user, default_value, reason)
-        e = {
-          kind: 'feature',
-          key: key,
-          user: user,
-          value: default_value,
-          default: default_value
-        }
-        e[:reason] = reason if @with_reasons
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      def new_identify_event(user)
-        {
-          kind: 'identify',
-          key: user[:key],
-          user: user
-        }
-      end
-
-      def new_alias_event(current_context, previous_context)
-        {
-          kind: 'alias',
-          key: current_context[:key],
-          contextKind: context_to_context_kind(current_context),
-          previousKey: previous_context[:key],
-          previousContextKind: context_to_context_kind(previous_context)
-        }
-      end
-
-      def new_custom_event(event_name, user, data, metric_value)
-        e = {
-          kind: 'custom',
-          key: event_name,
-          user: user
-        }
-        e[:data] = data if !data.nil?
-        e[:metricValue] = metric_value if !metric_value.nil?
-        e[:contextKind] = context_to_context_kind(user) if !user.nil? && user[:anonymous]
-        e
-      end
-
-      private
-
-      def context_to_context_kind(user)
-          if !user.nil? && user[:anonymous]
-            return "anonymousUser"
-          else
-            return "user"
-          end
-      end
-
-      def is_experiment(flag, reason)
-        return false if !reason
-
-        if reason.in_experiment
-          return true
-        end
-
-        case reason[:kind]
-        when 'RULE_MATCH'
-          index = reason[:ruleIndex]
-          if !index.nil?
-            rules = flag[:rules] || []
-            return index >= 0 && index < rules.length && rules[index][:trackEvents]
-          end
-        when 'FALLTHROUGH'
-          return !!flag[:trackEventsFallthrough]
-        end
-        false
-      end
-
-    end
-  end
-end

data/lib/ldclient-rb/newrelic.rb

@@ -1,17 +0,0 @@
-module LaunchDarkly
-  # @private
-  class LDNewRelic
-    begin
-      require "newrelic_rpm"
-      NR_ENABLED = defined?(::NewRelic::Agent.add_custom_parameters)
-    rescue ScriptError, StandardError
-      NR_ENABLED = false
-    end
-
-    def self.annotate_transaction(key, value)
-      if NR_ENABLED
-        ::NewRelic::Agent.add_custom_parameters(key.to_s => value.to_s)
-      end
-    end
-  end
-end

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