launchdarkly-server-sdk 8.11.2 → 8.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0821343a2375748e37f95a7a43016973a21c6027d9f0b3c402074ae9859c91b
-  data.tar.gz: d285b359f653ed6ea74d9b6fedd8ff0388347e24d986f72866c226b24516ed38
+  metadata.gz: e1fa7eda2bd9b051a44200581ef0467e375d74fbeccd23f94838149b01bcebb3
+  data.tar.gz: 6d1d16653bdb132f4348cc3b97e22ea7dbf45af1721a96e89221d10d46e7384e
 SHA512:
-  metadata.gz: e9937a4267ca69970169b66564e1fdfff11e7ceefa57462a0f4f11830aa6ef8cefc34dbcb83e62910759c14ba3120d53c20ba7436d87f21aff0a63ad2996ff8f
-  data.tar.gz: 6726a6c125e3253c691d8c566e46ef17dc29cfb76407e79232f9b213580bfc53665bf1968fc60b48641a93276b8b4bd6c2bdabce77bda70f4575df2e5b61ec11
+  metadata.gz: f938280053627372c37235543a9204585e4c4550ec029c726d0fde1187b44d8c1351deb80722504de3f88f373ec7217c66f181169c58fb05609683c7dfbf6f77
+  data.tar.gz: bec0a20471ce7242ff8eeb6b0e535e9218492fb4caa83b7bc70d2769242ed96cb0dcf2fc56449c8a6e9380675e594ee898b3eb2aa0c896bb11c0fd1eb116219a

data/lib/ldclient-rb/config.rb

@@ -1,4 +1,5 @@
 require "logger"
+require "ldclient-rb/impl/cache_store"
 
 module LaunchDarkly
   #
@@ -44,6 +45,7 @@ module LaunchDarkly
     # @option opts [Hash] :application See {#application}
     # @option opts [String] :payload_filter_key See {#payload_filter_key}
     # @option opts [Boolean] :omit_anonymous_contexts See {#omit_anonymous_contexts}
+    # @option opts [DataSystemConfig] :datasystem_config See {#datasystem_config}
     # @option hooks [Array<Interfaces::Hooks::Hook]
     # @option plugins [Array<Interfaces::Plugins::Plugin]
     #
@@ -82,6 +84,7 @@ module LaunchDarkly
       @hooks = (opts[:hooks] || []).keep_if { |hook| hook.is_a? Interfaces::Hooks::Hook }
       @plugins = (opts[:plugins] || []).keep_if { |plugin| plugin.is_a? Interfaces::Plugins::Plugin }
       @omit_anonymous_contexts = opts.has_key?(:omit_anonymous_contexts) && opts[:omit_anonymous_contexts]
+      @datasystem_config = opts[:datasystem_config]
       @data_source_update_sink = nil
       @instance_id = nil
     end
@@ -96,7 +99,7 @@ module LaunchDarkly
     # Custom data source implementations should integrate with this sink if
     # they want to provide support for data source status listeners.
     #
-    # @private
+    # @api private
     #
     attr_accessor :data_source_update_sink
 
@@ -108,7 +111,7 @@ module LaunchDarkly
     # property is not supported; it is temporarily being exposed to maintain
     # backwards compatibility while the SDK structure is updated.
     #
-    # @private
+    # @api private
     #
     attr_accessor :instance_id
 
@@ -430,6 +433,15 @@ module LaunchDarkly
     #
     attr_reader :omit_anonymous_contexts
 
+    #
+    # Configuration for the upcoming enhanced data system design. This is
+    # experimental and should not be set without direction from LaunchDarkly
+    # support.
+    #
+    # @return [DataSystemConfig, nil]
+    #
+    attr_reader :datasystem_config
+
 
     #
     # The default LaunchDarkly client configuration. This configuration sets
@@ -477,7 +489,7 @@ module LaunchDarkly
     # @return [Object] the Rails cache if in Rails, or a simple in-memory implementation otherwise
     #
     def self.default_cache_store
-      defined?(Rails) && Rails.respond_to?(:cache) ? Rails.cache : ThreadSafeMemoryStore.new
+      defined?(Rails) && Rails.respond_to?(:cache) ? Rails.cache : Impl::ThreadSafeMemoryStore.new
     end
 
     #
