determinator 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1b781c3d75121ccfad51eae6fa2faa71a6026d24570c3cf73daeb330e80f5e6
-  data.tar.gz: 3adf8888c9f6f1e70b619afbd8b819be6981701274f502f5017688229a2f355f
+  metadata.gz: 2e45f2f0be23112e3ef9836aa58973333a2bb409ac3718d02dcc464f117c4911
+  data.tar.gz: 4489393bdd074715f545a1ce35419f0794fb47ed99a72af90f63d8885cf5c4fe
 SHA512:
-  metadata.gz: f154018834b5fc5e7ff5f624272487a343c633ebcb5124b34c522694e8e0a0df606999243f0994d1e8d836eaec07fb3be8ef140d457542b948a8ddc4e2cea2ea
-  data.tar.gz: c4d0bbbade1370255a2d33155d443ce8e440673daf0fc18c975eb268f1efc0ad56d0cf73fdf36aa4b24f708d1826f3c53de424e71e0b3505c9a5778f190c5b84
+  metadata.gz: e9c6833636ff9724dd8c6533d532aee97edac0303168bda759d8e2a693221bd4f9d10c55bde8adcd51d8859d35902892188f023a15482aad054a273b426ff169
+  data.tar.gz: ab4692c91ffcceb61018d08c165bf6c3bb7a6873103ffe91c6bf494d64f103a8f9a88e46462291024ea9476a00a9afdcfc32c863ade7807dc112857516e218e4

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# v2.1.0 (2019-05-01)
+
+Feature:
+- Adds HttpRetriever and cascading cache support (#58)
+
 # v2.0.0 (2019-02-19)
 
 Breaking change:

data/README.md

@@ -116,6 +116,46 @@ This configures the `Determinator.instance` with:
 
 You may also want to configure a `determinator` helper method inside your web request scope, see below for more information.
 
+### Using over http
+
+Using the HttpRetriever will cause a request to be sent to actor tracking every time a feature is checked. The impact of this can be mitigated somewhat by having a short lived memory cache, but we're limited in
+the length of time we can cache for without some way of notifying the cache that an item has changed.
+
+```ruby
+faraday_connection = Faraday.new("http://actor-tracking.local") do |conn|
+  conn.headers['User-Agent'] = "Determinator - my service name"
+  conn.basic_auth('my-service-name', 'actor-tracking-token')
+  conn.adapter Faraday.default_adapter
+end
+
+Determinator.configure(
+  retrieval: Determinator::Retrieve::HttpRetriever.new(
+    connection: faraday_connection,
+  ),
+  feature_cache: Determinator::Cache::FetchWrapper.new(
+    ActiveSupport::Cache::MemoryStore.new(expires_in: 1.minute),
+    ActiveSupport::Cache::RedisCacheStore.new
+  )
+)
+```
+
+In this set up we've got two caches - some limited local cache and a larger redis cache that's shared between instances. The memory cache ensure that we're able to perform determination lookups in tight loops without excessive calls to redis.
+
+We don't set a TTL on the redis cache (although we could) because we intend to expire the caches manually when we receive an update from our event bus:
+
+```ruby
+  feature_name = Determinator.retrieval.get_name("http://actor-tracking.local/features/some_feature")
+  Determinator.feature_cache.expire(feature_name)
+```
+
+or in instances where the event bus provides a full feature object with a name it's simply:
+
+```ruby
+  Determinator.feature_cache.expire(deserialized_kafka_feature.name)
+```
+
+This will expire both the limited local cache and the larger shared cache.
+
 ## Further Usage
 
 Once this is done you can ask for a determination like this:
@@ -154,12 +194,6 @@ determinator.which_variant(:my_experiment_name)
 
 Check the example Rails app in the `examples` directory for more information on how to make use of this gem.
 
-### Routemaster
-
-Determinator's [Routemaster](https://github.com/deliveroo/routemaster) integration requires your application to be subscribed to the a `features` topic.
-
-The drain must expire the routemaster cache on receipt of events, making use of  `Routemaster::Drain::CacheBusting.new` or similar is recommended.
-
 ### Using Determinator in RSpec
 
 * Include the  `spec_helper.rb`.

data/lib/determinator.rb

@@ -7,6 +7,7 @@ require 'determinator/serializers/json'
 
 module Determinator
   class << self
+    attr_reader :feature_cache, :retrieval
     # @param :retrieval [Determinator::Retrieve::Routemaster] A retrieval instance for Features
     # @param :errors [#call, nil] a proc, accepting an error, which will be called with any errors which occur while determinating
     # @param :missing_feature [#call, nil] a proc, accepting a feature name, which will be called any time a feature is requested but isn't available
@@ -15,6 +16,7 @@ module Determinator
       self.on_error(&errors) if errors
       self.on_missing_feature(&missing_feature) if missing_feature
       @feature_cache = feature_cache if feature_cache.respond_to?(:call)
+      @retrieval = retrieval
       @instance = Control.new(retrieval: retrieval)
     end
 
@@ -89,5 +91,9 @@ module Determinator
 
       @feature_cache.call(name) { yield }
     end
+
+    def invalidate_cache(name)
+      @feature_cache.expire(name)
+    end
   end
 end

data/lib/determinator/cache/fetch_wrapper.rb

@@ -1,13 +1,30 @@
 module Determinator
   module Cache
     class FetchWrapper
-      # @param cache [#fetch] An instance of a cache class which implements #fetch like ActiveSupport::Cache does
-      def initialize(cache)
-        @cache = cache
+      # @param *caches [ActiveSupport::Cache] If a list then the head of the the
+      # list should will be checked before the  tail. If the head is empty but
+      # the tail is not then the head will be filled with the value of the tail.
+      def initialize(*caches)
+        @caches = caches
       end
 
+      # Call walks through each cache, returning a value if the item exists in
+      # any cache, otherwise popularing each cache with the value of yield.
       def call(feature_name)
-        @cache.fetch(key(feature_name)) { yield }
+        value = read_and_upfill(feature_name)
+        # nil is an acceptable value in the case of a missing feature definition
+        return nil if value.nil?
+        return value if value != false
+
+        value_to_write = yield
+        @caches.each do |cache|
+          cache.write(key(feature_name), value_to_write)
+        end
+        return value_to_write
+      end
+
+      def expire(feature_name)
+        @caches.each{ |c| c.delete(key(feature_name)) }
       end
 
       private
@@ -15,6 +32,27 @@ module Determinator
       def key(feature_name)
         "determinator:feature_cache:#{feature_name}"
       end
+
+      # Walks through the list of caches, returning the first stored value.
+      #
+      # If a value is found in a cache after the first then all caches earlier
+      # in that list will be backfilled.
+      #
+      # @param url [String] a feature name
+      # @return [false, nil, Feature] false when no value is found, otherwise
+      # the value stored in the cache (including nil)
+      def read_and_upfill(feature_name)
+        @caches.each.with_index do |cache, index|
+          if cache.exist?(key(feature_name))
+            value = cache.read(key(feature_name))
+            @caches[0...index].each do |cache|
+              cache.write(key(feature_name), value)
+            end
+            return value
+          end
+        end
+        return false
+      end
     end
   end
 end

data/lib/determinator/retrieve/http_retriever.rb

@@ -0,0 +1,35 @@
+require 'faraday'
+
+module Determinator
+  module Retrieve
+
+    class HttpRetriever
+      def initialize(connection:)
+        raise ArgumentError, "client must be a Faraday::Connection" unless connection.is_a?(Faraday::Connection)
+        @connection = connection
+      end
+
+      def retrieve(name)
+        begin
+          response = @connection.get("/features/#{name}")
+          return Determinator::Serializers::JSON.load(response.body) if response.status == 200
+        rescue => e
+          Determinator.notice_error(e)
+        end
+        nil
+      end
+
+      # Returns a feature name given a actor-tracking url. Used so we are able
+      # to expire a cache using a feature name given an event url.
+      #
+      # Not intended to be generic, and makes no guarantees about support for
+      # alternative url schemes.
+      #
+      # @param url [String] a actor tracking url
+      # @return [String, nil] a feature name or nil
+      def get_name(url)
+        (url.match('features\/(.*)\z') || [])[1]
+      end
+    end
+  end
+end

data/lib/determinator/version.rb

@@ -1,3 +1,3 @@
 module Determinator
-  VERSION = '2.0.0'
+  VERSION = '2.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: determinator
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - JP Hastings-Spital
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-19 00:00:00.000000000 Z
+date: 2019-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -197,6 +197,7 @@ files:
 - lib/determinator/feature.rb
 - lib/determinator/retrieve/dynaconf.rb
 - lib/determinator/retrieve/file.rb
+- lib/determinator/retrieve/http_retriever.rb
 - lib/determinator/retrieve/null_retriever.rb
 - lib/determinator/serializers/json.rb
 - lib/determinator/target_group.rb
@@ -222,7 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.8
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Determine which experiments and features a specific actor should see.