determinator 2.4.4 → 2.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b5c2494d530c31a915321c8dbf47713e4ddaed50a0d5858a285e020a87bccf1
-  data.tar.gz: 4e9cad995c047a7c8d12aa7dc8228cddfc4a84891c2fc9283b4d41eb26b3bbdf
+  metadata.gz: 7e5cd27cbcca013e18d0a941c9a196e9b8e7e908a97d67b857514f58d35def5d
+  data.tar.gz: 18c86d3448b136bb996702d0bbcdba97f5280f496bd580daf145013b2dd054f8
 SHA512:
-  metadata.gz: 0727e1e39289a3f89b0d6e20da1139130ca329cdd786af73b7190c3df3f3e958f31d2f92eb09593e00c2503fdb09adf499ac81006baac28094b377e59f7be452
-  data.tar.gz: ce5085f303357a3d3e70e082b99f6ef986ee1f5c0a27fee7c0b89d7e6196c6702955e2c70db1897f003316cfcbf3934d99a9379cfa1b11a9659321832141a091
+  metadata.gz: f892fed72664d8dd47fb50d710678ff33ebe274f25fa8885ab048a13a7b3db5e496b7e39d67ce1fcea14c805bfaa390cc905241fb6e3e63405687d0ea2fe8355
+  data.tar.gz: a9c104b252ba508445957ee1f249f39ace127f294104693153e96afae9f3903c7dcf497ead2d1b255b1ff429fde9340db37551d82ecee6888576bae01eea6395

data/CHANGELOG.md

@@ -1,3 +1,30 @@
+# 2.5.4
+
+Bug fix:
+- Apply app_version logic to structured request.app_version too
+
+# 2.5.3
+
+Bug fix:
+- Avoid errors when updating the gem and using persistent cache resulting in null fixed_determinations
+
+# 2.5.2
+
+Feature:
+- Add structured_bucket to Feature
+- Add `#retrieve` method to the Control
+- Add optional `feature` argument to `feature_flag_on?` and `which_variant`, to reuse an existing feature
+
+# 2.5.1
+
+Feature:
+- Add explain functionality for determinations
+
+# 2.5.0
+
+Feature:
+- Add fixed determinations
+
 # 2.4.4
 
 Bug fix:

data/lib/determinator.rb

@@ -2,6 +2,8 @@ require 'determinator/version'
 require 'determinator/control'
 require 'determinator/feature'
 require 'determinator/target_group'
+require 'determinator/fixed_determination'
+require 'determinator/explainer'
 require 'determinator/cache/fetch_wrapper'
 require 'determinator/serializers/json'
 require 'determinator/missing_response'

data/lib/determinator/control.rb

@@ -5,10 +5,11 @@ require 'securerandom'
 
 module Determinator
   class Control
-    attr_reader :retrieval
+    attr_reader :retrieval, :explainer
 
     def initialize(retrieval:)
       @retrieval = retrieval
+      @explainer = Determinator::Explainer.new
     end
 
     # Creates a new determinator instance which assumes the actor id, guid and properties given
@@ -29,10 +30,11 @@ module Determinator
     # @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
+    # @param :feature [Feature] The feature to use instead of retrieving one
     # @raise [ArgumentError] When the arguments given to this method aren't ever going to produce a useful response
     # @return [true,false] Whether the feature is on (true) or off (false) for this actor
-    def feature_flag_on?(name, id: nil, guid: nil, properties: {})
-      determinate_and_notice(name, id: id, guid: guid, properties: properties) do |feature|
+    def feature_flag_on?(name, id: nil, guid: nil, properties: {}, feature: nil)
+      determinate_and_notice(name, id: id, guid: guid, properties: properties, feature: feature) do |feature|
         feature.feature_flag?
       end
     end
@@ -43,14 +45,29 @@ module Determinator
     # @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
+    # @param :feature [Feature] The feature to use instead of retrieving one
     # @raise [ArgumentError] When the arguments given to this method aren't ever going to produce a useful response
     # @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, properties: {})