@@ -678,4 +690,55 @@ module LaunchDarkly
     # @return [Float]
     attr_reader :stale_after
   end
+
+  #
+  # Configuration for LaunchDarkly's data acquisition strategy.
+  #
+  # This is not stable and is not subject to any backwards compatibility guarantees
+  # or semantic versioning. It is not suitable for production usage.
+  #
+  class DataSystemConfig
+    #
+    # @param initializers [Array<Proc(Config) => LaunchDarkly::Interfaces::DataSystem::Initializer>, nil] The (optional) array of builder procs
+    # @param primary_synchronizer [Proc(Config) => LaunchDarkly::Interfaces::DataSystem::Synchronizer, nil] The (optional) builder proc for primary synchronizer
+    # @param secondary_synchronizer [Proc(Config) => LaunchDarkly::Interfaces::DataSystem::Synchronizer, nil] The (optional) builder proc for secondary synchronizer
+    # @param data_store_mode [Symbol] The (optional) data store mode
+    # @param data_store [LaunchDarkly::Interfaces::FeatureStore, nil] The (optional) data store
+    # @param fdv1_fallback_synchronizer [Proc(Config) => LaunchDarkly::Interfaces::DataSystem::Synchronizer, nil]
+    #   The (optional) builder proc for FDv1-compatible fallback synchronizer
+    #
+    def initialize(initializers: nil, primary_synchronizer: nil, secondary_synchronizer: nil,
+                   data_store_mode: LaunchDarkly::Interfaces::DataSystem::DataStoreMode::READ_ONLY, data_store: nil, fdv1_fallback_synchronizer: nil)
+      @initializers = initializers
+      @primary_synchronizer = primary_synchronizer
+      @secondary_synchronizer = secondary_synchronizer
+      @data_store_mode = data_store_mode
+      @data_store = data_store
+      @fdv1_fallback_synchronizer = fdv1_fallback_synchronizer
+    end
+
+    # The initializers for the data system. Each proc takes sdk_key and Config and returns an Initializer.
+    # @return [Array<Proc(String, Config) => LaunchDarkly::Interfaces::DataSystem::Initializer>, nil]
+    attr_reader :initializers
+
+    # The primary synchronizer builder. Takes sdk_key and Config and returns a Synchronizer.
+    # @return [Proc(String, Config) => LaunchDarkly::Interfaces::DataSystem::Synchronizer, nil]
+    attr_reader :primary_synchronizer
+
+    # The secondary synchronizer builder. Takes sdk_key and Config and returns a Synchronizer.
+    # @return [Proc(String, Config) => LaunchDarkly::Interfaces::DataSystem::Synchronizer, nil]
+    attr_reader :secondary_synchronizer
+
+    # The data store mode.
+    # @return [Symbol]
+    attr_reader :data_store_mode
+
+    # The data store.
+    # @return [LaunchDarkly::Interfaces::FeatureStore, nil]
+    attr_reader :data_store
+
+    # The FDv1-compatible fallback synchronizer builder. Takes sdk_key and Config and returns a Synchronizer.
+    # @return [Proc(String, Config) => LaunchDarkly::Interfaces::DataSystem::Synchronizer, nil]
+    attr_reader :fdv1_fallback_synchronizer
+  end
 end

data/lib/ldclient-rb/context.rb

@@ -48,7 +48,7 @@ module LaunchDarkly
     attr_reader :error
 
     #
-    # @private
+    # @api private
     # @param key [String, nil]
     # @param fully_qualified_key [String, nil]
     # @param kind [String, nil]

