launchdarkly-server-sdk 7.3.2 → 8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4a03c0847cb10ea287eaa193067eb3e74191ea124faad2ec6a632ccd04b3297
-  data.tar.gz: dc06eb1a9d68e1fa972751ac4273ecc3284737279d1715b2769fde52f8457def
+  metadata.gz: 133fe555993b53f1e53f3348242d1c96ac2318d2c2c1ebf48e33e4d23c6e97f3
+  data.tar.gz: 12f604c2a17d9d06433a1ad041051e41f767efa3c7310a5925553cb5678b5709
 SHA512:
-  metadata.gz: 9496714bc7e4fe7ddfdf392255d89033a5d330b26397efd87ac166582d6ac74984843a91d5ee1236638f70310d8e4f03ab0d8fce0d0220381daed4b2bee9ea98
-  data.tar.gz: ababf98f4a35776fcbd9911a06b2dca144fb5803a05ad9f1aabe5a5afcb776a9c76a9156059ccfc484888d32c1f3ef70a81b8060bb01bced991d72b417da0b5f
+  metadata.gz: 1be2d4708681d7e0a2665e68e878ed8d2e17975f6c28716ed139911b866acb067884b4af872e6f5469177f09b5071f1c8fbb0ac6b7519f581bb20ee11afb76df
+  data.tar.gz: 2d0a5df44d5de21887eb4330f34bf65d4a4bab9a153d7644077790e3262a8b6418c26c4ebe5612523be468d05ddd5a8b837dc22a347c08ef463229c337e040c3

data/lib/ldclient-rb/config.rb

@@ -13,18 +13,6 @@ module LaunchDarkly
     #
     # Constructor for creating custom LaunchDarkly configurations.
     #
-    # `user_keys_capacity` and `user_keys_flush_interval` are deprecated
-    # configuration options. They exist to maintain backwards compatibility
-    # with previous configurations. Newer code should prefer their replacement
-    # options -- `context_keys_capacity` and `context_keys_flush_interval`.
-    #
-    # In the event both the user and context variations are provided, the
-    # context specific configuration option will take precedence.
-    #
-    # Similarly, `private_attribute_names` is deprecated. Newer code should
-    # prefer `private_attributes`. If both are provided, `private_attributes`
-    # will take precedence.
-    #
     # @param opts [Hash] the configuration options
     # @option opts [Logger] :logger See {#logger}.
     # @option opts [String] :base_uri ("https://sdk.launchdarkly.com") See {#base_uri}.
@@ -42,12 +30,9 @@ module LaunchDarkly
     # @option opts [Float] :poll_interval (30) See {#poll_interval}.
     # @option opts [Boolean] :stream (true) See {#stream?}.
     # @option opts [Boolean] all_attributes_private (false) See {#all_attributes_private}.
-    # @option opts [Array] :private_attribute_names See {#private_attribute_names}.
     # @option opts [Array] :private_attributes See {#private_attributes}.
     # @option opts [Boolean] :send_events (true) See {#send_events}.
-    # @option opts [Integer] :user_keys_capacity (1000) See {#user_keys_capacity}.
     # @option opts [Integer] :context_keys_capacity (1000) See {#context_keys_capacity}.
-    # @option opts [Float] :user_keys_flush_interval (300) See {#user_keys_flush_interval}.
     # @option opts [Float] :context_keys_flush_interval (300) See {#context_keys_flush_interval}.
     # @option opts [Object] :data_source See {#data_source}.
     # @option opts [Boolean] :diagnostic_opt_out (false) See {#diagnostic_opt_out?}.
@@ -76,10 +61,10 @@ module LaunchDarkly
       @offline = opts.has_key?(:offline) ? opts[:offline] : Config.default_offline
       @poll_interval = opts.has_key?(:poll_interval) && opts[:poll_interval] > Config.default_poll_interval ? opts[:poll_interval] : Config.default_poll_interval
       @all_attributes_private = opts[:all_attributes_private] || false
-      @private_attributes = opts[:private_attributes] || opts[:private_attribute_names] || []
+      @private_attributes = opts[:private_attributes] || []
       @send_events = opts.has_key?(:send_events) ? opts[:send_events] : Config.default_send_events
