launchdarkly-server-sdk 8.11.2 → 8.11.3

data/lib/ldclient-rb/impl/data_system/protocolv2.rb

@@ -0,0 +1,264 @@
+require 'json'
+
+module LaunchDarkly
+  module Impl
+    module DataSystem
+      module ProtocolV2
+        #
+        # This module contains the protocol definitions and data types for the
+        # LaunchDarkly data system version 2 (FDv2).
+        #
+
+        #
+        # DeleteObject specifies the deletion of a particular object.
+        #
+        # This type is not stable, and not subject to any backwards
+        # compatibility guarantees or semantic versioning. It is not suitable for production usage.
+        #
+        class DeleteObject
+          # @return [Integer] The version
+          attr_reader :version
+
+          # @return [String] The object kind ({LaunchDarkly::Interfaces::DataSystem::ObjectKind})
+          attr_reader :kind
+
+          # @return [String] The key
+          attr_reader :key
+
+          #
+          # @param version [Integer] The version
+          # @param kind [String] The object kind ({LaunchDarkly::Interfaces::DataSystem::ObjectKind})
+          # @param key [String] The key
+          #
+          def initialize(version:, kind:, key:)
+            @version = version
+            @kind = kind
+            @key = key
+          end
+
+          #
+          # Returns the event name.
+          #
+          # @return [String]
+          #
+          def name
+            LaunchDarkly::Interfaces::DataSystem::EventName::DELETE_OBJECT
+          end
+
+          #
+          # Serializes the DeleteObject to a JSON-compatible hash.
+          #
+          # @return [Hash]
+          #
+          def to_h
+            {
+              version: @version,
+              kind: @kind,
+              key: @key,
+            }
+          end
+
+          #
+          # Deserializes a DeleteObject from a JSON-compatible hash.
+          #
+          # @param data [Hash] The hash representation
+          # @return [DeleteObject]
+          # @raise [ArgumentError] if required fields are missing
+          #
+          def self.from_h(data)
+            version = data[:version]
+            kind = data[:kind]
+            key = data[:key]
+
+            raise ArgumentError, "Missing required fields in DeleteObject" if version.nil? || kind.nil? || key.nil?
+
+            new(version: version, kind: kind, key: key)
+          end
+        end
+
+        #
+        # PutObject specifies the addition of a particular object with upsert semantics.
+        #
+        # This type is not stable, and not subject to any backwards
+        # compatibility guarantees or semantic versioning. It is not suitable for production usage.
+        #
+        class PutObject
+          # @return [Integer] The version
+          attr_reader :version
+
+          # @return [String] The object kind ({LaunchDarkly::Interfaces::DataSystem::ObjectKind})
+          attr_reader :kind
+
+          # @return [String] The key
+          attr_reader :key
+
+          # @return [Hash] The object data
+          attr_reader :object
+
+          #
+          # @param version [Integer] The version
+          # @param kind [String] The object kind ({LaunchDarkly::Interfaces::DataSystem::ObjectKind})
+          # @param key [String] The key
+          # @param object [Hash] The object data
+          #
+          def initialize(version:, kind:, key:, object:)
+            @version = version
+            @kind = kind
+            @key = key
+            @object = object
+          end
+
+          #
+          # Returns the event name.
+          #
+          # @return [String]
+          #
+          def name
+            LaunchDarkly::Interfaces::DataSystem::EventName::PUT_OBJECT
+          end
+
+          #
+          # Serializes the PutObject to a JSON-compatible hash.
+          #
+          # @return [Hash]
+          #
+          def to_h
+            {
+              version: @version,
+              kind: @kind,
+              key: @key,
+              object: @object,
+            }
+          end
+
+          #
+          # Deserializes a PutObject from a JSON-compatible hash.
+          #
+          # @param data [Hash] The hash representation
+          # @return [PutObject]
+          # @raise [ArgumentError] if required fields are missing
+          #
+          def self.from_h(data)
+            version = data[:version]
+            kind = data[:kind]
+            key = data[:key]
+            object_data = data[:object]
+
+            raise ArgumentError, "Missing required fields in PutObject" if version.nil? || kind.nil? || key.nil? || object_data.nil?
+
+            new(version: version, kind: kind, key: key, object: object_data)
+          end
+        end
+
+        #
+        # Goodbye represents a goodbye event.
+        #
+        # This type is not stable, and not subject to any backwards
+        # compatibility guarantees or semantic versioning. It is not suitable for production usage.
+        #
+        class Goodbye
+          # @return [String] The reason for goodbye
+          attr_reader :reason
+
+          # @return [Boolean] Whether the goodbye is silent
+          attr_reader :silent
+
+          # @return [Boolean] Whether this represents a catastrophic failure
+          attr_reader :catastrophe
+
+          #
+          # @param reason [String] The reason for goodbye
+          # @param silent [Boolean] Whether the goodbye is silent
+          # @param catastrophe [Boolean] Whether this represents a catastrophic failure
+          #
+          def initialize(reason:, silent:, catastrophe:)
+            @reason = reason
+            @silent = silent
+            @catastrophe = catastrophe
+          end
+
+          #
+          # Serializes the Goodbye to a JSON-compatible hash.
+          #
+          # @return [Hash]
+          #
+          def to_h
+            {
+              reason: @reason,
+              silent: @silent,
+              catastrophe: @catastrophe,
+            }
+          end
+
+          #
+          # Deserializes a Goodbye event from a JSON-compatible hash.
+          #
+          # @param data [Hash] The hash representation
+          # @return [Goodbye]
+          # @raise [ArgumentError] if required fields are missing
+          #
+          def self.from_h(data)
+            reason = data[:reason]
+            silent = data[:silent]
+            catastrophe = data[:catastrophe]
+
+            raise ArgumentError, "Missing required fields in Goodbye" if reason.nil? || silent.nil? || catastrophe.nil?
+
+            new(reason: reason, silent: silent, catastrophe: catastrophe)
+          end
+        end
+
+        #
+        # Error represents an error event.
+        #
+        # This type is not stable, and not subject to any backwards
+        # compatibility guarantees or semantic versioning. It is not suitable for production usage.
+        #
+        class Error
+          # @return [String] The payload ID
+          attr_reader :payload_id
+
+          # @return [String] The reason for the error
+          attr_reader :reason
+
+          #
+          # @param payload_id [String] The payload ID
+          # @param reason [String] The reason for the error
+          #
+          def initialize(payload_id:, reason:)
+            @payload_id = payload_id
+            @reason = reason
+          end
+
+          #
+          # Serializes the Error to a JSON-compatible hash.
+          #
+          # @return [Hash]
+          #
+          def to_h
+            {
+              payloadId: @payload_id,
+              reason: @reason,
+            }
+          end
+
+          #
+          # Deserializes an Error from a JSON-compatible hash.
+          #
+          # @param data [Hash] The hash representation
+          # @return [Error]
+          # @raise [ArgumentError] if required fields are missing
+          #
+          def self.from_h(data)
+            payload_id = data[:payloadId]
+            reason = data[:reason]
+
+            raise ArgumentError, "Missing required fields in Error" if payload_id.nil? || reason.nil?
+
+            new(payload_id: payload_id, reason: reason)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,12 @@
+require "ldclient-rb/impl/model/serialization"
+
 module LaunchDarkly
   module Impl
     class DependencyTracker