-      determinate_and_notice(name, id: id, guid: guid, properties: properties) do |feature|
+    def which_variant(name, id: nil, guid: nil, properties: {}, feature: nil)
+      determinate_and_notice(name, id: id, guid: guid, properties: properties, feature: feature) do |feature|
         feature.experiment?
       end
     end
 
+    def explain_determination(name, id: nil, guid: nil, properties: {})
+      explainer.explain do
+        determinate_and_notice(name, id: id, guid: guid, properties: properties)
+      end
+    end
+
+    # Uses the retrieval (and a cache if set on the Determinator config) to fetch a feature definition.
+    #
+    # @param name [#to_s] The name of the experiment being checked
+    # @return [Feature, MissingResponse] Returns the Feature object, or MissingResponse if the feature is not found.
+    def retrieve(name)
+      Determinator.with_retrieval_cache(name) { retrieval.retrieve(name) }
+    end
+
     def inspect
       '#<Determinator::Control>'
     end
@@ -59,8 +76,8 @@ module Determinator
 
     Indicators = Struct.new(:rollout, :variant)
 
-    def determinate_and_notice(name, id:, guid:, properties:)
-      feature = Determinator.with_retrieval_cache(name) { retrieval.retrieve(name) }
+    def determinate_and_notice(name, id:, guid:, properties:, feature: nil)
+      feature ||= retrieve(name)
 
       if feature.nil? || feature.is_a?(ErrorResponse) || feature.is_a?(MissingResponse)
         Determinator.notice_missing_feature(name)
@@ -76,10 +93,20 @@ module Determinator
       # Calling method can place constraints on the feature, eg. experiment only
       return false if block_given? && !yield(feature)
 
+      explainer.log(:start, { feature: feature } )
+
       # Inactive features are always, always off
-      return false unless feature.active?
+      return false unless feature_active?(feature)
+
+      return override_value(feature, id) if feature_overridden?(feature, id)
 
-      return feature.override_value_for(id) if feature.overridden_for?(id)
+      fixed_determination = choose_fixed_determination(feature, properties)
+      # Given constraints have specified that this actor's determination should be fixed
+      if fixed_determination
+        return explainer.log(:chosen_fixed_determination, { fixed_determination: fixed_determination }) {
+          fixed_determination_value(feature, fixed_determination)
+        }
+      end
 
       target_group = choose_target_group(feature, properties)
       # Given constraints have excluded this actor from this experiment
@@ -90,14 +117,18 @@ module Determinator
       return false unless indicators
 
       # Actor's indicator has excluded them from the feature
-      return false if indicators.rollout >= target_group.rollout
+      return false if excluded_from_rollout?(indicators, target_group)
 
       # Features don't need variant determination and, at this stage,
       # they have been rolled out to.
-      return true unless feature.experiment?
+      # require_variant_determination?
+      return true unless require_variant_determination?(feature)
+
 
-      variant_for(feature, indicators.variant)
 
+      explainer.log(:chosen_variant) {
+        variant_for(feature, indicators.variant)
+      }
     rescue ArgumentError
       raise
 
@@ -106,26 +137,98 @@ module Determinator
       false
     end
 
+    def feature_active?(feature)
+      explainer.log(:feature_active) {
+        feature.active?
+      }
+    end
+
+    def feature_overridden?(feature, id)
+      explainer.log(:feature_overridden_for) {
+        feature.overridden_for?(id)
+      }
+    end
+
+    def override_value(feature, id)
+      explainer.log(:override_value, { id: id }) {
+        feature.override_value_for(id)
+      }
+    end
+
+    def excluded_from_rollout?(indicators, target_group)
+      explainer.log(:excluded_from_rollout, { target_group: target_group } ) {
+        indicators.rollout >= target_group.rollout
+      }
+    end
+
+    def require_variant_determination?(feature)
+      explainer.log(:require_variant_determination) {
+        feature.experiment?
+      }
+    end
+
+    def fixed_determination_value(feature, fixed_determination)
+      return false unless fixed_determination.feature_on
+      return true unless feature.experiment?
+      return fixed_determination.variant
+    end
+
+    def choose_fixed_determination(feature, properties)
+      return unless feature.fixed_determinations
+
+      # Keys and values must be strings
+      normalised_properties = normalise_properties(properties)
+
+      feature.fixed_determinations.find do |fd|
+        explainer.log(:possible_match_fixed_determination, { fixed_determination: fd }) {
+          check_fixed_determination(fd, normalised_properties)
+        }
+      end
+    end
+
+    def check_fixed_determination(fixed_determination, properties)
+      explainer.log(:check_fixed_determination, { fixed_determination: fixed_determination })
+
+      matches_constraints(properties, fixed_determination.constraints)
+    end
+
     def choose_target_group(feature, properties)
       # Keys and values must be strings