-      @context_keys_capacity = opts[:context_keys_capacity] || opts[:user_keys_capacity] || Config.default_context_keys_capacity
-      @context_keys_flush_interval = opts[:context_keys_flush_interval] || opts[:user_keys_flush_interval] || Config.default_user_keys_flush_interval
+      @context_keys_capacity = opts[:context_keys_capacity] || Config.default_context_keys_capacity
+      @context_keys_flush_interval = opts[:context_keys_flush_interval] || Config.default_context_keys_flush_interval
       @data_source = opts[:data_source]
       @diagnostic_opt_out = opts.has_key?(:diagnostic_opt_out) && opts[:diagnostic_opt_out]
       @diagnostic_recording_interval = opts.has_key?(:diagnostic_recording_interval) && opts[:diagnostic_recording_interval] > Config.minimum_diagnostic_recording_interval ?
@@ -258,14 +243,6 @@ module LaunchDarkly
     #
     attr_reader :private_attributes
 
-    #
-    # @deprecated Backwards compatibility alias for #private_attributes.
-    #
-    # @return [Integer]
-    # @see #private_attributes
-    #
-    alias :private_attribute_names :private_attributes
-
     #
     # Whether to send events back to LaunchDarkly. This differs from {#offline?} in that it affects
     # only the sending of client-side events, not streaming or polling for events from the server.
@@ -281,14 +258,6 @@ module LaunchDarkly
     #
     attr_reader :context_keys_capacity
 
-    #
-    # @deprecated Backwards compatibility alias for #context_keys_capacity.
-    #
-    # @return [Integer]
-    # @see #context_keys_flush_interval
-    #
-    alias :user_keys_capacity :context_keys_capacity
-
     #
     # The interval in seconds at which the event processor will reset its set of known context keys.
     # @return [Float]
@@ -296,14 +265,6 @@ module LaunchDarkly
     #
     attr_reader :context_keys_flush_interval
 
-    #
-    # @deprecated Backwards compatibility alias for #context_keys_flush_interval.
-    #
-    # @return [Integer]
-    # @see #context_keys_flush_interval
-    #
-    alias :user_keys_flush_interval :context_keys_flush_interval
-
     #
     # An object that is responsible for receiving feature flag data from LaunchDarkly. By default,
     # the client uses its standard polling or streaming implementation; this is customizable for
@@ -570,18 +531,6 @@ module LaunchDarkly
       300
     end
 
-    class << self
-      #
-      # @deprecated Backwards compatibility alias for #default_context_keys_capacity
-      #
-      alias :default_user_keys_capacity :default_context_keys_capacity
-
-      #
-      # @deprecated Backwards compatibility alias for #default_context_keys_flush_interval
-      #
-      alias :default_user_keys_flush_interval :default_context_keys_flush_interval
-    end
-
     #
     # The default value for {#diagnostic_recording_interval}.
     # @return [Float] 900
@@ -647,25 +596,11 @@ module LaunchDarkly
     # @return [Integer]
     attr_reader :context_cache_size
 
-    #
-    # @deprecated Backwards compatibility alias for #context_cache_size
-    #
-    # @return [Integer]
-    #
-    alias :user_cache_size :context_cache_size
-
     # The maximum length of time (in seconds) that the Big Segment state for a context will be cached
     # by the SDK.
     # @return [Float]
     attr_reader :context_cache_time
 
-    #
-    # @deprecated Backwards compatibility alias for #context_cache_time
-    #
-    # @return [Float]
-    #
-    alias :user_cache_time :context_cache_time
-
     # The interval (in seconds) at which the SDK will poll the Big Segment store to make sure it is
     # available and to determine how long ago it was updated.
     # @return [Float]

data/lib/ldclient-rb/context.rb

@@ -47,9 +47,6 @@ module LaunchDarkly
     # @return [String, nil] Returns the error associated with this LDContext if invalid
     attr_reader :error
 
-    # @return [Array<Reference>] Returns the private attributes associated with this LDContext
-    attr_reader :private_attributes
-
     #
     # @private
     # @param key [String, nil]