data/lib/ldclient-rb/data_system.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'ldclient-rb/interfaces/data_system'
+require 'ldclient-rb/config'
+require 'ldclient-rb/impl/data_system/polling'
+
+module LaunchDarkly
+  #
+  # Configuration for LaunchDarkly's data acquisition strategy.
+  #
+  # This module provides factory methods for creating data system configurations.
+  #
+  module DataSystem
+    #
+    # Builder for the data system configuration.
+    #
+    class ConfigBuilder
+      def initialize
+        @initializers = nil
+        @primary_synchronizer = nil
+        @secondary_synchronizer = nil
+        @fdv1_fallback_synchronizer = nil
+        @data_store_mode = LaunchDarkly::Interfaces::DataSystem::DataStoreMode::READ_ONLY
+        @data_store = nil
+      end
+
+      #
+      # Sets the initializers for the data system.
+      #
+      # @param initializers [Array<Proc(String, Config) => LaunchDarkly::Interfaces::DataSystem::Initializer>]
+      #   Array of builder procs that take sdk_key and Config and return an Initializer
+      # @return [ConfigBuilder] self for chaining
+      #
+      def initializers(initializers)
+        @initializers = initializers
+        self
+      end
+
+      #
+      # Sets the synchronizers for the data system.
+      #
+      # @param primary [Proc(String, Config) => LaunchDarkly::Interfaces::DataSystem::Synchronizer] Builder proc that takes sdk_key and Config and returns the primary Synchronizer
+      # @param secondary [Proc(String, Config) => LaunchDarkly::Interfaces::DataSystem::Synchronizer, nil]
+      #   Builder proc that takes sdk_key and Config and returns the secondary Synchronizer
+      # @return [ConfigBuilder] self for chaining
+      #
+      def synchronizers(primary, secondary = nil)
+        @primary_synchronizer = primary
+        @secondary_synchronizer = secondary
+        self
+      end
+
+      #
+      # Configures the SDK with a fallback synchronizer that is compatible with
+      # the Flag Delivery v1 API.
+      #
+      # @param fallback [Proc(String, Config) => LaunchDarkly::Interfaces::DataSystem::Synchronizer]
+      #   Builder proc that takes sdk_key and Config and returns the fallback Synchronizer
+      # @return [ConfigBuilder] self for chaining
+      #
+      def fdv1_compatible_synchronizer(fallback)
+        @fdv1_fallback_synchronizer = fallback
+        self
+      end
+
+      #
+      # Sets the data store configuration for the data system.
+      #
+      # @param data_store [LaunchDarkly::Interfaces::FeatureStore] The data store
+      # @param store_mode [Symbol] The store mode
+      # @return [ConfigBuilder] self for chaining
+      #
+      def data_store(data_store, store_mode)
+        @data_store = data_store
+        @data_store_mode = store_mode
+        self
+      end
+
+      #
+      # Builds the data system configuration.
+      #
+      # @return [DataSystemConfig]
+      # @raise [ArgumentError] if configuration is invalid
+      #
+      def build
+        if @secondary_synchronizer && @primary_synchronizer.nil?
+          raise ArgumentError, "Primary synchronizer must be set if secondary is set"
+        end
+
+        DataSystemConfig.new(
+          initializers: @initializers,
+          primary_synchronizer: @primary_synchronizer,
+          secondary_synchronizer: @secondary_synchronizer,
+          data_store_mode: @data_store_mode,
+          data_store: @data_store,
+          fdv1_fallback_synchronizer: @fdv1_fallback_synchronizer
+        )
+      end
+    end
+
+    #
+    # Returns a builder proc for creating a polling data source.
+    # This is a building block that can be used with {ConfigBuilder#initializers}
+    # or {ConfigBuilder#synchronizers} to create custom data system configurations.
+    #
+    # @return [Proc] A proc that takes (sdk_key, config) and returns a polling data source
+    #
+    def self.polling_ds_builder
+      lambda do |sdk_key, config|
+        LaunchDarkly::Impl::DataSystem::PollingDataSourceBuilder.new(sdk_key, config).build
+      end
+    end
+
+    #
+    # Returns a builder proc for creating an FDv1 fallback polling data source.
+    # This is a building block that can be used with {ConfigBuilder#fdv1_compatible_synchronizer}
+    # to provide FDv1 compatibility in custom data system configurations.
+    #
+    # @return [Proc] A proc that takes (sdk_key, config) and returns an FDv1 polling data source
+    #
+    def self.fdv1_fallback_ds_builder
+      lambda do |sdk_key, config|
+        LaunchDarkly::Impl::DataSystem::FDv1PollingDataSourceBuilder.new(sdk_key, config).build
+      end
+    end
+
+    #
+    # Returns a builder proc for creating a streaming data source.
+    # This is a building block that can be used with {ConfigBuilder#synchronizers}
+    # to create custom data system configurations.
+    #
+    # @return [Proc] A proc that takes (sdk_key, config) and returns a streaming data source
+    #
+    def self.streaming_ds_builder
+      # TODO(fdv2): Implement streaming data source builder
+      lambda do |_sdk_key, _config|
+        raise NotImplementedError, "Streaming data source not yet implemented for FDv2"
+      end
+    end
+
+    #
+    # Default is LaunchDarkly's recommended flag data acquisition strategy.
+    #
+    # Currently, it operates a two-phase method for obtaining data: first, it
+    # requests data from LaunchDarkly's global CDN. Then, it initiates a
+    # streaming connection to LaunchDarkly's Flag Delivery services to
+    # receive real-time updates.
+    #
+    # If the streaming connection is interrupted for an extended period of
+    # time, the SDK will automatically fall back to polling the global CDN
+    # for updates.
+    #
+    # @return [ConfigBuilder]
+    #
+    def self.default
+      polling_builder = polling_ds_builder
+      streaming_builder = streaming_ds_builder
+      fallback = fdv1_fallback_ds_builder
+
+      builder = ConfigBuilder.new
+      builder.initializers([polling_builder])
+      builder.synchronizers(streaming_builder, polling_builder)
+      builder.fdv1_compatible_synchronizer(fallback)
+
+      builder
+    end
+
+    #
+    # Streaming configures the SDK to efficiently stream flag/segment data
+    # in the background, allowing evaluations to operate on the latest data
+    # with no additional latency.
+    #
+    # @return [ConfigBuilder]
+    #
+    def self.streaming
+      streaming_builder = streaming_ds_builder
+      fallback = fdv1_fallback_ds_builder
+
+      builder = ConfigBuilder.new
+      builder.synchronizers(streaming_builder)
+      builder.fdv1_compatible_synchronizer(fallback)
+
+      builder
+    end
+
+    #
+    # Polling configures the SDK to regularly poll an endpoint for
+    # flag/segment data in the background. This is less efficient than
+    # streaming, but may be necessary in some network environments.
+    #
+    # @return [ConfigBuilder]
+    #
+    def self.polling
+      polling_builder = polling_ds_builder
+      fallback = fdv1_fallback_ds_builder
+
+      builder = ConfigBuilder.new
+      builder.synchronizers(polling_builder)
+      builder.fdv1_compatible_synchronizer(fallback)
+
+      builder
+    end
+
+    #
+    # Custom returns a builder suitable for creating a custom data
+    # acquisition strategy. You may configure how the SDK uses a Persistent
+    # Store, how the SDK obtains an initial set of data, and how the SDK
+    # keeps data up-to-date.
+    #
+    # @return [ConfigBuilder]
+    #
+    def self.custom
+      ConfigBuilder.new
+    end
+
+    #
+    # Daemon configures the SDK to read from a persistent store integration
+    # that is populated by Relay Proxy or other SDKs. The SDK will not connect
+    # to LaunchDarkly. In this mode, the SDK never writes to the data store.
+    #
+    # @param store [Object] The persistent store
+    # @return [ConfigBuilder]
+    #
+    def self.daemon(store)
+      custom.data_store(store, LaunchDarkly::Interfaces::DataSystem::DataStoreMode::READ_ONLY)
+    end
+
+    #
+    # PersistentStore is similar to default, with the addition of a persistent
+    # store integration. Before data has arrived from LaunchDarkly, the SDK is
+    # able to evaluate flags using data from the persistent store. Once fresh
+    # data is available, the SDK will no longer read from the persistent store,
+    # although it will keep it up-to-date.
+    #
+    # @param store [Object] The persistent store
+    # @return [ConfigBuilder]
+    #
+    def self.persistent_store(store)
+      default.data_store(store, LaunchDarkly::Interfaces::DataSystem::DataStoreMode::READ_WRITE)
+    end
+  end
+end
+

