determinator 2.4.0 → 2.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63baaf3ee379eef31694ec105e48407970d0e53e6906af8e9a1746cfac5ca5e4
-  data.tar.gz: 88b70dc55dedc32c98dc1eb3619fd420471127c812a7cdda7086c13349d3bdca
+  metadata.gz: 4466edc3643125ca6b84591b4db51083d215c5c6ea8201694e99d16e403eab24
+  data.tar.gz: 326d45e3f0ac249e5a358ee3911c1da4da01db81c14ab1b3c827a8fd5d0f4ef9
 SHA512:
-  metadata.gz: 1ea1835cd7e0953c5d6747bbcbddfc43804cd33ffc3ed136c72ede003c2a24c9357c7746081370404b9851788a0b64b9d45a633657365524ed77cf6a5a69bf67
-  data.tar.gz: 2db13fd8793c724554c2ba4766e3e769eb5d9e4042481b153a205337c5b0cfaad1bd6a691b552ee9a25109f9b8bb7b6dc6837570e909bf5d60fab1f4fe056e86
+  metadata.gz: c83ad23860f0d5565618e3cfbf1f9975763f3f64c0db49668fa2259aae06c972689e000538a734571906edbf766c8d1d46e58ad2d7c657461c76759768f37bfa
+  data.tar.gz: 777556d4606d6a10514b5f7c6311e498117845f9bf5bc3bd1be7f8c47cee837fb17243348d11ee0f2fff3931493e97e65cb06608dcbc9b435916aabad07e69f1

data/CHANGELOG.md

@@ -1,3 +1,39 @@
+# 2.5.1
+
+Feature:
+- Add explain functionality for determinations
+
+# 2.5.0
+
+Feature:
+- Add fixed determinations
+
+# 2.4.4
+
+Bug fix:
+- Count repeated determinations instead of tracking separately
+
+# 2.4.3
+
+Feature:
+- Add Sinatra endpoint tracking
+
+Bug fix:
+- Remove endpoint tracking of PATH_INFO
+
+# 2.4.2
+
+Feature:
+- Add endpoint information to tracking request
+
+Bug fix:
+- Make tracking request "start" attribute an actual time
+
+# 2.4.1
+
+Bug fix:
+- Update "fake" retrievers to match behaviour introduced in `v2.3.1` when a feature is missing
+
 # 2.4.0
 
 Feature:

data/README.md

@@ -289,12 +289,17 @@ end
 require 'determinator/tracking'
 
 Determinator::Tracking.on_request do |r|
-  Rails.logger.info("tag=determinator_request type=#{r.type} request_time=#{r.time} error=#{r.error?} response_status=#{r.attributes[:status]} sidekiq_queue=#{r.attributes[:queue]}")
+  Rails.logger.info("tag=determinator_request endpoint=#{r.endpoint} type=#{r.type} request_time=#{r.time} error=#{r.error?} response_status=#{r.attributes[:status]} sidekiq_queue=#{r.attributes[:queue]}")
   r.determinations.each do |d|
     Rails.logger.info("tag=determination id=#{d.id} guid=#{d.guid} flag=#{d.feature_id} result=#{d.determination}")
   end
 end
 
+# The library sets the "endpoint" with information about the request or sidekiq job. If you
+# have environment variables that further identify the service, e.g. ENV['APP_NAME'],
+# you can configure the tracker to prepend it to the endpoint:
+Determinator::Tracking.endpoint_env_vars = ['APP_NAME']
+
 # If using an APM, you can provide trace information on the request by providing a get_context hook: e.g.
 
 Determinator::Tracking.get_context do
