launchdarkly-server-sdk 8.11.2-java → 8.12.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d9e66b4d568f476ab565dfb9332242aa2f4cdc8b1feb741460945e6d9eadcb7
-  data.tar.gz: 6b2af234cec690fcf0ef3b8c82f1aa8f504f26472a24eb6798a41f37070b9121
+  metadata.gz: 1725cd5066df8e5072abb09c606e0bda2784fb2b16640cdf6b557a4119e2356c
+  data.tar.gz: efbba66e2391376fdd945a7e26bbb429e121a127b267b1f14d7685d7f2098a3f
 SHA512:
-  metadata.gz: a2e8a497b962919601f25bcd1aa66b3e5eddfa827b48437d42061f61ef81a4db94fddfd47efab499c5994775505943edad61008a84abc797889b6f46ad6d2243
-  data.tar.gz: 3af46adb331c7be348ae42efcc4e6a84704f25484f53a407d0f4e12ecc4cdaff110ad0a6a042cbff0ad1e69e09118de2bf3b3ecce5699aa42aa825e2b73fb2d0
+  metadata.gz: aecbdb3e07abe04e7993fd7967ee10376bbb9e19e70558858fd11b16ee5a5f56327005c1b76df628bf3a5d552b6462b3d2e57a1d8dee0477e18454a0d3e30a66
+  data.tar.gz: 56b6cfad3066a766c76fdf70ab3f204778bf208cfda316eed9ba8bbf5106c8ccceb7c3fa436d6af8045093b61d741791a087df78cca21d937c47bb2eb018cf14

data/lib/ldclient-rb/config.rb

@@ -1,4 +1,8 @@
 require "logger"
+require "ldclient-rb/impl/cache_store"
+require "ldclient-rb/impl/data_system/http_config_options"
+require "ldclient-rb/impl/data_system/polling"
+require "ldclient-rb/impl/data_system/streaming"
 
 module LaunchDarkly
   #
@@ -44,6 +48,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] :data_system_config See {#data_system_config}
     # @option hooks [Array<Interfaces::Hooks::Hook]
     # @option plugins [Array<Interfaces::Plugins::Plugin]
     #
@@ -82,6 +87,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]
+      @data_system_config = opts[:data_system_config]
       @data_source_update_sink = nil
       @instance_id = nil
     end
@@ -96,7 +102,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 +114,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 +436,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 :data_system_config
+
 
     #
     # The default LaunchDarkly client configuration. This configuration sets
@@ -453,7 +468,7 @@ module LaunchDarkly
     # @return [String] "https://sdk.launchdarkly.com"
     #
     def self.default_base_uri
-      "https://sdk.launchdarkly.com"
+      Impl::DataSystem::PollingDataSourceBuilder::DEFAULT_BASE_URI
     end
 
     #
@@ -461,7 +476,7 @@ module LaunchDarkly
     # @return [String] "https://stream.launchdarkly.com"
     #
     def self.default_stream_uri
-      "https://stream.launchdarkly.com"
+      Impl::DataSystem::StreamingDataSourceBuilder::DEFAULT_BASE_URI
     end
 
     #
@@ -477,7 +492,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
 
     #
@@ -493,7 +508,7 @@ module LaunchDarkly
     # @return [Float] 10
     #
     def self.default_read_timeout
-      10
+      Impl::DataSystem::HttpConfigOptions::DEFAULT_READ_TIMEOUT
     end
 
     #
@@ -501,7 +516,7 @@ module LaunchDarkly
     # @return [Float] 1
     #
     def self.default_initial_reconnect_delay
-      1
+      Impl::DataSystem::StreamingDataSourceBuilder::DEFAULT_INITIAL_RECONNECT_DELAY
     end
 
     #
@@ -509,7 +524,7 @@ module LaunchDarkly
     # @return [Float] 2
     #
     def self.default_connect_timeout