@@ -69,10 +66,10 @@ module LaunchDarkly
       @name = name
       @anonymous = anonymous || false
       @attributes = attributes
-      @private_attributes = []
+      @private_attributes = Set.new
       (private_attributes || []).each do |attribute|
         reference = Reference.create(attribute)
-        @private_attributes << reference if reference.error.nil?
+        @private_attributes.add(reference) if reference.error.nil?
       end
       @error = error
       @contexts = contexts
@@ -80,6 +77,16 @@ module LaunchDarkly
     end
     private_class_method :new
 
+    protected attr_reader :name, :anonymous, :attributes
+
+    #
+    # @return [Array<Reference>] Returns the private attributes associated with this LDContext
+    #
+    def private_attributes
+      # TODO(sc-227265): Return a set instead of an array.
+      @private_attributes.to_a
+    end
+
     #
     # @return [Boolean] Is this LDContext a multi-kind context?
     #
@@ -274,6 +281,59 @@ module LaunchDarkly
       nil
     end
 
+    #
+    # An LDContext can be compared to other LDContexts or to a hash object. If
+    # a hash is provided, it is first converted to an LDContext using the
+    # `LDContext.create` method.
+    #
+    # @param other [LDContext, Hash]
+    # @return [Boolean]
+    #
+    def ==(other)
+      other = LDContext.create(other) if other.is_a? Hash
+      return false unless other.is_a? LDContext
+
+      return false unless self.kind == other.kind
+      return false unless self.valid? == other.valid?
+      return false unless self.error == other.error
+
+      return false unless self.individual_context_count == other.individual_context_count
+
+      if self.multi_kind?
+        self.kinds.each do |kind|
+          return false unless self.individual_context(kind) == other.individual_context(kind)
+        end
+
+        return true
+      end
+
+      return false unless self.key == other.key
+      return false unless self.name == other.name
+      return false unless self.anonymous == other.anonymous
+      return false unless self.attributes == other.attributes
+
+      # TODO(sc-227265): Calling .to_set is unnecessary once private_attributes are sets.
+      return false unless self.private_attributes.to_set == other.private_attributes.to_set
+
+      true
+    end
+    alias eql? ==
+
+    #
+    # For a single-kind context, the provided key will return the attribute value specified. This is the same as calling
+    # `LDCotnext.get_value`.
+    #
+    # For multi-kind contexts, the key will be interpreted as a context kind. If the multi-kind context has an
+    # individual context of that kind, it will be returned. Otherwise, this method will return nil. This behaves the
+    # same as calling `LDContext.individual_context`.
+    #
+    # @param key [Symbol, String]
+    #
+    def [](key)
+      return nil unless key.is_a? Symbol or key.is_a? String
+      multi_kind? ? individual_context(key.to_s) : get_value(key)
+    end
+
     #
     # Retrieve the value of any top level, addressable attribute.
     #
@@ -324,7 +384,6 @@ module LaunchDarkly
     #
     def self.create(data)
       return create_invalid_context(ERR_NOT_HASH) unless data.is_a?(Hash)
-      return create_legacy_context(data) unless data.has_key?(:kind)
 
       kind = data[:kind]
       if kind == KIND_MULTI
@@ -394,52 +453,6 @@ module LaunchDarkly
       new(nil, nil, nil, nil, false, nil, nil, error)
     end
 