-      def initialize
+      def initialize(logger = nil)
         @from = {}
         @to = {}
+        @logger = logger
       end
 
       #
@@ -11,11 +14,11 @@ module LaunchDarkly
       #
       # @param from_kind [Object] the changed item's kind
       # @param from_key [String] the changed item's key
-      # @param from_item [Object] the changed item
+      # @param from_item [Object] the changed item (can be a Hash, model object, or nil)
       #
       def update_dependencies_from(from_kind, from_key, from_item)
         from_what = { kind: from_kind, key: from_key }
-        updated_dependencies = DependencyTracker.compute_dependencies_from(from_kind, from_item)
+        updated_dependencies = DependencyTracker.compute_dependencies_from(from_kind, from_item, @logger)
 
         old_dependency_set = @from[from_what]
         unless old_dependency_set.nil?
@@ -39,7 +42,7 @@ module LaunchDarkly
       def self.segment_keys_from_clauses(clauses)
         clauses.flat_map do |clause|
           if clause.op == :segmentMatch
-            clause.values.map { |value| {kind: LaunchDarkly::SEGMENTS, key: value }}
+            clause.values.map { |value| {kind: DataStore::SEGMENTS, key: value }}
           else
             []
           end
@@ -48,19 +51,28 @@ module LaunchDarkly
 
       #
       # @param from_kind [String]