-      normalised_properties = properties.each_with_object({}) do |(name, values), hash|
-        hash[name.to_s] = [*values].map(&:to_s)
+      normalised_properties = normalise_properties(properties)
+
+      # Must choose target group deterministically, if more than one match
+      explainer.log(:chosen_target_group) {
+        filtered_target_groups(feature, normalised_properties).sort_by { |tg| tg.rollout }.last
+      }
+    end
+
+    def filtered_target_groups(feature, properties)
+      feature.target_groups.select do |tg|
+        explainer.log(:possible_match_target_group, { target_group: tg }) {
+          check_target_group(tg, properties)
+        }
       end
+    end
 
-      feature.target_groups.select { |tg|
-        next false unless tg.rollout.between?(1, 65_536)
+    def check_target_group(target_group, properties)
+      explainer.log(:check_target_group, { target_group: target_group })
 
-        tg.constraints.reduce(true) do |fit, (scope, *required)|
-          present = [*normalised_properties[scope]]
-          fit && matches_requirements?(scope, required, present)
-        end
-        # Must choose target group deterministically, if more than one match
-      }.sort_by { |tg| tg.rollout }.last
+      return false unless target_group.rollout.between?(1, 65_536)
+
+      matches_constraints(properties, target_group.constraints)
+    end
+
+    def matches_constraints(normalised_properties, constraints)
+      constraints.reduce(true) do |fit, (scope, *required)|
+        present = [*normalised_properties[scope]]
+        fit && matches_requirements?(scope, required, present)
+      end
     end
 
     def matches_requirements?(scope, required, present)
       case scope
         when "app_version" then has_any_app_version?(required, present)
+        when "request.app_version" then has_any_app_version?(required, present)
         else has_any?(required, present)
       end
     end
@@ -155,10 +258,12 @@ module Determinator
     def actor_identifier(feature, id, guid)
       case feature.bucket_type
       when :id
+        explainer.log(:missing_identifier, { identifier_type: 'ID' }) unless id
         id
       when :guid
         return guid if guid.to_s != ''
 
+        explainer.log(:missing_identifier, { identifier_type: 'GUID' })
         raise ArgumentError, 'A GUID must always be given for GUID bucketed features'
       when :fallback
         identifier = (id || guid).to_s
@@ -168,6 +273,7 @@ module Determinator
       when :single
         SecureRandom.hex(64)
       else
+        explainer.log(:unknown_bucket, { feature: feature } )
         Determinator.notice_error "Cannot process the '#{feature.bucket_type}' bucket type found in #{feature.name}"
       end
     end
@@ -205,5 +311,13 @@ module Determinator
 
       raise ArgumentError, "A variant should have been found by this point, there is a bug in the code."
     end
+
+    private
+
+    def normalise_properties(properties)
+      properties.each_with_object({}) do |(name, values), hash|
+        hash[name.to_s] = [*values].map(&:to_s)
+      end
+    end
   end
 end

data/lib/determinator/explainer.rb