-    #
-    # @param data [Hash]
-    # @return [LDContext]
-    #
-    private_class_method def self.create_legacy_context(data)
-      warn("DEPRECATED: legacy user format will be removed in 8.0.0", uplevel: 1)
-
-      key = data[:key]
-
-      # Legacy users are allowed to have "" as a key but they cannot have nil as a key.
-      return create_invalid_context(ERR_KEY_EMPTY) if key.nil?
-
-      name = data[:name]
-      name_error = LaunchDarkly::Impl::Context.validate_name(name)
-      return create_invalid_context(name_error) unless name_error.nil?
-
-      anonymous = data[:anonymous]
-      anonymous_error = LaunchDarkly::Impl::Context.validate_anonymous(anonymous, true)
-      return create_invalid_context(anonymous_error) unless anonymous_error.nil?
-
-      custom = data[:custom]
-      unless custom.nil? || custom.is_a?(Hash)
-        return create_invalid_context(ERR_CUSTOM_NON_HASH)
-      end
-
-      # We only need to create an attribute hash if one of these keys exist.
-      # Everything else is stored in dedicated instance variables.
-      attributes = custom.clone
-      data.each do |k, v|
-        case k
-        when :ip, :email, :avatar, :firstName, :lastName, :country
-          attributes ||= {}
-          attributes[k] = v.clone
-        else
-          next
-        end
-      end
-
-      private_attributes = data[:privateAttributeNames]
-      if private_attributes && !private_attributes.is_a?(Array)
-        return create_invalid_context(ERR_PRIVATE_NON_ARRAY)
-      end
-
-      new(key.to_s, key.to_s, KIND_DEFAULT, name, anonymous, attributes, private_attributes)
-    end
-
     #
     # @param data [Hash]
     # @param kind [String]

data/lib/ldclient-rb/evaluation_detail.rb

@@ -1,4 +1,3 @@
-
 module LaunchDarkly
 # An object returned by {LDClient#variation_detail}, combining the result of a flag evaluation with
   # an explanation of how it was calculated.
@@ -13,6 +12,7 @@ module LaunchDarkly
     def initialize(value, variation_index, reason)
       raise ArgumentError.new("variation_index must be a number") if !variation_index.nil? && !(variation_index.is_a? Numeric)
       raise ArgumentError.new("reason must be an EvaluationReason") unless reason.is_a? EvaluationReason
+
       @value = value
       @variation_index = variation_index
       @reason = reason
@@ -100,6 +100,10 @@ module LaunchDarkly
     # a rule specified a nonexistent  variation. An error message will always be logged in this case.
     ERROR_MALFORMED_FLAG = :MALFORMED_FLAG
 
+    # Value for {#error_kind} indicating that there was an inconsistency between the expected type of the flag, and the
+    # actual type of the variation evaluated.
+    ERROR_WRONG_TYPE = :WRONG_TYPE
+
     # Value for {#error_kind} indicating that the caller passed `nil` for the context parameter, or the
     # context was invalid.
     ERROR_USER_NOT_SPECIFIED = :USER_NOT_SPECIFIED

data/lib/ldclient-rb/events.rb

@@ -40,7 +40,9 @@ module LaunchDarkly
       default = nil,
       track_events = false,
       debug_until = nil,
-      prereq_of = nil
+      prereq_of = nil,
+      sampling_ratio = nil,
+      exclude_from_summaries = false
     )
     end
 
@@ -55,6 +57,9 @@ module LaunchDarkly
     )
     end
 
+    def record_migration_op_event(event)
+    end
+
     def flush
     end
 
@@ -153,10 +158,12 @@ module LaunchDarkly
       default = nil,
       track_events = false,
       debug_until = nil,
-      prereq_of = nil
+      prereq_of = nil,
+      sampling_ratio = nil,
+      exclude_from_summaries = false
     )
       post_to_inbox(LaunchDarkly::Impl::EvalEvent.new(timestamp, context, key, version, variation, value, reason,
-        default, track_events, debug_until, prereq_of))
+        default, track_events, debug_until, prereq_of, sampling_ratio, exclude_from_summaries))
     end
 
     def record_identify_event(context)
@@ -167,6 +174,10 @@ module LaunchDarkly
       post_to_inbox(LaunchDarkly::Impl::CustomEvent.new(timestamp, context, key, data, metric_value))
     end
 
+    def record_migration_op_event(event)
+      post_to_inbox(event)
+    end
+
     def flush
       # flush is done asynchronously
       post_to_inbox(FlushMessage.new)
@@ -220,6 +231,7 @@ module LaunchDarkly
       @config = config
       @diagnostic_accumulator = config.diagnostic_opt_out? ? nil : diagnostic_accumulator
       @event_sender = event_sender
+      @sampler = LaunchDarkly::Impl::Sampler.new(Random.new)
 
       @context_keys = SimpleLRUCacheSet.new(config.context_keys_capacity)
       @formatter = EventOutputFormatter.new(config)
