determinator 2.3.1 → 2.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08378908b45b61bc3c88232e1e480db1200acfe98d3b42dfd10e27420067b5e8'
-  data.tar.gz: ee822d9401d3c8a0019ae45ecdebd1f2becd56e7081764dd92ecbba9a30b6fa5
+  metadata.gz: b505247b6902fb3768389da7b5a20e625f95e5ccaec778ae7fb52e1808286b73
+  data.tar.gz: 659b93e86df258535f904bd90d91768767c5c1644cd578d3efe3f45a9c2aba6f
 SHA512:
-  metadata.gz: '0288df451ba45366adfb9ffb1f76147c0e565ee647d278f00b23877490cdbb7ebd4fd1b832e46f3812616894d576ee285f509df67e54a68a69415ce6370bfc65'
-  data.tar.gz: 93cc9692b60bc97bfcf629995bfd38afdbf00161864bec8b5b15568a0b409470d17b52ad1673270444afd7080ff857b10605cea4c0d733b41fbb633a8bf13dd5
+  metadata.gz: 753968e66ac00b3f0606eed33b5d1873ad23a89cce901b69e261f38263ff14f18b975a0f03e55146e8ea78dc397b1a48878f10c3b1fc6eadd4f278a78f2a7703
+  data.tar.gz: 46d183bc1e87d5031b43115bb63573503725f441a44603577274fef9817cd20722471bcba1b46d018beab4828bbcbf738c4de742aff0de26578178330edd2885

data/.circleci/config.yml

@@ -10,6 +10,10 @@ jobs:
     steps:
       - checkout
 
+      - run:
+          name: Install bundler
+          command: gem install bundler -v 2.1.4
+
       - run:
           name: Bundle Install
           command: bundle install
@@ -30,6 +34,10 @@ jobs:
     steps:
       - checkout
 
+      - run:
+          name: Install bundler
+          command: gem install bundler -v 2.1.4
+
       - run:
           name: Bundle Install
           command: bundle install
@@ -50,6 +58,10 @@ jobs:
     steps:
       - checkout
 
+      - run:
+          name: Install bundler
+          command: gem install bundler -v 2.1.4
+
       - run:
           name: Bundle Install
           command: bundle install

data/CHANGELOG.md

@@ -1,3 +1,39 @@
+# 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:
+- Add tracker middleware
+
 # v2.3.1 (2019-05-25)
 
 Feature:

data/README.md

@@ -204,7 +204,7 @@ variant = determinator.which_variant(
     app_version: "1.2.3"
   }
 )
-``` 
+```
 The `app_version` constraint for that flag needs to follow ruby gem version constraints. We support the following operators: `>, <, >=, <=, ~>`. For example:
 `app_version: ">=1.2.0"`
 
@@ -220,6 +220,8 @@ Determinator.configure(retrieval: nil)
 
 * Tag your rspec test with `:determinator_support`, so the `forced_determination` helper method will be available.
 
