Introduce Split Registry Endpoint Accepting a Timestamp

app/controllers/api/v2/split_registries_controller.rb

@@ -2,6 +2,6 @@ class Api::V2::SplitRegistriesController < UnauthenticatedApiController
   include CorsSupport
 
   def show
-    @split_registry = SplitRegistry.instance
+    @split_registry = SplitRegistrySnapshot.new(timestamp: Time.zone.now)
   end
 end

app/controllers/api/v2/split_registry_snapshots_controller.rb

@@ -0,0 +1,19 @@
+class Api::V2::SplitRegistrySnapshotsController < UnauthenticatedApiController
+  include CorsSupport
+
+  def show
+    snapshot = SplitRegistrySnapshot.new(timestamp: snapshot_params[:timestamp])
+
+    if snapshot.valid?
+      @split_registry_snapshot = snapshot
+    else
+      render_errors snapshot
+    end
+  end
+
+  private
+
+  def snapshot_params
+    params.permit(:timestamp)
+  end
+end

app/models/split_registry_snapshot.rb

@@ -0,0 +1,37 @@
+class SplitRegistrySnapshot
+  include ActiveModel::Validations
+
+  validates :timestamp, presence: true
+  # We want to make sure the client is shipping us high-precision ISO
+  # timestamps so we choose to allow timestamps at either millisecond or second
+  # precision based on the W3C interpretation of iso8601 from this SO answer:
+  #
+  # https://stackoverflow.com/a/3143231
+  validates :timestamp, format: {
+    with: /\A\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d(.\d+)?([+-][0-2]\d:[0-5]\d|Z)\z/, allow_blank: true
+  }
+
+  def initialize(timestamp:)
+    @timestamp = timestamp
+  end
+
+  def splits
+    Split.active(as_of: timestamp)
+  end
+
+  def experience_sampling_weight
+    @experience_sampling_weight ||= _experience_sampling_weight
+  end
+
+  private
+
+  attr_reader :timestamp
+
+  def _experience_sampling_weight
+    Integer(ENV.fetch('EXPERIENCE_SAMPLING_WEIGHT', '1')).tap do |weight|
+      raise <<~TEXT if weight.negative?
+        EXPERIENCE_SAMPLING_WEIGHT, if specified, must be greater than or equal to 0. Use 0 to disable experience events.
+      TEXT
+    end
+  end
+end

app/views/api/v2/split_registry_snapshots/show.json.jbuilder

@@ -0,0 +1,10 @@
+json.splits do
+  @split_registry_snapshot.splits.each do |split|
+    json.set! split.name do
+      json.weights split.registry
+      json.feature_gate split.feature_gate?
+    end
+  end
+  json.merge!({})
+end
+json.(@split_registry_snapshot, :experience_sampling_weight)

config/routes.rb

@@ -51,6 +51,7 @@
 
     namespace :v2 do
       resource :split_registry, only: :show
+      resources :split_registry_snapshots, only: :show, param: :timestamp
 
       resources :migrations do
         collection do

spec/controllers/api/v2/split_registries_controller_spec.rb

@@ -7,7 +7,7 @@
 
   describe "#show" do
     before do
-      allow(SplitRegistry.instance).to receive(:experience_sampling_weight).and_return(10)
+      allow(ENV).to receive(:fetch).with('EXPERIENCE_SAMPLING_WEIGHT', any_args).and_return(10)
     end
 
     it "includes sampling weight" do

spec/controllers/api/v2/split_registry_snapshots_controller_spec.rb