-      # @param from_item [LaunchDarkly::Impl::Model::FeatureFlag, LaunchDarkly::Impl::Model::Segment]
+      # @param from_item [Hash, LaunchDarkly::Impl::Model::FeatureFlag, LaunchDarkly::Impl::Model::Segment, nil] the item (can be a hash, model object, or nil)
+      # @param logger [Logger, nil] optional logger for deserialization
       # @return [Set]
       #
-      def self.compute_dependencies_from(from_kind, from_item)
-        return Set.new if from_item.nil?
+      def self.compute_dependencies_from(from_kind, from_item, logger = nil)
+        # Check for deleted items (matches Python: from_item.get('deleted', False))
+        return Set.new if from_item.nil? || (from_item.is_a?(Hash) && from_item[:deleted])
+
+        # Deserialize hash to model object if needed (matches Python: from_kind.decode(from_item) if isinstance(from_item, dict))
+        from_item = if from_item.is_a?(Hash)
+                      LaunchDarkly::Impl::Model.deserialize(from_kind, from_item, logger)
+                    else
+                      from_item
+                    end
 
-        if from_kind == LaunchDarkly::FEATURES
+        if from_kind == DataStore::FEATURES && from_item.is_a?(LaunchDarkly::Impl::Model::FeatureFlag)
           prereq_keys = from_item.prerequisites.map { |prereq| {kind: from_kind, key: prereq.key} }
           segment_keys = from_item.rules.flat_map { |rule| DependencyTracker.segment_keys_from_clauses(rule.clauses) }
 
           results = Set.new(prereq_keys)
           results.merge(segment_keys)
-        elsif from_kind == LaunchDarkly::SEGMENTS
+        elsif from_kind == DataStore::SEGMENTS && from_item.is_a?(LaunchDarkly::Impl::Model::Segment)
           kind_and_keys  = from_item.rules.flat_map do |rule|
             DependencyTracker.segment_keys_from_clauses(rule.clauses)
           end

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

@@ -4,6 +4,7 @@ require "ldclient-rb/impl/evaluator_helpers"
 require "ldclient-rb/impl/evaluator_operators"
 require "ldclient-rb/impl/model/feature_flag"
 require "ldclient-rb/impl/model/segment"
+require "ldclient-rb/impl/util"
 
 module LaunchDarkly
   module Impl
@@ -152,11 +153,11 @@ module LaunchDarkly
         begin
           detail = eval_internal(flag, context, result, state)
         rescue EvaluationException => exn
-          LaunchDarkly::Util.log_exception(@logger, "Unexpected error when evaluating flag #{flag.key}", exn)
+          Impl::Util.log_exception(@logger, "Unexpected error when evaluating flag #{flag.key}", exn)
           result.detail = EvaluationDetail.new(nil, nil, EvaluationReason::error(exn.error_kind))
           return result, state
         rescue => exn
-          LaunchDarkly::Util.log_exception(@logger, "Unexpected error when evaluating flag #{flag.key}", exn)
+          Impl::Util.log_exception(@logger, "Unexpected error when evaluating flag #{flag.key}", exn)
           result.detail = EvaluationDetail.new(nil, nil, EvaluationReason::error(EvaluationReason::ERROR_EXCEPTION))
           return result, state
         end

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

@@ -1,4 +1,5 @@
 require "ldclient-rb/impl/unbounded_pool"
+require "ldclient-rb/impl/util"
 
 require "securerandom"
 require "http"
@@ -21,7 +22,7 @@ module LaunchDarkly
         @logger = config.logger
         @retry_interval = retry_interval
         @http_client_pool = UnboundedPool.new(
-          lambda { LaunchDarkly::Util.new_http_client(@config.events_uri, @config) },
+          lambda { Impl::Util.new_http_client(@config.events_uri, @config) },
           lambda { |client| client.close })
       end
 
@@ -81,9 +82,9 @@ module LaunchDarkly
               end
               return EventSenderResult.new(true, false, res_time)
             end
-            must_shutdown = !LaunchDarkly::Util.http_error_recoverable?(status)
+            must_shutdown = !Impl::Util.http_error_recoverable?(status)
             can_retry = !must_shutdown && attempt == 0
-            message = LaunchDarkly::Util.http_error_message(status, "event delivery", can_retry ? "will retry" : "some events were dropped")
+            message = Impl::Util.http_error_message(status, "event delivery", can_retry ? "will retry" : "some events were dropped")
             @logger.error { "[LDClient] #{message}" }
             if must_shutdown
               return EventSenderResult.new(false, true, nil)

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