+  Please note, `RSpec::Determinator` mocks a determination _outcome_, not the process of choosing one. Set the `only_for` argument to be the properties you require for Determinator to return the specified outcome. At the moment this mock does not allow for the testing of the `id` or `guid` arguments (only the properties).
+
 ```ruby
 RSpec.describe "something", :determinator_support do
 
@@ -251,6 +253,73 @@ end
 
 * Check out [the specs for `RSpec::Determinator`](spec/rspec/determinator_spec.rb) to find out what you can do!
 
+## Tracking
+
+The library includes a middleware to track all determinations being made, allowing logging them at the end of the request
+(including some useful request metrics).
+
+To enable it, e.g. in Rails:
+
+```ruby
+# config/application.rb
+
+require 'determinator/tracking/rack/middleware'
+
+# possibly near the top of your stack, in case other middlewares make determinations
+config.middleware.use Determinator::Tracking::Rack::Middleware
+```
+
+or for Sidekiq:
+
+```ruby
+# config/initializers/sidekiq.rb
+
+require 'determinator/tracking/sidekiq/middleware'
+
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add Determinator::Tracking::Sidekiq::Middleware
+  end
+end
+```
+
+```ruby
+# config/initializers/determinator.rb
+
+require 'determinator/tracking'
+
+Determinator::Tracking.on_request do |r|
+  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
+  span = Datadog.tracer.active_root_span
+  return unless span
+  Determinator::Tracking::Context.new(
+    request_id: span.trace_id,
+    service: span.service,
+    resource: span.resource,
+    type: span.type,
+    meta: span.meta
+  )
+end
+```
+
+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)
+```
+
 ## Testing this library
 
 This library makes use of the [Determinator Standard Tests](https://github.com/deliveroo/determinator-standard-tests) to ensure that it conforms to the same specification as determinator libraries in other languages. The standard tests can be updated to the latest ones available by updating the submodule:

data/determinator.gemspec

@@ -23,11 +23,12 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "faraday"
   spec.add_runtime_dependency "semantic", "~> 1.6"
 
-  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "bundler", "~> 2.1.4"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rspec-its", "~> 1.2"
   spec.add_development_dependency "guard-rspec", "~> 4.7"
   spec.add_development_dependency "factory_girl", "~> 4.8"
   spec.add_development_dependency 'webmock'
+  spec.add_development_dependency "sidekiq"
 end

data/lib/determinator.rb

@@ -2,10 +2,12 @@ require 'determinator/version'
 require 'determinator/control'
 require 'determinator/feature'
 require 'determinator/target_group'
+require 'determinator/fixed_determination'
 require 'determinator/cache/fetch_wrapper'
 require 'determinator/serializers/json'
 require 'determinator/missing_response'
 require 'determinator/error_response'
+require 'determinator/tracking'
 
 
 module Determinator
@@ -83,6 +85,7 @@ module Determinator
     end
 
     def notice_determination(id, guid, feature, determination)
+      Determinator::Tracking.track(id, guid, feature, determination)
       return unless @determination_callback
       @determination_callback.call(id, guid, feature, determination)
     end

data/lib/determinator/control.rb

@@ -81,6 +81,14 @@ module Determinator
 
       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 false unless fixed_determination.feature_on
+        return true unless feature.experiment?
+        return fixed_determination.variant
+      end
+
       target_group = choose_target_group(feature, properties)
       # Given constraints have excluded this actor from this experiment
       return false unless target_group
@@ -106,23 +114,34 @@ module Determinator
       false
     end
 
+    def choose_fixed_determination(feature, properties)
+      # Keys and values must be strings
+      normalised_properties = normalise_properties(properties)
+
+      feature.fixed_determinations.find { |fd|
+        matches_constraints(normalised_properties, fd.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)
-      end
+      normalised_properties = normalise_properties(properties)
 
       feature.target_groups.select { |tg|
         next false unless tg.rollout.between?(1, 65_536)
 
-        tg.constraints.reduce(true) do |fit, (scope, *required)|
-          present = [*normalised_properties[scope]]
-          fit && matches_requirements?(scope, required, present)
-        end
+        matches_constraints(normalised_properties, tg.constraints)
         # Must choose target group deterministically, if more than one match
       }.sort_by { |tg| tg.rollout }.last
     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)
@@ -205,5 +224,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/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
@@ -72,14 +73,43 @@ module Determinator
 
       TargetGroup.new(
         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(
+        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,20 @@
+module Determinator
+  class FixedDetermination
+    attr_reader :feature_on, :variant, :constraints
+
+    def initialize(feature_on:, variant:, constraints: {})
+      @feature_on = feature_on
+      @variant = variant
+      @constraints = constraints
+    end
+
+    def inspect
+      "<feature_on: #{feature_on}, variant: #{variant}, constraints: #{constraints}"
+    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/tracking.rb

@@ -0,0 +1,74 @@
+require 'determinator/tracking/tracker'
+require 'determinator/tracking/context'
+
+module Determinator
+  module Tracking
+    class << self
+      attr_reader :endpoint_env_vars
+
+      def instance
+        Thread.current[:determinator_tracker]
+      end
+
+      def start!(type)
+        Thread.current[:determinator_tracker] = Tracker.new(type)
+      end
+
+      def finish!(endpoint:, error:, **attributes)
+        return false unless started?
+        request = instance.finish!(endpoint: endpoint, error: error, **attributes)
+        clear!
+        report(request)
+        request
+      end
+
+      def clear!
+        Thread.current[:determinator_tracker] = nil
+      end
+
+      def started?
+        !!instance
+      end
+
+      def track(id, guid, feature, determination)
+        return false unless started?
+        instance.track(id, guid, feature, determination)
+      end
+
+      def on_request(&block)
+        @on_request = block
+      end
+
+      def report(request)
+        return unless @on_request
+        @on_request.call(request)
+      end
+
+      def get_context(&block)
+        @get_context = block
+      end
+
+      def context
+        return unless @get_context
+        @get_context.call
+      rescue
+        nil
+      end
+
+      def clear_hooks!
+        @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/context.rb

@@ -0,0 +1,15 @@
+module Determinator
+  module Tracking
+    class Context
+      attr_reader :request_id, :service, :resource
+
+      def initialize(request_id: nil, service: nil, resource: nil, type: nil, meta: {})
+        @request_id = request_id
+        @service = service
+        @resource = resource
+        @type = type
+        @meta = meta
+      end
+    end
+  end
+end

data/lib/determinator/tracking/determination.rb

@@ -0,0 +1,24 @@
+module Determinator
+  module Tracking
+    class Determination
+      attr_reader :id, :guid, :feature_id, :determination
+
+      def initialize(id:, guid:, feature_id:, determination:)
+        @id = id
+        @guid = guid
+        @feature_id = feature_id
+        @determination = determination
+      end
+
+      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

@@ -0,0 +1,43 @@
+require 'determinator/tracking'
+
+module Determinator
+  module Tracking
+    module Rack
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          Determinator::Tracking.start!(:rack)
+          status, headers, response = @app.call(env)
+          [status, headers, response]
+        rescue
+          error = true
+          raise
+        ensure
+          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
+  end
+end

data/lib/determinator/tracking/request.rb

@@ -0,0 +1,22 @@
+module Determinator
+  module Tracking
+    class Request
+      attr_reader :start, :type, :endpoint, :time, :error, :attributes, :determinations, :context
+
+      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
+
+      def error?
+        error
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require 'determinator/tracking'
+
+module Determinator
+  module Tracking
+    module Sidekiq
+      class Middleware
+        # @param [Object] worker the worker instance
+        # @param [Hash] job the full job payload
+        #   * @see https://github.com/mperham/sidekiq/wiki/Job-Format
+        # @param [String] queue the name of the queue the job was pulled from
+        # @yield the next middleware in the chain or worker `perform` method
+        # @return [Void]
+        def call(worker, job, queue)
+          begin
+            Determinator::Tracking.start!(:sidekiq)
+            yield
+          rescue => ex
+            error = true
+            raise
+          ensure
+            Determinator::Tracking.finish!(
+              endpoint: Determinator::Tracking.collect_endpoint_info(worker.class.name),
+              queue: queue,
+              error: !!error
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/determinator/tracking/tracker.rb

@@ -0,0 +1,48 @@
+require 'determinator/tracking/determination'
+require 'determinator/tracking/request'
+
+module Determinator
+  module Tracking
+    class Tracker
+      attr_reader :type, :determinations
+
+      def initialize(type)
+        @determinations = Hash.new(0)
+        @type = type
+        @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
+          )
+        ] += 1
+      end
+
+      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,
+          context: Determinator::Tracking.context
+        )
+      end
+
+      private
+
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/determinator/version.rb

@@ -1,3 +1,3 @@
 module Determinator
-  VERSION = '2.3.1'
+  VERSION = '2.5.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: determinator
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.5.0
 platform: ruby
 authors:
 - JP Hastings-Spital
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-09-25 00:00:00.000000000 Z
+date: 2020-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: 2.1.4
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: 2.1.4
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -136,7 +136,21 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
 email:
 - jp@deliveroo.co.uk
 executables: []
@@ -196,6 +210,7 @@ files:
 - lib/determinator/control.rb
 - lib/determinator/error_response.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
@@ -204,13 +219,20 @@ files:
 - lib/determinator/retrieve/null_retriever.rb
 - lib/determinator/serializers/json.rb
 - lib/determinator/target_group.rb
+- lib/determinator/tracking.rb
+- lib/determinator/tracking/context.rb
+- lib/determinator/tracking/determination.rb
+- lib/determinator/tracking/rack/middleware.rb
+- lib/determinator/tracking/request.rb
+- lib/determinator/tracking/sidekiq/middleware.rb
+- lib/determinator/tracking/tracker.rb
 - lib/determinator/version.rb
 - lib/rspec/determinator.rb
 homepage: https://github.com/deliveroo/determinator
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -225,9 +247,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
-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: []