@@ -0,0 +1,61 @@
+require 'determinator/explainer/messages'
+
+module Determinator
+  class Explainer
+    attr_accessor :enabled
+    attr_reader :logs
+
+    def initialize
+      @logs  = []
+      @enabled = false
+    end
+
+    def explain
+      @enabled = true
+      { outcome: yield, explanation: @logs }
+    ensure
+      @logs = []
+      @enabled = false
+    end
+
+    def log(type, args = {})
+      result = block_given? ? yield : nil
+
+      return result unless @enabled
+
+      result.tap do |r|
+        add(type, r, args)
+      end
+    end
+
+    private
+
+    def add(type, result, args = {})
+      template = MESSAGES[type].fetch(result.to_s) { MESSAGES[type][:default] }
+      return unless template
+
+      args = convert_hash(
+        args.merge(result: result)
+          .transform_values { |v| v.respond_to?(:to_explain_params) ? v.to_explain_params : v }
+      )
+
+      @logs << template.dup.tap do |m|
+        m[:title] = format(m[:title], args)
+        m[:subtitle] = format(m[:subtitle], args) if m[:subtitle]
+      end
+      true
+    end
+
+    def convert_hash(hsh, path = "")
+      hsh.each_with_object({}) do |(k, v), ret|
+        key = "#{path}#{k}"
+
+        if v.is_a?(Hash)
+          ret.merge! convert_hash(v, "#{key}.")
+        else
+          ret[key.to_sym] = v
+        end
+      end
+    end
+  end
+end

data/lib/determinator/explainer/messages.rb

@@ -0,0 +1,119 @@
+module Determinator
+  class Explainer
+    MESSAGES = {
+      start: {
+        default: {
+          type: :start,
+          title: 'Determinating %<feature.name>s',
+          subtitle: 'The given ID, GUID and properties will be used to determine which target groups this actor is in, and will deterministically return an outcome for the visibility of this feature for them.'
+        }
+      },
+      feature_active: {
+        'true' => { type: :continue, title: 'Feature is active' },
+        'false' => { type: :fail, title: 'Feature is inactive', subtitle: 'Every actor is excluded' }
+      },
+      feature_overridden_for: {
+        'false' => { type: :pass, title: 'No matching override found'  }
+      },
+      override_value: {
+        default: {
+          type: :success,
+          title: 'Matching override found for this actor with id: %<id>s',
+          subtitle: 'Determinator will return "%<result>s" for this actor and this feature in any system that is correctly set up.'
+        }
+      },
+      excluded_from_rollout: {
+        'true' => {
+          type: :fail,
+          title: 'Determinated to be outside the %<target_group.rollout_percent>s',
+          subtitle: 'This actor is excluded'
+        },
+        'false' => {
+          type: :continue,
+          title: 'Determinated to be inside the %<target_group.rollout_percent>s',
+          subtitle: 'This actor is included'
+        }
+      },
+      require_variant_determination: {
+        'false' => {
+          type: :success,
+          title: 'Feature flag on for this actor',
+          subtitle: 'Determinator will return true for this actor and this feature in any system that is correctly set up.'
+        }
+      },
+      missing_identifier: {
+        default: {
+          type: :fail,
+          title: 'No %<identifier_type>s given, cannot determinate',
+          subtitle: 'For %<identifier_type>s bucketed features an %<identifier_type>s must be given to have the possibility of being included.'
+        }
+      },
+      chosen_variant: {
+        default: {
+          type: :success,
+          title: 'In the "%<result>s" variant',
+          subtitle: 'Determinator will return "%<result>s" for this actor and this feature in any system that is correctly set up.'
+        }
+      },
+      unknown_bucket: {
+        default: {
+          type: :fail,
+          title: 'Unknown bucket type',
+          subtitle: 'The bucket type "%<feature.bucket_type>s" is not understood by Determinator. All actors will be excluded.'
+        }
+      },
+      check_target_group: {
+        default: {
+          type: :target_group,
+          title: 'Checking "%<target_group.name>s" target group',
+          subtitle: 'An actor must match at least one non-zero target group in order to be included.'
+        }
+      },
+      possible_match_target_group: {
+        'true' => {
+          type: :continue,
+          title: 'Matches the "%<target_group.name>s" target group',
+          subtitle: 'Matching this target group allows this actor a %<target_group.rollout_percent>s percent chance of being included.'
+        },
+        'false' => {
+          type: :pass,
+          title: 'Didn\'t match the "%<target_group.name>s" target group',
+          subtitle: 'Actor can\'t be included as part of this target group.'
+        }
+      },
+      chosen_target_group: {
+        '' => {
+          type: :fail,
+          title: 'No matching target groups',
+          subtitle: 'No matching target groups have a rollout larger than 0 percent. This actor is excluded.'
+        },
+        default: {
+          type: :info,
+          title: '%<result.rollout_percent>s percent chance of being included',
+          subtitle: 'The largest matching rollout percentage is %<result.rollout_percent>s, giving this actor a percent chance of being included.'
+        }
+      },
+      check_fixed_determination: {
+        default: {
+          type: :target_group,
+          title: 'Checking "%<fixed_determination.name>s" fixed determination',
+          subtitle: 'Matching an actor based on the constraints provided.'
+        }
+      },
+      possible_match_fixed_determination: {
+        'false' => {
+          type: :pass,
+          title: 'Didn\'t match the "%<fixed_determination.name>s" fixed determination',
+          subtitle: 'Actor can\'t be included as part of this fixed determination.'
+        }
+      },
+      chosen_fixed_determination: {
+        default: {
+          type: :success,
+          title: 'Matching fixed determination found for this actor with name: "%<fixed_determination.name>s"',
+          subtitle: 'Determinator will return "%<result>s" for this actor and this feature in any system that is correctly set up.'
+        },
+      }
+    }.freeze
+  end
+end