@@ -0,0 +1,79 @@
+
+module LaunchDarkly
+  module Impl
+    # A thread-safe cache with maximum number of entries and TTL.
+    # Adapted from https://github.com/SamSaffron/lru_redux/blob/master/lib/lru_redux/ttl/cache.rb
+    # under MIT license with the following changes:
+    #   * made thread-safe
+    #   * removed many unused methods
+    #   * reading a key does not reset its expiration time, only writing
+    class ExpiringCache
+      def initialize(max_size, ttl)
+        @max_size = max_size
+        @ttl = ttl
+        @data_lru = {}
+        @data_ttl = {}
+        @lock = Mutex.new
+      end
+
+      def [](key)
+        @lock.synchronize do
+          ttl_evict
+          @data_lru[key]
+        end
+      end
+
+      def []=(key, val)
+        @lock.synchronize do
+          ttl_evict
+
+          @data_lru.delete(key)
+          @data_ttl.delete(key)
+
+          @data_lru[key] = val
+          @data_ttl[key] = Time.now.to_f
+
+          if @data_lru.size > @max_size
+            key, _ = @data_lru.first # hashes have a FIFO ordering in Ruby
+
+            @data_ttl.delete(key)
+            @data_lru.delete(key)
+          end
+
+          val
+        end
+      end
+
+      def delete(key)
+        @lock.synchronize do
+          ttl_evict
+
+          @data_lru.delete(key)
+          @data_ttl.delete(key)
+        end
+      end
+
+      def clear
+        @lock.synchronize do
+          @data_lru.clear
+          @data_ttl.clear
+        end
+      end
+
+      private
+
+      def ttl_evict
+        ttl_horizon = Time.now.to_f - @ttl
+        key, time = @data_ttl.first
+
+        until time.nil? || time > ttl_horizon
+          @data_ttl.delete(key)
+          @data_lru.delete(key)
+
+          key, time = @data_ttl.first
+        end
+      end
+    end
+  end
+end
+

data/lib/ldclient-rb/impl/integrations/file_data_source.rb

@@ -1,5 +1,5 @@
 require 'ldclient-rb/in_memory_store'
-require 'ldclient-rb/util'
+require 'ldclient-rb/impl/util'
 
 require 'concurrent/atomics'
 require 'json'
@@ -75,14 +75,14 @@ module LaunchDarkly
 
         def load_all
           all_data = {
-            FEATURES => {},
-            SEGMENTS => {},
+            Impl::DataStore::FEATURES => {},
+            Impl::DataStore::SEGMENTS => {},
           }
           @paths.each do |path|
             begin
               load_file(path, all_data)
             rescue => exn
-              LaunchDarkly::Util.log_exception(@logger, "Unable to load flag data from \"#{path}\"", exn)
+              Impl::Util.log_exception(@logger, "Unable to load flag data from \"#{path}\"", exn)
               @data_source_update_sink&.update_status(
                 LaunchDarkly::Interfaces::DataSource::Status::INTERRUPTED,
                 LaunchDarkly::Interfaces::DataSource::ErrorInfo.new(LaunchDarkly::Interfaces::DataSource::ErrorInfo::INVALID_DATA, 0, exn.to_s, Time.now)
@@ -105,14 +105,14 @@ module LaunchDarkly
           parsed = parse_content(File.read(path))
           (parsed[:flags] || {}).each do |key, flag|
             flag[:version] = version
-            add_item(all_data, FEATURES, flag)
+            add_item(all_data, Impl::DataStore::FEATURES, flag)
           end
           (parsed[:flagValues] || {}).each do |key, value|
-            add_item(all_data, FEATURES, make_flag_with_value(key.to_s, value, version))
+            add_item(all_data, Impl::DataStore::FEATURES, make_flag_with_value(key.to_s, value, version))
           end
           (parsed[:segments] || {}).each do |key, segment|
             segment[:version] = version
-            add_item(all_data, SEGMENTS, segment)
+            add_item(all_data, Impl::DataStore::SEGMENTS, segment)
           end
         end
 
@@ -212,7 +212,7 @@ module LaunchDarkly
                   end
                   reloader.call if changed
                 rescue => exn
-                  LaunchDarkly::Util.log_exception(logger, "Unexpected exception in FileDataSourcePoller", exn)
+                  Impl::Util.log_exception(logger, "Unexpected exception in FileDataSourcePoller", exn)
                 end
               end
             end