@@ -0,0 +1,65 @@
+require 'rails_helper'
+
+RSpec.describe Api::V2::SplitRegistrySnapshotsController, type: :controller do
+  let(:split_1) { FactoryBot.create :split, name: "one", finished_at: Time.zone.parse('2019-11-13'), registry: { all: 100 } }
+  let(:split_2) { FactoryBot.create :split, name: "two", registry: { on: 50, off: 50 } }
+  let(:split_3) { FactoryBot.create :split, name: "three_enabled", registry: { true: 99, false: 1 }, feature_gate: true }
+
+  describe "#show" do
+    before do
+      allow(ENV).to receive(:fetch).with('EXPERIENCE_SAMPLING_WEIGHT', any_args).and_return(10)
+    end
+
+    it "includes sampling weight" do
+      get :show, params: { timestamp: '2019-11-11T14:35:30Z' }
+
+      expect(response).to have_http_status :ok
+      expect(response_json['experience_sampling_weight']).to eq(10)
+    end
+
+    it "returns empty with no active splits on the timestamp" do
+      expect(split_1).to be_finished
+
+      get :show, params: { timestamp: '2019-11-14T14:35:30Z' }
+
+      expect(response).to have_http_status :ok
+      expect(response_json['splits']).to eq({})
+    end
+
+    it "returns the full split registry of splits that are active during timestamp" do
+      expect(split_1).to be_finished
+      expect(split_2).not_to be_finished
+      expect(split_3).not_to be_finished
+
+      get :show, params: { timestamp: '2019-11-12T14:35:30Z' }
+
+      expect(response).to have_http_status :ok
+      expect(response_json['splits']).to eq(
+        "one" => {
+          "weights" => { "all" => 100 },
+          "feature_gate" => false
+        },
+        "two" => {
+          "weights" => { "on" => 50, "off" => 50 },
+          "feature_gate" => false
+        },
+        "three_enabled" => {
+          "weights" => { "true" => 99, "false" => 1 },
+          "feature_gate" => true
+        }
+      )
+    end
+
+    it "returns unprocessable_entity if the timestamp url param is invalid" do
+      get :show, params: { timestamp: "2019-04-16 10:38:08 -0400" }
+
+      expect(response).to have_http_status :unprocessable_entity
+    end
+
+    it "returns unprocessable_entity if the timestamp url param is missing" do
+      get :show, params: { timestamp: "" }
+
+      expect(response).to have_http_status :unprocessable_entity
+    end
+  end
+end

spec/models/split_registry_spec.rb → spec/models/split_registry_snapshot_spec.rb

@@ -1,31 +1,57 @@
 require 'rails_helper'
 
-RSpec.describe SplitRegistry do
-  subject { described_class.instance }
+RSpec.describe SplitRegistrySnapshot do
+  subject { described_class.new(timestamp: Time.zone.now) }
+
+  describe 'validations' do
+    it "is valid with valid args" do
+      expect(described_class.new(timestamp: "2019-04-16T14:35:30Z")).to be_valid
+    end
+
+    it "is invalid with no timestamp" do
+      expect(described_class.new(timestamp: "")).to be_invalid
+    end
+
+    it "is invalid with a non-ISO date" do
+      expect(described_class.new(timestamp: "2019-04-16 10:38:08 -0400")).to be_invalid
+    end
+
+    it "is valid with an ISO date with millis" do
+      expect(described_class.new(timestamp: "2019-04-16T14:35:30.123Z")).to be_valid
+    end
+
+    it "is invalid with an ISO date without seconds" do
+      expect(described_class.new(timestamp: "2019-04-16T14:35Z")).to be_invalid
+    end
+  end
 
   describe "#splits" do
     it "doesn't cache the instance" do
       expect(subject.splits).to eq(subject.splits)
       expect(subject.splits).not_to eql(subject.splits)
     end
 
-    it "returns active splits" do
+    it "returns active splits as of provided timestamp" do
       split = FactoryBot.create(:split)
 
       expect(subject.splits.all).to include(split)
     end
 
-    it "doesn't return inactive splits" do
-      split = FactoryBot.create(:split, finished_at: Time.zone.now)
+    it "doesn't return inactive splits as of given timestamp" do
+      split = FactoryBot.create(:split, finished_at: 1.day.ago)
 
       expect(subject.splits.all).not_to include(split)
     end
+
+    it "returns splits that were retired after the given timestamp" do
+      split = FactoryBot.create(:split, finished_at: Time.zone.now)
+
+      expect(described_class.new(timestamp: 1.day.ago).splits.all).to include(split)
+    end
   end
 
   describe "#experience_sampling_weight" do
     context "bypassing singleton memoization" do
-      subject { described_class.send(:new) }
-
       it "memoizes the env var fetch" do
         allow(ENV).to receive(:fetch).and_call_original