data/lib/ldclient-rb/events.rb

@@ -3,6 +3,8 @@ require "ldclient-rb/impl/diagnostic_events"
 require "ldclient-rb/impl/event_sender"
 require "ldclient-rb/impl/event_summarizer"
 require "ldclient-rb/impl/event_types"
+require "ldclient-rb/impl/non_blocking_thread_pool"
+require "ldclient-rb/impl/simple_lru_cache"
 require "ldclient-rb/impl/util"
 
 require "concurrent"
@@ -60,6 +62,19 @@ module LaunchDarkly
     def record_migration_op_event(event)
     end
 
+    #
+    # Tells the event processor that all pending analytics events should be delivered as soon as possible.
+    #
+    # When the LaunchDarkly client generates analytics events (from {LaunchDarkly::LDClient#variation},
+    # {LaunchDarkly::LDClient#variation_detail}, {LaunchDarkly::LDClient#identify}, or
+    # {LaunchDarkly::LDClient#track}), they are queued on a worker thread. The event thread normally
+    # sends all queued events to LaunchDarkly at regular intervals, controlled by the
+    # {LaunchDarkly::Config#flush_interval} option. Calling `flush` triggers a send without waiting
+    # for the next interval.
+    #
+    # Flushing is asynchronous, so this method will return before it is complete. However, if you
+    # call {LaunchDarkly::LDClient#close}, events are guaranteed to be sent before that method returns.
+    #
     def flush
     end
 