-      2
+      Impl::DataSystem::HttpConfigOptions::DEFAULT_CONNECT_TIMEOUT
     end
 
     #
@@ -563,7 +578,7 @@ module LaunchDarkly
     # @return [Float] 30
     #
     def self.default_poll_interval
-      30
+      Impl::DataSystem::PollingDataSourceBuilder::DEFAULT_POLL_INTERVAL
     end
 
     #
@@ -678,4 +693,49 @@ 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<#build(String, Config)>, nil] The (optional) array of builders
+    # @param synchronizers [Array<#build(String, Config)>, nil] The (optional) array of synchronizer builders
+    # @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 [#build(String, Config), nil]
+    #   The (optional) builder for FDv1-compatible fallback synchronizer
+    #
+    def initialize(initializers: nil, synchronizers: nil,
+                   data_store_mode: LaunchDarkly::Interfaces::DataSystem::DataStoreMode::READ_ONLY, data_store: nil, fdv1_fallback_synchronizer: nil)
+      @initializers = initializers
+      @synchronizers = synchronizers
+      @data_store_mode = data_store_mode
+      @data_store = data_store
+      @fdv1_fallback_synchronizer = fdv1_fallback_synchronizer
+    end
+
+    # The initializer builders for the data system. Each builder responds to build(sdk_key, config) and returns an Initializer.
+    # @return [Array<#build(String, Config)>, nil]
+    attr_reader :initializers
+
+    # The synchronizer builders for the data system. Each builder responds to build(sdk_key, config) and returns a Synchronizer.
+    # @return [Array<#build(String, Config)>, nil]
+    attr_reader :synchronizers
+
+    # 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. Responds to build(sdk_key, config) and returns a Synchronizer.
+    # @return [#build(String, Config), 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,227 @@
+# frozen_string_literal: true
+
+require 'ldclient-rb/interfaces/data_system'
+require 'ldclient-rb/config'
+require 'ldclient-rb/impl/data_system/polling'
+require 'ldclient-rb/impl/data_system/streaming'
+
+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
+        @synchronizers = 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<#build(String, Config)>]
+      #   Array of builders that respond to build(sdk_key, 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 synchronizers [Array<#build(String, Config)>]
+      #   Array of builders that respond to build(sdk_key, config) and return a Synchronizer
+      # @return [ConfigBuilder] self for chaining
+      #
+      def synchronizers(synchronizers)
+        @synchronizers = synchronizers
+        self
+      end
+
+      #
+      # Configures the SDK with a fallback synchronizer that is compatible with
+      # the Flag Delivery v1 API.
+      #
+      # @param fallback [#build(String, Config)] Builder that responds to build(sdk_key, 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]
+      #
+      def build
+        DataSystemConfig.new(
+          initializers: @initializers,
+          synchronizers: @synchronizers,
+          data_store_mode: @data_store_mode,
+          data_store: @data_store,
+          fdv1_fallback_synchronizer: @fdv1_fallback_synchronizer
+        )
+      end
+    end
+
+    #
+    # Returns a builder 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 [LaunchDarkly::Impl::DataSystem::PollingDataSourceBuilder]
+    #
+    def self.polling_ds_builder
+      LaunchDarkly::Impl::DataSystem::PollingDataSourceBuilder.new
+    end
+
+    #
+    # Returns a builder 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 [LaunchDarkly::Impl::DataSystem::FDv1PollingDataSourceBuilder]
+    #
+    def self.fdv1_fallback_ds_builder
+      LaunchDarkly::Impl::DataSystem::FDv1PollingDataSourceBuilder.new
+    end
+
+    #
+    # Returns a builder 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 [LaunchDarkly::Impl::DataSystem::StreamingDataSourceBuilder]
+    #
+    def self.streaming_ds_builder
+      LaunchDarkly::Impl::DataSystem::StreamingDataSourceBuilder.new
+    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)
 
       @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
+