@@ -292,7 +304,7 @@ module LaunchDarkly
       return if @disabled.value
 
       # Always record the event in the summary.
-      outbox.add_to_summary(event)
+      outbox.add_to_summary(event) unless event.exclude_from_summaries
 
       # Decide whether to add the event to the payload. Feature events may be added twice, once for
       # the event (if tracked) and once for debugging.
@@ -309,12 +321,12 @@ module LaunchDarkly
 
       # For each context we haven't seen before, we add an index event - unless this is already
       # an identify event for that context.
-      if !event.context.nil? && !notice_context(event.context) && !event.is_a?(LaunchDarkly::Impl::IdentifyEvent)
+      if !event.context.nil? && !notice_context(event.context) && !event.is_a?(LaunchDarkly::Impl::IdentifyEvent) && !event.is_a?(LaunchDarkly::Impl::MigrationOpEvent)
         outbox.add_event(LaunchDarkly::Impl::IndexEvent.new(event.timestamp, event.context))
       end
 
-      outbox.add_event(event) if will_add_full_event
-      outbox.add_event(debug_event) unless debug_event.nil?
+      outbox.add_event(event) if will_add_full_event && @sampler.sample(event.sampling_ratio.nil? ? 1 : event.sampling_ratio)
+      outbox.add_event(debug_event) if !debug_event.nil? && @sampler.sample(event.sampling_ratio.nil? ? 1 : event.sampling_ratio)
     end
 
     #
@@ -443,6 +455,7 @@ module LaunchDarkly
     CUSTOM_KIND = 'custom'
     INDEX_KIND = 'index'
     DEBUG_KIND = 'debug'
+    MIGRATION_OP_KIND = 'migration_op'
     SUMMARY_KIND = 'summary'
 
     def initialize(config)
@@ -476,6 +489,64 @@ module LaunchDarkly
         out[:reason] = event.reason unless event.reason.nil?
         out
 
+      when LaunchDarkly::Impl::MigrationOpEvent
+        out = {
+          kind: MIGRATION_OP_KIND,
+          creationDate: event.timestamp,
+          contextKeys: event.context.keys,
+          operation: event.operation.to_s,
+          evaluation: {
+            key: event.key,
+            value: event.evaluation.value,
+          },
+        }
+
+        out[:evaluation][:version] = event.version unless event.version.nil?
+        out[:evaluation][:default] = event.default unless event.default.nil?
+        out[:evaluation][:variation] = event.evaluation.variation_index unless event.evaluation.variation_index.nil?
+        out[:evaluation][:reason] = event.evaluation.reason unless event.evaluation.reason.nil?
+        out[:samplingRatio] = event.sampling_ratio unless event.sampling_ratio.nil? || event.sampling_ratio == 1
+
+        measurements = []
+
+        unless event.invoked.empty?
+          measurements << {
+            "key": "invoked",
+            "values": event.invoked.map { |origin| [origin, true] }.to_h,
+          }
+        end
+
+        unless event.consistency_check.nil?
+          measurement = {
+            "key": "consistent",
+            "value": event.consistency_check,
+          }
+
+          unless event.consistency_check_ratio.nil? || event.consistency_check_ratio == 1
+            measurement[:samplingRatio] = event.consistency_check_ratio
+          end
+
+          measurements << measurement
+        end
+
+
+        unless event.latencies.empty?
+          measurements << {
+            "key": "latency_ms",
+            "values": event.latencies,
+          }
+        end
+
+        unless event.errors.empty?
+          measurements << {
+            "key": "error",
+            "values": event.errors.map { |origin| [origin, true] }.to_h,
+          }
+        end
+        out[:measurements] = measurements unless measurements.empty?
+
+        out
+
       when LaunchDarkly::Impl::IdentifyEvent
         {
           kind: IDENTIFY_KIND,

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

@@ -23,7 +23,7 @@ module LaunchDarkly
         @last_status = nil
 
         unless @store.nil?
-          @cache = ExpiringCache.new(big_segments_config.user_cache_size, big_segments_config.user_cache_time)
+          @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

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

@@ -142,4 +142,4 @@ module LaunchDarkly
       end
     end
   end
-end
+end

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)