@@ -70,24 +85,24 @@ module LaunchDarkly
   MAX_FLUSH_WORKERS = 5
   private_constant :MAX_FLUSH_WORKERS
 
-  # @private
+  # @api private
   class NullEventProcessor
     include EventProcessorMethods
   end
 
-  # @private
+  # @api private
   class FlushMessage
   end
 
-  # @private
+  # @api private
   class FlushContextsMessage
   end
 
-  # @private
+  # @api private
   class DiagnosticEventMessage
   end
 
-  # @private
+  # @api private
   class SynchronousMessage
     def initialize
       @reply = Concurrent::Semaphore.new(0)
@@ -102,15 +117,15 @@ module LaunchDarkly
     end
   end
 
-  # @private
+  # @api private
   class TestSyncMessage < SynchronousMessage
   end
 
-  # @private
+  # @api private
   class StopMessage < SynchronousMessage
   end
 
-  # @private
+  # @api private
   class EventProcessor
     include EventProcessorMethods
 
@@ -141,7 +156,7 @@ module LaunchDarkly
       @inbox_full = Concurrent::AtomicBoolean.new(false)
 
       event_sender = (test_properties || {})[:event_sender] ||
-        Impl::EventSender.new(sdk_key, config, client || Util.new_http_client(config.events_uri, config))
+        Impl::EventSender.new(sdk_key, config, client || Impl::Util.new_http_client(config.events_uri, config))
 
       @timestamp_fn = (test_properties || {})[:timestamp_fn] || proc { Impl::Util.current_time_millis }
       @omit_anonymous_contexts = config.omit_anonymous_contexts
@@ -226,7 +241,7 @@ module LaunchDarkly
     end
   end
 
-  # @private
+  # @api private
   class EventDispatcher
     def initialize(inbox, sdk_key, config, diagnostic_accumulator, event_sender)
       @sdk_key = sdk_key
@@ -235,7 +250,7 @@ module LaunchDarkly
       @event_sender = event_sender
       @sampler = LaunchDarkly::Impl::Sampler.new(Random.new)
 
-      @context_keys = SimpleLRUCacheSet.new(config.context_keys_capacity)
+      @context_keys = Impl::SimpleLRUCacheSet.new(config.context_keys_capacity)
       @formatter = EventOutputFormatter.new(config)
       @disabled = Concurrent::AtomicBoolean.new(false)
       @last_known_past_time = Concurrent::AtomicReference.new(0)
@@ -243,10 +258,10 @@ module LaunchDarkly
       @events_in_last_batch = 0
 
       outbox = EventBuffer.new(config.capacity, config.logger)
-      flush_workers = NonBlockingThreadPool.new(MAX_FLUSH_WORKERS, 'LD/EventDispatcher/FlushWorkers')
+      flush_workers = Impl::NonBlockingThreadPool.new(MAX_FLUSH_WORKERS, 'LD/EventDispatcher/FlushWorkers')
 
       if !@diagnostic_accumulator.nil?