@@ -310,9 +315,7 @@ Determinator::Tracking.get_context do
 end
 ```
 
-NOTE: this is implemented by keeping the list of requests in a per-request thread-local variable, which means that determinations will only be tracked on the main thread.
-
-If your application is spinning out worker threads, you should make the determinations in the main thread if possible; or collect them from your worker threads and track them in the main thread with
+NOTE: determinations will only be recorded on the threads where Determinator::Tracking is initialised via the middleware. If offloading work away from these thread (for example, by spinning up new threads within a Rack request or a Sidekiq worker), make the determinations before, and pass them through to the new threads; or, if it's not possible, collect them manually and track them in the request's thread with
 ```
 Determinator::Tracking.track(id, guid, feature, determination)
 ```

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
@@ -51,6 +52,12 @@ module Determinator
       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
+
     def inspect
       '#<Determinator::Control>'
     end
@@ -76,10 +83,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 +107,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,21 +127,90 @@ 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)
+      # 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)
@@ -155,10 +245,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 +260,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 +298,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,13 +3,14 @@ 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, :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:, 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
@@ -57,6 +58,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 +76,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/retrieve/in_memory_retriever.rb

@@ -10,7 +10,7 @@ module Determinator
 
       # @param name [string,symbol] The name of the feature to retrieve
       def retrieve(name)
-        @features[name.to_s]
+        @features.fetch(name.to_s, MissingResponse.new)
       end
 
       # @param feature [Determinator::Feature] The feature to store

data/lib/determinator/retrieve/null_retriever.rb

@@ -10,6 +10,7 @@ module Determinator
       # The Control class will assume a nil return from this method
       # means the feature doesn't exist, so in turn will return `false`.
       def retrieve(_)
+        MissingResponse.new
       end
     end
   end

data/lib/determinator/serializers/json.rb

@@ -12,14 +12,15 @@ 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'],
+            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/tracking.rb

@@ -4,6 +4,8 @@ require 'determinator/tracking/context'
 module Determinator
   module Tracking
     class << self
+      attr_reader :endpoint_env_vars
+
       def instance
         Thread.current[:determinator_tracker]
       end
@@ -12,9 +14,9 @@ module Determinator
         Thread.current[:determinator_tracker] = Tracker.new(type)
       end
 
-      def finish!(error:, **attributes)
+      def finish!(endpoint:, error:, **attributes)
         return false unless started?
-        request = instance.finish!(error: error, **attributes)
+        request = instance.finish!(endpoint: endpoint, error: error, **attributes)
         clear!
         report(request)
         request
@@ -57,6 +59,16 @@ module Determinator
         @on_request = nil
         @get_context = nil
       end
+
+      def endpoint_env_vars=(vars)
+        @endpoint_env_vars = Array(vars)
+      end
+
+      def collect_endpoint_info(parts)
+        endpoint = Array(Determinator::Tracking.endpoint_env_vars).map{ |v| ENV[v] }
+        endpoint += Array(parts)
+        endpoint.reject{ |p| p.nil? || p == ''}.join(' ')
+      end
     end
   end
 end

data/lib/determinator/tracking/determination.rb

@@ -13,6 +13,12 @@ module Determinator
       def ==(other)
         id == other.id && guid == other.guid && feature_id == other.feature_id && determination == other.determination
       end
+
+      alias eql? ==
+
+      def hash
+        [id, guid, feature_id, determination].hash
+      end
     end
   end
 end

data/lib/determinator/tracking/rack/middleware.rb

@@ -16,7 +16,26 @@ module Determinator
           error = true
           raise
         ensure
-          Determinator::Tracking.finish!(status: status, error: !!error)
+          Determinator::Tracking.finish!(
+            status: status,
+            error: !!error,
+            endpoint: extract_endpoint(env)
+          )
+        end
+
+        private
+
+        def extract_endpoint(env)
+          parts = if params = env['action_dispatch.request.path_parameters']
+            [env['REQUEST_METHOD'], [params[:controller], params[:action]].join('#')]
+          elsif env['sinatra.route']
+            [env['sinatra.route']]
+          else
+            [env['REQUEST_METHOD']]
+          end
+          Determinator::Tracking.collect_endpoint_info(parts)
+        rescue
+          env['PATH_INFO']
         end
       end
     end

data/lib/determinator/tracking/request.rb

@@ -1,14 +1,16 @@
 module Determinator
   module Tracking
     class Request
-      attr_reader :type, :time, :error, :attributes, :determinations, :context
+      attr_reader :start, :type, :endpoint, :time, :error, :attributes, :determinations, :context
 
-      def initialize(type:, time:, error:, attributes:, determinations:, context: nil)
+      def initialize(start:, type:, endpoint:, time:, error:, attributes:, determinations:, context: nil)
+        @start = start
         @type = type
         @time = time
         @error = error
         @attributes = attributes
         @determinations = determinations
+        @endpoint = endpoint
         @context = context
       end
 

data/lib/determinator/tracking/sidekiq/middleware.rb

@@ -18,7 +18,11 @@ module Determinator
             error = true
             raise
           ensure
-            Determinator::Tracking.finish!(queue: queue, error: !!error)
+            Determinator::Tracking.finish!(
+              endpoint: Determinator::Tracking.collect_endpoint_info(worker.class.name),
+              queue: queue,
+              error: !!error
+            )
           end
         end
       end

data/lib/determinator/tracking/tracker.rb

@@ -7,25 +7,30 @@ module Determinator
       attr_reader :type, :determinations
 
       def initialize(type)
-        @determinations = []
+        @determinations = Hash.new(0)
         @type = type
-        @start = now
+        @monotonic_start = now
+        @start = Time.now
       end
 
       def track(id, guid, feature, determination)
-        determinations << Determinator::Tracking::Determination.new(
-          id: id,
-          guid: guid,
-          feature_id: feature.identifier,
-          determination: determination
-        )
+        determinations[
+          Determinator::Tracking::Determination.new(
+            id: id,
+            guid: guid,
+            feature_id: feature.identifier,
+            determination: determination
+          )
+        ] += 1
       end
 
-      def finish!(error:, **attributes)
-        request_time = now - @start
+      def finish!(endpoint:, error:, **attributes)
+        request_time = now - @monotonic_start
         Determinator::Tracking::Request.new(
+          start: @start,
           type: type,
           time: request_time,
+          endpoint: endpoint,
           error: error,
           attributes: attributes,
           determinations: determinations,

data/lib/determinator/version.rb

@@ -1,3 +1,3 @@
 module Determinator
-  VERSION = '2.4.0'
+  VERSION = '2.5.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: determinator
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.1
 platform: ruby
 authors:
 - JP Hastings-Spital
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-03-05 00:00:00.000000000 Z
+date: 2020-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -150,7 +150,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - jp@deliveroo.co.uk
 executables: []
@@ -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
@@ -231,7 +234,7 @@ homepage: https://github.com/deliveroo/determinator
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -246,8 +249,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.0.6
+signing_key:
 specification_version: 4
 summary: Determine which experiments and features a specific actor should see.
 test_files: []