main
ply4 git calls331 ms44 KiB1 cachedprotocol v2
214 lines10 KiBRaw
1import { describe, expect, it, vi } from 'vitest';
2import { serveFlags, loadRuleset, normalizeCacheStatus, rulesetCacheProblems, rulesetRequest, rulesetRequestProblems } from '../../src/flags/cache.ts';
3import { CACHE_STATUSES, parseCacheStatus } from '../../src/flags/types.ts';
4import { memoryStore } from '../../src/flags/store.ts';
5import { setRollout } from '../../src/flags/api.ts';
6import { ABSENT_REVISION, FLAGS_CACHE_URL, FLAGS_MAX_AGE_S, FLAGS_SWR_S, cacheControl } from '../../src/flags/ttl.ts';
7import { handleFlagHttp } from '../../src/flags/http.ts';
8import { isEnabled, resolveFlags, usageNote } from '../../src/flags/client.ts';
9import { parseFlagKey } from '../../src/flags/brand.ts';
10import { parseUnit } from '../../src/flags/document.ts';
11import type { FlagSelection, Unit } from '../../src/flags/types.ts';
13/** One property. A null receiver and a missing key are holes. A stored null stays null. */
14function slot(receiver: unknown, key: string): unknown {
15 if (receiver === null || receiver === void 0) return void 0;
16 if (typeof receiver !== 'object' && typeof receiver !== 'function') return void 0;
17 return (receiver as Record<string, unknown>)[key];
20const env = { FLAGS: { present: true }, FLAGS_MAX_AGE_S: String(FLAGS_MAX_AGE_S), FLAGS_SWR_S: String(FLAGS_SWR_S) };
21const ABSENT_UNIT = { kind: 'absent' } as const;
23function resolvedUnit(id: string): { unit: Unit; keys: FlagSelection } {
24 const parsed = parseUnit(id, ABSENT_UNIT);
25 if (parsed.kind !== 'ok') throw new Error(parsed.reason);
26 const flag = parseFlagKey('ply.usage.note');
27 if (flag.kind !== 'key') throw new Error(flag.reason);
28 return { unit: { id: parsed.id, attributes: parsed.attributes }, keys: { kind: 'listed', keys: [flag.value] } };
31async function seeded() {
32 const store = memoryStore();
33 const written = await setRollout(store, { invalidate: async () => ({ kind: 'ok' }) }, 'ply.usage.note', 0, ABSENT_REVISION);
34 if (written.kind !== 'ok') throw new Error(written.kind);
35 return { store, revision: written.revision };
38describe('cache status', () => {
39 it('keeps every documented token and does not alias an unknown one to NONE', () => {
40 for (const status of CACHE_STATUSES) {
41 expect(parseCacheStatus(status)).toEqual({ kind: 'known', status });
42 expect(normalizeCacheStatus(status)).toBe(status);
43 }
44 expect(parseCacheStatus(null)).toEqual({ kind: 'absent' });
45 expect(normalizeCacheStatus(null)).toBe('NONE');
46 expect(normalizeCacheStatus('')).toBe('NONE');
47 expect(parseCacheStatus('IGNORED')).toEqual({ kind: 'unrecognized', value: 'IGNORED' });
48 expect(normalizeCacheStatus('IGNORED')).toBe('UNKNOWN');
49 });
50});
52describe('ruleset cache', () => {
53 it('sets a short max-age, a long stale-while-revalidate, the revision etag, and one tag', async () => {
54 const { store, revision } = await seeded();
55 const response = await serveFlags(new Request('https://flags.internal/config'), env, store);
56 expect(response.status).toBe(200);
57 expect(response.headers.get('cache-control')).toBe(cacheControl(FLAGS_MAX_AGE_S, FLAGS_SWR_S));
58 expect(rulesetCacheProblems(response.headers)).toEqual([]);
59 expect(response.headers.get('etag')).toBe(revision);
60 const again = await serveFlags(new Request('https://flags.internal/config', { headers: { 'if-none-match': revision } }), env, store);
61 expect(again.status).toBe(304);
62 expect(rulesetCacheProblems(again.headers)).toEqual([]);
63 expect(again.headers.get('etag')).toBe(revision);
64 expect(await again.text()).toBe('');
65 });
67 it('caches a missing ruleset under the same contract as a present one', async () => {
68 const response = await serveFlags(rulesetRequest(), env, memoryStore());
69 expect(response.status).toBe(404);
70 expect(rulesetCacheProblems(response.headers)).toEqual([]);
71 expect(response.headers.get('cache-control')).toBe(cacheControl(FLAGS_MAX_AGE_S, FLAGS_SWR_S));
72 expect(response.headers.has('set-cookie')).toBe(false);
73 expect(response.headers.get('vary')).toBeNull();
74 });
76 it('calls FlagsCache with one stable key, and records hit, miss, and stale', async () => {
77 const seen: string[] = [];
78 const { store } = await seeded();
79 for (const status of ['HIT', 'MISS', 'STALE'] as const) {
80 const lines: string[] = [];
81 const spy = vi.spyOn(console, 'log').mockImplementation(line => { lines.push(String(line)); });
82 try {
83 const cache = {
84 async fetch(request: Request) {
85 seen.push(`${request.method} ${request.url}`);
86 expect(rulesetRequestProblems(request)).toEqual([]);
87 expect(request.headers.has('authorization')).toBe(false);
88 expect(request.headers.has('cookie')).toBe(false);
89 const response = await serveFlags(request, env, status === 'MISS' ? memoryStore() : store);
90 expect(rulesetCacheProblems(response.headers)).toEqual([]);
91 response.headers.set('cf-cache-status', status);
92 return response;
93 },
94 };
95 const unit = status === 'HIT' ? 'user-a' : 'user-b';
96 await usageNote(env, { exports: { FlagsCache: cache }, tracing: null }, { kind: 'present', value: unit });
97 const asked = resolvedUnit(unit);
98 const resolved = await resolveFlags(
99 { env, cache, tracing: null },
100 asked.unit,
101 asked.keys,
102 );
103 expect(resolved.kind).toBe('ok');
104 if (resolved.kind === 'ok') expect(resolved.cache).toBe(status);
105 } finally {
106 spy.mockRestore();
107 }
108 const parsed = lines.map(line => JSON.parse(line) as { msg: string; cache_status: string });
109 expect(parsed.filter(row => row.msg === 'flags.resolve').every(row => row.cache_status === status)).toBe(true);
110 expect(parsed.some(row => row.msg === 'flags.resolve' && row.cache_status === status)).toBe(true);
111 }
112 expect(new Set(seen)).toEqual(new Set([`GET ${FLAGS_CACHE_URL}`]));
113 });
115 it('serves eval as no-store and refuses an HTTP write', async () => {
116 const { store } = await seeded();
117 const cache = {
118 async fetch(request: Request) {
119 const response = await serveFlags(request, env, store);
120 response.headers.set('cf-cache-status', 'MISS');
121 return response;
122 },
123 };
124 const ctx = { exports: { FlagsCache: cache }, tracing: null };
125 const listed = await handleFlagHttp(new Request('https://ply.ivar.workers.dev/v1/flags'), env, ctx);
126 expect(listed.status).toBe(200);
127 expect(listed.headers.get('cache-control')).toBe('no-store');
128 const put = await handleFlagHttp(new Request('https://ply.ivar.workers.dev/v1/flags', { method: 'PUT' }), env, ctx);
129 expect(put.status).toBe(405);
130 const body = await put.json() as { message: string };
131 expect(body.message).toContain('FlagControl');
132 expect(body.message).toContain('ply-flag-operator');
133 const evalResponse = await handleFlagHttp(new Request('https://ply.ivar.workers.dev/v1/flags/eval', {
134 method: 'POST',
135 body: JSON.stringify({ unit: 'anonymous' }),
136 }), env, ctx);
137 expect(evalResponse.headers.get('cache-control')).toBe('no-store');
138 const payload = await evalResponse.json() as { flags: { key: string; reason: string; variant: { value: boolean } }[] };
139 expect(payload.flags[0]).toMatchObject({ key: 'ply.usage.note', reason: 'default', variant: { kind: 'boolean', value: false } });
140 });
141});
143describe('in-worker gate', () => {
144 it('stays off when the binding is missing, and on for an allow-listed unit', async () => {
145 expect(await isEnabled({}, void 0, 'ply.usage.note', { id: 'anonymous', attributes: ABSENT_UNIT })).toBe(false);
146 expect(await usageNote({}, void 0, { kind: 'absent' })).toBeNull();
147 const store = memoryStore();
148 const created = await setRollout(store, { invalidate: async () => ({ kind: 'ok' }) }, 'ply.usage.note', 0, ABSENT_REVISION);
149 if (created.kind !== 'ok') throw new Error(created.kind);
150 const { setTargeting } = await import('../../src/flags/api.ts');
151 const targeted = await setTargeting(store, { invalidate: async () => ({ kind: 'ok' }) }, 'ply.usage.note', { allow: ['anonymous'], deny: [], rules: [] }, created.revision);
152 expect(targeted.kind).toBe('ok');
153 const cache = {
154 async fetch(request: Request) {
155 const response = await serveFlags(request, env, store);
156 response.headers.set('cf-cache-status', 'HIT');
157 return response;
158 },
159 };
160 const on = await isEnabled(env, { exports: { FlagsCache: cache } }, 'ply.usage.note', { id: 'anonymous', attributes: ABSENT_UNIT });
161 expect(on).toBe(true);
162 const note = await usageNote(env, { exports: { FlagsCache: cache } }, { kind: 'absent' });
163 expect(note).toBe('ply.usage.note is on for this unit.');
164 const loaded = await loadRuleset(env, cache);
165 expect(loaded.kind).toBe('ready');
166 });
167});
169describe('resolve timing', () => {
170 it('measures the cache await and leaves the pure eval at 0 when the clock only moves on I/O', async () => {
171 const { store } = await seeded();
172 let now = 0;
173 const clock = () => now;
174 const spans: string[] = [];
175 let spanOpenDuringFetch = false;
176 const cache = {
177 async fetch(request: Request) {
178 expect(request.method).toBe('GET');
179 spanOpenDuringFetch = spans.includes('flags.eval') && !spans.includes('flags.eval:end');
180 now += 12.5;
181 const response = await serveFlags(request, env, store);
182 response.headers.set('cf-cache-status', 'MISS');
183 return response;
184 },
185 };
186 const tracing = {
187 enterSpan(name: string) {
188 spans.push(name);
189 return { setAttribute() {}, end() { spans.push(`${name}:end`); } };
190 },
191 };
192 const lines: string[] = [];
193 const spy = vi.spyOn(console, 'log').mockImplementation(line => { lines.push(String(line)); });
194 try {
195 const asked = resolvedUnit('user:smoke');
196 const resolved = await resolveFlags(
197 { env, cache, tracing },
198 asked.unit,
199 asked.keys,
200 clock,
201 );
202 expect(resolved.kind).toBe('ok');
203 } finally {
204 spy.mockRestore();
205 }
206 expect(spanOpenDuringFetch).toBe(true);
207 expect(spans[0]).toBe('flags.eval');
208 const evalLine = lines.map(line => JSON.parse(line) as { msg: string; resolve_ms: number; eval_ms: number }).find(row => row.msg === 'flags.eval');
209 expect(slot(evalLine, 'resolve_ms')).toBe(12.5);
210 expect(slot(evalLine, 'eval_ms')).toBe(0);
211 expect(spans.indexOf('flags.resolve')).toBeGreaterThan(spans.indexOf('flags.eval'));
212 expect(spans.indexOf('flags.resolve:end')).toBeLessThan(spans.indexOf('flags.eval:end'));
213 });
214});
Diagnostics4 git calls · 331 ms
CallStatusSizeTime0331 ms
discover200152 B2 ms
git.upload-pack discover
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=152
git.server.agent=gitty/1.0
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch object-format
git.server.fetch=shallow filter sideband-all
git.protocol.version=2
git.pkt.frames=8
git.pkt.data=6
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=152
git.pkt.payload.max=34
ls-refs200145 B4 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=4
git.response.bytes=145
git.response.cache=UPDATING
git.response.duration_ms=4
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=145
git.pkt.payload.max=76
git.ls_refs.count=2
git.ls_refs.head=refs/heads/main
fetchblob:none · deepen 1020040 KiB · hit3 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=3
git.response.bytes=41349
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=blob:none
git.fetch.filter.requested=tree:0
git.fetch.filter.fallback=blob:none
git.fetch.filter.learned=false
git.fetch.wants=526b305930b8ef382f2d7a1f9c0238730a585921
git.fetch.haves.count=0
git.fetch.deepen=10
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=6
git.pkt.data=4
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=41349
git.pkt.payload.max=41254
git.sideband.band1.bytes=41253
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=61
git.pack.bytes=41253
git.pack.ofs_delta=0
git.pack.ref_delta=0
git.pack.chain.max=0
git.pack.trailer=ab60efef4b7243678c75de64a4386986ee885c1c
git.pack.full=61
Open pack map
fetch2002.9 KiB324 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=324
git.response.bytes=2982
git.response.cache=MISS
git.response.duration_ms=324
git.fetch.wants=81919c4e4a3036d8632c5a52ade74e687ab89283
git.fetch.haves.count=0
git.fetch.deepen=0
git.fetch.thin_pack=false
git.fetch.ofs_delta=true
git.protocol.version=2
git.pkt.frames=3
git.pkt.data=2
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=2982
git.pkt.payload.max=2961
git.sideband.band1.bytes=2960
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0

Each row is one HTTP round trip ply made to the git server for this page, on one timeline. discover asks what the server speaks, ls-refs lists branch tips, fetch brings objects by id. A hit was served by Workers Cache. Tap a row for its wire details.

Remote
https://5ad2236b39de4c8bd8f6270ea63f3ea9.artifacts.cloudflare.net/git/public-v0/ply-web.git
Ref
refs/heads/main
Commit
526b305930b8ef382f2d7a1f9c0238730a585921
cf-ray
a5e295b85e2d2407
Request
73bc9e21…
Protocol
v2 · sha1
Agent
gitty/1.0
Filter
advertised
Fetch
shallow filter sideband-all
Capabilities
agent ls-refs fetch object-format