-        diagnostic_event_workers = NonBlockingThreadPool.new(1, 'LD/EventDispatcher/DiagnosticEventWorkers')
+        diagnostic_event_workers = Impl::NonBlockingThreadPool.new(1, 'LD/EventDispatcher/DiagnosticEventWorkers')
         init_event = @diagnostic_accumulator.create_init_event(config)
         send_diagnostic_event(init_event, diagnostic_event_workers)
       else
@@ -281,7 +296,7 @@ module LaunchDarkly
             dispatch_event(message, outbox)
           end
         rescue => e
-          Util.log_exception(@config.logger, "Unexpected error in event processor", e)
+          Impl::Util.log_exception(@config.logger, "Unexpected error in event processor", e)
         end
       end
     end
@@ -383,7 +398,7 @@ module LaunchDarkly
               @last_known_past_time.value = (result.time_from_server.to_f * 1000).to_i
             end
           rescue => e
-            Util.log_exception(@config.logger, "Unexpected error in event processor", e)
+            Impl::Util.log_exception(@config.logger, "Unexpected error in event processor", e)
           end
         end
         outbox.clear if success # Reset our internal state, these events now belong to the flush worker
@@ -408,16 +423,16 @@ module LaunchDarkly
         begin
           @event_sender.send_event_data(event.to_json, "diagnostic event", true)
         rescue => e
-          Util.log_exception(@config.logger, "Unexpected error in event processor", e)
+          Impl::Util.log_exception(@config.logger, "Unexpected error in event processor", e)
         end
       end
     end
   end
 
-  # @private
+  # @api private
   FlushPayload = Struct.new(:events, :summary)
 
-  # @private
+  # @api private
   class EventBuffer
     def initialize(capacity, logger)
       @capacity = capacity
@@ -461,7 +476,7 @@ module LaunchDarkly
     end
   end
 
-  # @private
+  # @api private
   class EventOutputFormatter
     FEATURE_KIND = 'feature'
     IDENTIFY_KIND = 'identify'

data/lib/ldclient-rb/flags_state.rb

@@ -15,7 +15,7 @@ module LaunchDarkly
     end
 
     # Used internally to build the state map.
-    # @private
+    # @api private
     def add_flag(flag_state, with_reasons, details_only_if_tracked)
       key = flag_state[:key]
       @flag_values[key] = flag_state[:value]

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

@@ -1,8 +1,8 @@
 require "ldclient-rb/config"
-require "ldclient-rb/expiring_cache"
+require "ldclient-rb/impl/expiring_cache"
 require "ldclient-rb/impl/repeating_task"
+require "ldclient-rb/impl/util"
 require "ldclient-rb/interfaces"
-require "ldclient-rb/util"
 
 require "digest"
 
@@ -45,7 +45,7 @@ module LaunchDarkly
             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)
+            Impl::Util.log_exception(@logger, "Big Segment store membership query returned error", e)
             return BigSegmentMembershipResult.new(nil, BigSegmentsStatus::STORE_ERROR)
           end
         end
@@ -67,7 +67,7 @@ module LaunchDarkly
             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)
+            Impl::Util.log_exception(@logger, "Big Segment store status query returned error", e)
           end
         end
         @last_status = new_status

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

@@ -0,0 +1,44 @@
+require "concurrent/map"
+
+module LaunchDarkly
+  module Impl
+    # A thread-safe in-memory store that uses the same semantics that Faraday would expect, although we
+    # no longer use Faraday. This is used by Requestor, when we are not in a Rails environment.
+    class ThreadSafeMemoryStore
+      #
+      # Default constructor
+      #
+      # @return [ThreadSafeMemoryStore] a new store
+      def initialize
+        @cache = Concurrent::Map.new
+      end
+
+      #
+      # Read a value from the cache
+      # @param key [Object] the cache key
+      #
+      # @return [Object] the cache value
+      def read(key)
+        @cache[key]
+      end
+
+      #
+      # Store a value in the cache
+      # @param key [Object] the cache key
+      # @param value [Object] the value to associate with the key
+      #
+      # @return [Object] the value
+      def write(key, value)
+        @cache[key] = value
+      end
+
+      #
+      # Delete a value in the cache
+      # @param key [Object] the cache key
+      def delete(key)
+        @cache.delete(key)
+      end
+    end
+  end
+end
+