data/lib/determinator/feature.rb

@@ -3,16 +3,18 @@ module Determinator
   #
   # @attr_reader [nil,Hash<String,Integer>] variants The variants for this experiment, with the name of the variant as the key and the weight as the value. Will be nil for non-experiments.
   class Feature
-    attr_reader :name, :identifier, :bucket_type, :variants, :target_groups, :active, :winning_variant
+    attr_reader :name, :identifier, :bucket_type, :structured_bucket, :variants, :target_groups, :fixed_determinations, :active, :winning_variant
 
-    def initialize(name:, identifier:, bucket_type:, target_groups:, variants: {}, overrides: {}, active: false, winning_variant: nil)
+    def initialize(name:, identifier:, bucket_type:, target_groups:, structured_bucket: nil, fixed_determinations: [], variants: {}, overrides: {}, active: false, winning_variant: nil)
       @name = name.to_s
-      @identifier = (identifier || name).to_s
+      @identifier = identifier.to_s
       @variants = variants
       @target_groups = parse_target_groups(target_groups)
+      @fixed_determinations = parse_fixed_determinations(fixed_determinations)
       @winning_variant = parse_outcome(winning_variant, allow_exclusion: false)
       @active = active
       @bucket_type = bucket_type.to_sym
+      @structured_bucket = structured_bucket
 
       # To prevent confusion between actor id data types
       @overrides = overrides.each_with_object({}) do |(identifier, outcome), hash|
@@ -35,6 +37,11 @@ module Determinator
       variants.empty?
     end
 
+    # @return [true,false] Is this feature using structured identification?
+    def structured?
+      !!structured_bucket && !structured_bucket.empty?
+    end
+
     # Is this feature overridden for the given actor id?
     #
     # @return [true,false] Whether this feature is overridden for this actor
@@ -57,6 +64,10 @@ module Determinator
       Marshal.dump(self) == Marshal.dump(other)
     end
 
+    def to_explain_params
+      { name: name, identifier: identifier, bucket_type: bucket_type }
+    end
+
     private
 
     attr_reader :overrides
@@ -71,15 +82,46 @@ module Determinator
       constraints = target_group['constraints'].to_h
 
       TargetGroup.new(
+        name: target_group['name'],
         rollout: target_group['rollout'].to_i,
-        constraints: constraints.each_with_object({}) do |(key, value), hash|
-          hash[key.to_s] = [*value].map(&:to_s)
-        end
+        constraints: parse_constraints(constraints)
       )
 
     # Invalid target groups are ignored
     rescue
       nil
     end
+
+    def parse_fixed_determinations(fixed_determinations)
+      fixed_determinations.map(&method(:parse_fixed_determination)).compact
+    end
+
+    def parse_fixed_determination(fixed_determination)
+      return fixed_determination if fixed_determination.is_a? FixedDetermination
+
+      variant = fixed_determination['variant']
+      return nil if variant && !variants.keys.include?(variant)
+
+      # if a variant is present the fixed determination should always be on
+      return nil if variant && !fixed_determination['feature_on']
+
+      constraints = fixed_determination['constraints'].to_h
+
+      FixedDetermination.new(
+        name: fixed_determination['name'],
+        feature_on: fixed_determination['feature_on'],
+        variant: variant,
+        constraints: parse_constraints(constraints)
+      )
+    # Invalid fixed determinations are ignored
+    rescue
+      nil
+    end
+
+    def parse_constraints(constraints)
+      constraints.each_with_object({}) do |(key, value), hash|
+        hash[key.to_s] = [*value].map(&:to_s)
+      end
+    end
   end
 end

