determinator 0.8.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b61e11a6498a8925acd9afe2f044ee454a0b155d
-  data.tar.gz: 033893ae1248afd025503413daebc2a0dd953a66
+  metadata.gz: 0a7faec5d84de6789a94db7db9ff1de4fe22f947
+  data.tar.gz: 7c6f139261beea20a8f5c64f5071582a2314e4f1
 SHA512:
-  metadata.gz: 3f1abc324ad0a963d67d82fabdc35a49ea8149bd6a8718e2ece520a5b07ae7d101a4234455ae82e1ede5c76f1db8b5d96760440330c6be3dbe41836a5253759e
-  data.tar.gz: 500c7ec60e1dd4e08764dc3d0d30dc60cd0be635e4b42b8188b5363a0f37690a3984a6a0c109ee3ada8976931c5551678f48f4e2dabc52d82c97dfac65d2f56d
+  metadata.gz: cda841470760af3175a63d5d6e4a464bce9b71f6c3df6953e140fbae31dd8b1c6cdeae89504e71ac66dab8298b364c0eab641cca6cc98e39ed915e626ac7dd06
+  data.tar.gz: e3a5d769418dc6be72b97df333f8feafbb662fcb78331381863c6cb21193ad5d4b67d68c1b2bf0f513b660347f0676ec02f122f674cd821d4b44c29886eb6a04

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# v0.9.1 (2017-09-14)
+
+Bug fix:
+- Fixes an issue where PR #27 missed one instance of syntactic sugar where `constraints` needed to be switched to `properties`. (#30)
+
+# v0.9.0 (2017-09-14)
+
+This version of Determiantor introduces some breaking changes as we move to getting the Florence ecosystem more ready for a wider audience. A 1.0.0 release will follow shortly with few additional features, but with significantly more documentation.
+
+Breaking changes:
+- When asking for a determination, you must specify the `properties` of the given actor, not the `constraints` (as `constraints` makes less sense) (#27)
+- Remove siphon drain step, determinator now requires just a drain that expires caches. Also Removes the caching step for ID lookup (#24)
+
+Features:
+- Added Determinator RSpec helper (#26)
+- Allows Determinator to accept both legacy and new style contraint and override specifications, for upcoming Florence API migration (#25)

data/README.md

@@ -25,7 +25,7 @@ when 'velociraptors'
 end
 ```
 
-Feature flags and Experiments can be configured to have string based constraints. When the strings required for the experiment do not match, the user will _never_ see the flag or the experiment, when they match, then the rollout specified by the feature will be applied.
+Feature flags and Experiments can be configured to have string based constraints. When the experiment's _constraints_ do not match the given actor's _properties_, the flag or experiment will always be off. When they match the rollout specified by the feature will be applied.
 
 Constraints must be strings, what matches and doesn't is configurable after-the-fact within Florence.
 
@@ -33,7 +33,7 @@ Constraints must be strings, what matches and doesn't is configurable after-the-
 # Constraints
 variant = determinator.which_variant(
   :my_experiment_name,
-  constraints: {
+  properties: {
     country_of_first_order: current_user.orders.first.country.tld,
   }
 )
@@ -41,13 +41,34 @@ variant = determinator.which_variant(
 
 ## Installation
 
+Determinator requires your application to be subscribed to the a `features` topic via Routemaster.
+
+The drain must expire the routemaster cache on receipt of events, `Routemaster::Drain::CacheBusting.new` or better.
+
 Check the example Rails app in `examples` for more information on how to make use of this gem.
 
+```
+# config/initializers/determinator.rb
+
+require 'determinator/retrieve/routemaster'
+Determinator.configure(
+  retrieval: Determinator::Retrieve::Routemaster.new(
+    discovery_url: 'https://florence.dev/'
+    retrieval_cache: ActiveSupport::Cache::MemoryStore.new(expires_in: 1.minute)
+  )
+)
+```
+
+### Retrieval Cache
+
+Determinator will function fully without a retrieval_cache set, although Determinator will produce 1 Redis query for every determination. By setting a `retrieval_cache` as an instance of `ActiveSupport::Cache::MemoryStore` (or equivalent) this can be reduced per application instance. This cache is not expired so *must* have a `expires_in` set, ideally to a short amount of time.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/deliveroo/determinator. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
+Any PR should include a new section at the top of the `CHANGELOG.md` (if it doesn't exist) called 'Unreleased' of a similar format to the lines below. Upon release, this will be used to detail what has been added.
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/examples/determinator-rails/Procfile

@@ -1,2 +1 @@
 web: bundle exec rails s
-worker: bundle exec sidekiq

data/examples/determinator-rails/README.md

@@ -8,13 +8,15 @@ This example Rails app has been configured so that Determinator is correctly con
 
 This file sets up the singleton Determinator instance for the application.
 
-### `config/routes.rb`
+### `config/initializers/routemaster.rb`
+
+Uses Routemaster::Client to subscribe to the `features` topic, with a calback url matching what's set up in the routes file
 
-Using Determinator with Routemaster means that you must expose an endpoint to be informed of changes to Features. Determinator makes it easy to set this up with the `#configure_rails_router` helper method.
+### `config/routes.rb`
 
-### `Procfile`
+Sets up a simple routemaster drain endpoint, using the `CacheBusting`. Other Drains are available with additional features
 
-Bear in mind that, because routemaster depends on background workers to populate the cache, Sidekiq (or Resque) must be running alongside the app.
+https://github.com/deliveroo/routemaster-drain
 
 ### `app/controllers/index_controller.rb`
 
@@ -29,7 +31,3 @@ The `determinator` method memoizes the instance of the `ActorControl` helper cla
 ### `config/application.rb`
 
 Ensure you've required the job runner backend appropriate for your set up. Routemaster Drain currently supports Sidekiq and Resque.
-
-### `config/sidekiq.yml`
-
-This example uses Sidekiq as the background processor, ensure you've set it up correctly for notifications to cache in the background.

data/examples/determinator-rails/config/routemaster.rb

@@ -0,0 +1,9 @@
+#Sets up the routemaster client and subscribes to the 'features' topic
+Routemaster::Client.subscribe(
+  topics: %w[
+    features
+  ],
+  callback: ENV.fetch('ROUTEMASTER_CALLBACK_URL'),
+  uuid: ENV.fetch('ROUTEMASTER_DRAIN_TOKENS'),
+  max: ENV.fetch('ROUTEMASTER_DRAIN_BATCH_SIZE', 1).to_i
+)

data/examples/determinator-rails/config/routes.rb

@@ -1,6 +1,5 @@
+require 'routemaster/drain/cache_busting'
 Rails.application.routes.draw do
   root to: 'index#show'
-
-  # DETERMINATOR: Make sure the routemaster routes are mapped to the containing app.
-  Determinator.instance.retrieval.configure_rails_router(self)
+  mount Routemaster::Drain::CacheBusting.new, at: ENV.fetch('ROUTEMASTER_CALLBACK_URL')
 end

data/lib/determinator/actor_control.rb

@@ -3,30 +3,33 @@ module Determinator
   # Useful for contexts where the actor remains constant (eg. inside
   # the request cycle in a webapp)
   class ActorControl
-    attr_reader :id, :guid, :default_constraints
+    attr_reader :id, :guid, :default_properties
 
-    def initialize(controller, id: nil, guid: nil, default_constraints: {})
+    # @see Determinator::Control#for_actor
+    def initialize(controller, id: nil, guid: nil, default_properties: {})
       @id = id
       @guid = guid
-      @default_constraints = default_constraints
+      @default_properties = default_properties
       @controller = controller
     end
 
-    def which_variant(name, constraints: {})
+    # @see Determinator::Control#which_variant
+    def which_variant(name, properties: {})
       controller.which_variant(
         name,
         id: id,
         guid: guid,
-        constraints: default_constraints.merge(constraints)
+        properties: default_properties.merge(properties)
       )
     end
 
-    def feature_flag_on?(name, constraints: {})
+    # @see Determinator::Control#feature_flag_on?
+    def feature_flag_on?(name, properties: {})
       controller.feature_flag_on?(
         name,
         id: id,
         guid: guid,
-        constraints: default_constraints.merge(constraints)
+        properties: default_properties.merge(properties)
       )
     end
 

data/lib/determinator/control.rb

@@ -9,25 +9,40 @@ module Determinator
       @retrieval = retrieval
     end
 
+    # Creates a new determinator instance which assumes the actor id, guid and properties given
+    # are always specified. This is useful for within a before filter in a webserver, for example,
+    # so that the determinator instance made available has the logged-in user's credentials prefilled.
+    #
+    # @param :id [#to_s] The ID of the actor being specified
+    # @param :guid [#to_s] The Anonymous ID of the actor being specified
+    # @param :default_properties [Hash<Symbol,String>] The default properties for the determinator being created
     # @return [ActorControl] A helper object removing the need to know id and guid everywhere
-    def for_actor(id: nil, guid: nil, default_constraints: {})
-      ActorControl.new(self, id: id, guid: guid, default_constraints: default_constraints)
+    def for_actor(id: nil, guid: nil, default_properties: {})
+      ActorControl.new(self, id: id, guid: guid, default_properties: default_properties)
     end
 
     # Determines whether a specific feature is on or off for the given actor
     #
+    # @param name [#to_s] The name of the feature flag being checked
+    # @param :id [#to_s] The id of the actor being determinated for
+    # @param :guid [#to_s] The Anonymous id of the actor being determinated for
+    # @param :properties [Hash<Symbol,String>] The properties of this actor which will be used for including this actor or not
     # @return [true,false] Whether the feature is on (true) or off (false) for this actor
-    def feature_flag_on?(name, id: nil, guid: nil, constraints: {})
-      determinate(name, id: id, guid: guid, constraints: constraints) do |feature|
+    def feature_flag_on?(name, id: nil, guid: nil, properties: {})
+      determinate(name, id: id, guid: guid, properties: properties) do |feature|
         feature.feature_flag?
       end
     end
 
     # Determines what an actor should see for a specific experiment
     #
+    # @param name [#to_s] The name of the experiment being checked
+    # @param :id [#to_s] The id of the actor being determinated for
+    # @param :guid [#to_s] The Anonymous id of the actor being determinated for
+    # @param :properties [Hash<Symbol,String>] The properties of this actor which will be used for including this actor or not
     # @return [false,String] Returns false, if the actor is not in this experiment, or otherwise the variant name.
-    def which_variant(name, id: nil, guid: nil, constraints: {})
-      determinate(name, id: id, guid: guid, constraints: constraints) do |feature|
+    def which_variant(name, id: nil, guid: nil, properties: {})
+      determinate(name, id: id, guid: guid, properties: properties) do |feature|
         feature.experiment?
       end
     end
@@ -40,7 +55,7 @@ module Determinator
 
     Indicators = Struct.new(:rollout, :variant)
 
-    def determinate(name, id:, guid:, constraints:)
+    def determinate(name, id:, guid:, properties:)
       feature = retrieval.retrieve(name)
       return false unless feature
 
@@ -52,7 +67,7 @@ module Determinator
 
       return false unless feature.active?
 
-      target_group = choose_target_group(feature, constraints)
+      target_group = choose_target_group(feature, properties)
       # Given constraints have excluded this actor from this experiment
       return false unless target_group
 
@@ -70,10 +85,10 @@ module Determinator
       variant_for(feature, indicators.variant)
     end
 
-    def choose_target_group(feature, constraints)
+    def choose_target_group(feature, properties)
       feature.target_groups.select { |tg|
         tg.constraints.reduce(true) do |fit, (scope, *required)|
-          present = [*constraints[scope]]
+          present = [*properties[scope]]
           fit && (required.flatten & present.flatten).any?
         end
       # Must choose target group deterministically, if more than one match

data/lib/determinator/retrieve/routemaster.rb

@@ -1,7 +1,6 @@
 require 'uri'
 require 'routemaster/drain/caching'
 require 'routemaster/responses/hateoas_response'
-require 'determinator/retrieve/routemaster_feature_id_cache_warmer'
 require 'determinator/retrieve/null_cache'
 
 module Determinator
@@ -11,12 +10,8 @@ module Determinator
     # To use this correctly you will need the following environment variables set to appropriate values
     # for your instance of Routemaster:
     #
-    # ROUTEMASTER_DRAIN_TOKENS
-    # ROUTEMASTER_DRAIN_REDIS
     # ROUTEMASTER_CACHE_REDIS
     # ROUTEMASTER_CACHE_AUTH
-    # ROUTEMASTER_QUEUE_NAME
-    # ROUTEMASTER_CALLBACK_URL
     class Routemaster
       attr_reader :routemaster_app
 
@@ -29,16 +24,11 @@ module Determinator
         )
         @retrieval_cache = retrieval_cache
         @actor_service = client.discover(discovery_url)
-        @routemaster_app = ::Routemaster::Drain::Caching.new(
-          siphon_events: { 'features' => RoutemasterFeatureIdCacheWarmer }
-        )
+
       end
 
-      def retrieve(feature_name)
-        cached_feature_lookup(feature_name) do
-          key = self.class.index_cache_key(feature_name)
-          feature_id = ::Routemaster::Config.cache_redis.get(key)
-          return unless feature_id
+      def retrieve(feature_id)
+        cached_feature_lookup(feature_id) do
           @actor_service.feature.show(feature_id)
         end
       rescue ::Routemaster::Errors::ResourceNotFound
@@ -52,6 +42,10 @@ module Determinator
         route_mapper.mount routemaster_app, at: CALLBACK_PATH
       end
 
+      def routemaster_app
+        @routemaster_app ||= ::Routemaster::Drain::Caching.new
+      end
+
       def self.index_cache_key(feature_name)
         "determinator_index:#{feature_name}"
       end
@@ -74,19 +68,49 @@ module Determinator
           identifier:    obj.body.identifier,
           bucket_type:   obj.body.bucket_type,
           active:        obj.body.active,
-          target_groups: obj.body.target_groups.map { |tg|
-            TargetGroup.new(
-              rollout: tg.rollout,
-              constraints: tg.constraints.first.to_h
-            )
-          },
+          target_groups: target_groups_attribute(obj.body.target_groups),
           variants:      obj.body.variants.to_h,
-          overrides:     obj.body.overrides.each_with_object({}) { |override, hash|
-            hash[override.user_id] = override.variant
-          },
+          overrides:     overrides_attribute(obj.body.overrides),
           winning_variant: obj.body.winning_variant,
         )
       end
+
+      def target_groups_attribute(target_groups)
+        target_groups.map do |tg|
+          TargetGroup.new(
+            rollout: tg.rollout,
+            constraints: constraints_attribute(tg.constraints)
+          )
+        end
+      end
+
+      def constraints_attribute(constraints)
+        # TODO when FLO-3 closed: no need for legacy guard
+        return legacy_constraints_attribute(constraints) unless constraints.respond_to?(:each_pair)
+        constraints
+      end
+
+      def legacy_constraints_attribute(constraints)
+        constraints.each_with_object({}) do |constraint, h|
+          if h[constraint.scope]
+            h[constraint.scope] = [*h[constraint.scope], constraint.identifier]
+          else
+            h[constraint.scope] = constraint.identifier
+          end
+        end
+      end
+
+      def overrides_attribute(overrides)
+        # TODO when FLO-3 closed: no need for legacy guard
+        return legacy_overrides_attribute(overrides) unless overrides.respond_to?(:each_pair)
+        overrides
+      end
+
+      def legacy_overrides_attribute(overrides)
+        overrides.each_with_object({}) do |override, h|
+          h[override[:user_id]] = override[:variant]
+        end
+      end
     end
   end
 end

data/lib/determinator/version.rb

@@ -1,3 +1,3 @@
 module Determinator
-  VERSION = "0.8.0"
+  VERSION = '0.9.1'
 end

data/lib/rspec/determinator.rb

@@ -1,3 +1,5 @@
+require 'determinator'
+
 module RSpec
   module Determinator
     def self.included(by)
@@ -5,12 +7,12 @@ module RSpec
 
       by.let(:fake_determinator) { FakeControl.new }
       by.before do
-        allow(Determinator::Control).to receive(:new).and_return(fake_determinator)
+        allow(::Determinator::Control).to receive(:new).and_return(fake_determinator)
       end
     end
 
     module DSL
-      def forced_determination(name, result, only_for: nil)
+      def forced_determination(name, result, only_for: {})
         before do
           fake_determinator.mock_result(
             name,
@@ -23,22 +25,33 @@ module RSpec
 
     class FakeControl
       def initialize
-        @mocked_results = {}
+        @mocked_results = Hash.new { |h, k| h[k] = {} }
       end
 
-      def mock_result(name, result, only_for: nil)
-        @mocked_results[name.to_s][only_for || {}] = result
+      def mock_result(name, result, only_for: {})
+        @mocked_results[name.to_s][only_for] = result
       end
 
-      def fake_determinate(name, id: nil, guid: nil, constraints: {})
-        constraints[:id] = id if id
-        constraints[:guid] = guid if guid
+      def fake_determinate(name, id: nil, guid: nil, properties: {})
+        properties[:id] = id if id
+        properties[:guid] = guid if guid
 
-        return false unless @mocked_results[name.to_s].has_key?(constraints)
-        @mocked_results[name.to_s][constraints]
+        outcome_for_feature_given_properties(name.to_s, properties)
       end
       alias_method :feature_flag_on?, :fake_determinate
       alias_method :which_variant, :fake_determinate
+
+      private
+
+      def outcome_for_feature_given_properties(feature_name, requirements)
+        req_array = requirements.to_a
+
+        _, forced = @mocked_results[feature_name].find do |given, outcome|
+          (given.to_a - req_array).empty?
+        end
+
+        forced || false
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: determinator
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.1
 platform: ruby
 authors:
 - JP Hastings-Spital
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-04 00:00:00.000000000 Z
+date: 2017-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: routemaster-drain
@@ -132,6 +132,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Guardfile
@@ -168,9 +169,9 @@ files:
 - examples/determinator-rails/config/initializers/new_framework_defaults.rb
 - examples/determinator-rails/config/initializers/wrap_parameters.rb
 - examples/determinator-rails/config/puma.rb
+- examples/determinator-rails/config/routemaster.rb
 - examples/determinator-rails/config/routes.rb
 - examples/determinator-rails/config/secrets.yml
-- examples/determinator-rails/config/sidekiq.yml
 - examples/determinator-rails/public/favicon.ico
 - examples/determinator-rails/public/robots.txt
 - lib/determinator.rb
@@ -180,7 +181,6 @@ files:
 - lib/determinator/retrieve/null_cache.rb
 - lib/determinator/retrieve/null_retriever.rb
 - lib/determinator/retrieve/routemaster.rb
-- lib/determinator/retrieve/routemaster_feature_id_cache_warmer.rb
 - lib/determinator/target_group.rb
 - lib/determinator/version.rb
 - lib/rspec/determinator.rb

data/examples/determinator-rails/config/sidekiq.yml

@@ -1,2 +0,0 @@
-:queues:
-  - routemaster

data/lib/determinator/retrieve/routemaster_feature_id_cache_warmer.rb

@@ -1,29 +0,0 @@
-module Determinator
-  module Retrieve
-    class RoutemasterFeatureIdCacheWarmer
-      def initialize(payload)
-        @payload = payload
-      end
-
-      def call
-        response = client.get(@payload['url']).body
-        if valid_feature_response?(response)
-          key = Routemaster.index_cache_key(response['name'])
-          ::Routemaster::Config.cache_redis.set(key, response['id'])
-        end
-      end
-
-      private
-
-      def client
-        @client ||= ::Routemaster::APIClient.new(
-          response_class: ::Routemaster::Responses::HateoasResponse
-        )
-      end
-
-      def valid_feature_response?(response)
-        response['id'] && response['name'] && response['bucket_type']
-      end
-    end
-  end
-end