data/lib/determinator/fixed_determination.rb

@@ -0,0 +1,25 @@
+module Determinator
+  class FixedDetermination
+    attr_reader :name, :feature_on, :variant, :constraints
+
+    def initialize(feature_on:, variant:, name: '', constraints: {})
+      @name = name
+      @feature_on = feature_on
+      @variant = variant
+      @constraints = constraints
+    end
+
+    def inspect
+      "<feature_on: #{feature_on}, variant: #{variant}, constraints: #{constraints}"
+    end
+
+    def to_explain_params
+      { name: name }
+    end
+
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      other.feature_on == feature_on && other.variant == variant && other.constraints == constraints
+    end
+  end
+end

data/lib/determinator/serializers/json.rb

@@ -12,14 +12,16 @@ module Determinator
           obj = string_or_hash.is_a?(Hash) ? string_or_hash : ::JSON.parse(string_or_hash)
 
           Determinator::Feature.new(
-            name:            obj['name'],
-            identifier:      obj['identifier'],
-            bucket_type:     obj['bucket_type'],
-            active:          (obj['active'] === true),
-            target_groups:   obj['target_groups'],
-            variants:        obj['variants'].to_h,
-            overrides:       obj['overrides'].to_h,
-            winning_variant: obj['winning_variant'].to_s,
+            name:                 obj['name'],
+            identifier:           obj['identifier'],
+            bucket_type:          obj['bucket_type'],
+            structured_bucket:    obj['structured_bucket'],
+            active:               (obj['active'] === true),
+            target_groups:        obj['target_groups'],
+            fixed_determinations: obj['fixed_determinations'].to_a,
+            variants:             obj['variants'].to_h,
+            overrides:            obj['overrides'].to_h,
+            winning_variant:      obj['winning_variant'].to_s,
           )
         end
       end

data/lib/determinator/target_group.rb

@@ -1,8 +1,9 @@
 module Determinator
   class TargetGroup
-    attr_reader :rollout, :constraints
+    attr_reader :name, :rollout, :constraints
 
-    def initialize(rollout:, constraints: {})
+    def initialize(rollout:, name: '', constraints: {})
+      @name = name
       @rollout = rollout
       @constraints = constraints
     end
@@ -15,9 +16,16 @@ module Determinator
       Rational(rollout, 65_536)
     end
 
+    def humanize_percentage
+      (rollout_percent * 100).to_f.round(1)
+    end
+
     def inspect
-      pc = (rollout_percent * 100).to_f.round(1)
-      "<#{pc}% of those matching: #{constraints}>"
+      "<TG name:'#{name}': #{humanize_percentage}% of those matching: #{constraints}>"
+    end
+
+    def to_explain_params
+      { name: name, rollout_percent: humanize_percentage }
     end
 
     def ==(other)

data/lib/determinator/version.rb

@@ -1,3 +1,3 @@
 module Determinator
-  VERSION = '2.4.4'
+  VERSION = '2.5.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: determinator
 version: !ruby/object:Gem::Version
-  version: 2.4.4
+  version: 2.5.4
 platform: ruby
 authors:
 - JP Hastings-Spital
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-20 00:00:00.000000000 Z
+date: 2020-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -209,7 +209,10 @@ files:
 - lib/determinator/cache/fetch_wrapper.rb
 - lib/determinator/control.rb
 - lib/determinator/error_response.rb
+- lib/determinator/explainer.rb
+- lib/determinator/explainer/messages.rb
 - lib/determinator/feature.rb
+- lib/determinator/fixed_determination.rb
 - lib/determinator/missing_response.rb
 - lib/determinator/retrieve/dynaconf.rb
 - lib/determinator/retrieve/file.rb