GitHubivarvong

ply

main
ply7 git calls232 ms28 KiB5 cachedprotocol v2
206 lines16 KiBRaw
1// Differential probes, reference target only (CI): every scenario run by ply and by stock git against git http-backend
2// configured to Artifacts' known policy, judged by stock git (ls-remote, a mirror clone, fsck --strict, rev-list,
3// merge-base), compared by src/probe-evaluate.ts. The Artifacts runs are opt-in and private (scripts/probes.mjs
4// --artifacts); this file never reaches the network beyond 127.0.0.1.
5import { test, beforeAll as before, afterAll as after } from 'vitest';
6import assert from 'node:assert/strict';
7import { mkdtempSync, rmSync } from 'node:fs';
8import { tmpdir } from 'node:os';
9import { join } from 'node:path';
10import { SCENARIOS } from '../../src/probe-scenarios.ts';
11import { ALLOW } from '../../src/probe-allow.ts';
12import { compareScenario, evaluablePairs, judge, plyOutcome, classify, runsFor, soloDiffs } from '../../src/probe-evaluate.ts';
13import { gitOutcome } from './git-outcome.ts';
14import { startReference, runScenario, newTracer, reportOf } from './runner.mjs';
15import { BEHAVIOURS } from '../behaviours/matrix.ts';
16import { ABSENT } from '../../src/probe-types.ts';
18test('every scenario probes a matrix behaviour, ids are unique, plans are closed', () => {
19 const ids = SCENARIOS.map(s => s.id);
20 assert.deepEqual(ids.filter((id, i) => ids.indexOf(id) !== i), [], 'duplicate scenario ids');
21 const behaviours = new Set(BEHAVIOURS.map(b => b.id));
22 for (const s of SCENARIOS) {
23 const [behaviour, variant] = s.id.split('#');
24 assert.ok(behaviours.has(behaviour), `${s.id}: no matrix behaviour ${behaviour}`);
25 assert.match(variant ?? '', /^[a-z0-9]+(-[a-z0-9]+)*$/, `${s.id}: variant must be kebab-case`);
26 assert.equal(s.expect.length, s.steps.length, `${s.id}: one expectation per step`);
27 const defined = new Set(s.seed.objects.map(o => o.name));
28 const refs = [
29 ...s.seed.refs.map(r => r.at),
30 ...s.seed.objects.flatMap(o => {
31 switch (o.tag) {
32 case 'commit': return o.parents;
33 case 'annotated-tag': return [o.target];
34 case 'raw-commit': return [...o.parents, o.tree];
35 case 'raw-tree': return o.entries.map(e => e.blob.tag === 'blob' ? e.blob.of : e.blob.name);
36 case 'phantom': return [];
37 case 'raw-tag': return [o.object];
38 }
39 throw new Error(`unknown seed object ${o.tag}`);
40 }),
41 ...s.steps.flatMap(st => (st.tag === 'push' ? [st.push] : st.tag === 'concurrent' ? st.pushes : []).flatMap(p => p.updates.flatMap(u => [u.old, u.new]))).filter(e => e.tag === 'obj').map(e => e.name),
42 ...s.steps.flatMap(st => (st.tag === 'push' && st.fault.tag === 'race' ? st.fault.moves.map(m => m.to) : [])).filter(e => e.tag === 'obj').map(e => e.name),
43 ...s.steps.flatMap(st => (st.tag === 'fetch' ? [st.want] : [])),
44 ...s.steps.flatMap(st => (st.tag === 'push' && st.push.pack.tag === 'listed' ? st.push.pack.objects : [])),
45 ...s.final.flatMap(f => (f.tag === 'at' ? [f.at] : f.tag === 'one-of' ? f.names.filter(n => n !== ABSENT) : [])),
46 ];
47 for (const n of refs) assert.ok(defined.has(n), `${s.id}: ${n} is not a seed object`);
48 s.seed.objects.forEach((o, i) => { if (o.tag === 'commit' || o.tag === 'raw-commit') for (const p of o.parents) assert.ok(s.seed.objects.slice(0, i).some(x => x.name === p), `${s.id}: ${o.name}'s parent ${p} must come first`); });
49 s.expect.forEach((e, i) => assert.equal(e.tag === 'many', s.steps[i].tag === 'concurrent' || s.steps[i].tag === 'retry-unlanded', `${s.id}: step ${i}: a concurrent or retry step takes a multiset expectation`));
50 s.steps.forEach((st, i) => { if (st.tag === 'retry-unlanded') assert.ok(st.of < i && s.steps[st.of].tag === 'concurrent', `${s.id}: step ${i} retries an earlier concurrent step`); });
51 }
52 // and the other way: a matrix behaviour that cites this file has a scenario here
53 const probed = new Set(SCENARIOS.map(s => s.id.split('#')[0]));
54 const cites = b => [...b.tests, ...(b.status.tag === 'verified' ? b.status.evidence : []).filter(e => e.ref.tag === 'test').map(e => e.ref)].some(r => r.path === 'test/probes/probes.test.js');
55 for (const b of BEHAVIOURS) if (cites(b)) assert.ok(probed.has(b.id), `${b.id} cites test/probes/probes.test.js but has no scenario`);
56 for (const a of ALLOW) {
57 assert.ok(ids.includes(a.scenario), `allow entry for unknown scenario ${a.scenario}`);
58 assert.ok(a.reason.trim().length > 20, `allow entry ${a.scenario} ${a.pair} ${a.field}: say why`);
59 }
60});
62test('stock git porcelain is classified like ply: landed, partial, conflict, rejected, ambiguous', () => {
63 const line = (flag, ref, summary) => `${flag}\t${ref}:${ref}\t${summary}`;
64 const R = 'refs/heads/main', S = 'refs/heads/side';
65 assert.deepEqual(gitOutcome(0, `To x\n${line(' ', R, 'a..b')}\nDone\n`, '').outcome, 'landed');
66 assert.deepEqual(gitOutcome(0, `To x\n${line('=', R, '[up to date]')}\nDone\n`, '').outcome, 'landed');
67 assert.deepEqual(gitOutcome(1, `To x\n${line(' ', R, 'a..b')}\n${line('!', S, '[remote rejected] (failed to update ref)')}\nDone\n`, ''), { outcome: 'partial', error: 'push_partial', detail: 'failed to update ref' });
68 assert.equal(gitOutcome(1, `${line('!', R, '[remote rejected] (stale ref)')}\n`, '').error, 'cas_conflict', 'Artifacts wording');
69 assert.equal(gitOutcome(1, `${line('!', R, '[remote rejected] (incorrect old value provided)')}\n`, '').error, 'cas_conflict');
70 assert.deepEqual(gitOutcome(1, `${line('!', R, '[rejected] (stale info)')}\n`, ''), { outcome: 'conflict', error: 'cas_conflict', detail: 'stale info' }, 'git saw the other writer first');
71 assert.equal(gitOutcome(1, `${line('!', R, '[rejected] (fetch first)')}\n`, '').error, 'cas_conflict');
72 assert.equal(gitOutcome(1, `${line('!', R, '[rejected] (non-fast-forward)')}\n`, '', new Set([R])).error, 'cas_conflict', 'a create of a ref that exists');
73 assert.deepEqual(gitOutcome(1, `${line('!', R, '[remote rejected] (atomic push failure)')}\n${line('!', S, '[remote rejected] (failed to update ref)')}\n`, '').error, 'cas_conflict');
74 assert.equal(gitOutcome(1, `${line('!', R, '[remote rejected] (unpacker error)')}\n`, 'remote: fatal: pack exceeds maximum allowed size\n').error, 'limit_exceeded');
75 assert.equal(gitOutcome(1, `${line('!', R, '[remote rejected] (unpacker error)')}\n`, '').outcome, 'rejected');
76 assert.equal(gitOutcome(1, `${line('!', R, '[rejected] (non-fast-forward)')}\n`, '').error, 'not_fast_forward');
77 assert.deepEqual(gitOutcome(128, '', 'error: RPC failed; curl 52 Empty reply from server\nfatal: the remote end hung up unexpectedly\n').outcome, 'ambiguous');
78 assert.equal(plyOutcome({ ok: false, code: 'ambiguous', message: 'x' }).outcome, 'ambiguous');
79 assert.equal(plyOutcome({ ok: false, code: 'push_partial', message: 'x' }).outcome, 'partial');
80 assert.equal(plyOutcome({ ok: false, code: 'limit_exceeded', message: 'x' }).outcome, 'rejected');
81});
83// Synthetic observations: the evaluator's own rules, with no server.
84const S0 = SCENARIOS.find(s => s.id === 'push.fast-forward-update#plain');
85const end = refs => ({ head: 'refs/heads/main', refs, objects: [], trees: {}, ancestry: [], mergeBases: {}, fsck: [] });
86const obs = (outcome, error, refs) => ({ steps: [{ outcomes: [{ outcome, error, detail: '' }] }], end: end(refs) });
87const names = { a: 'base', b: 'ff' };
88test('triangulation: a server difference ply alone shows is unresolved; stock git reproducing it makes it a server bug; ply wrong on the reference is a client bug', () => {
89 const good = obs('landed', null, { 'refs/heads/main': 'b' });
90 const bad = obs('rejected', 'push_rejected', { 'refs/heads/main': 'a' });
91 const plyOnly = compareScenario(S0, { 'ref-ply': good, 'ref-git': good, 'art-ply': bad, 'art-git': good }, names);
92 const outcomeDiff = plyOnly.find(d => d.pair === 'art-ply~ref-ply' && d.field === 'outcome');
93 assert.equal(classify(S0, outcomeDiff, plyOnly).class, 'unresolved');
94 const both = compareScenario(S0, { 'ref-ply': good, 'ref-git': good, 'art-ply': bad, 'art-git': bad }, names);
95 assert.equal(classify(S0, both.find(d => d.pair === 'art-ply~ref-ply' && d.field === 'outcome'), both).class, 'server-bug');
96 const client = compareScenario(S0, { 'ref-ply': bad, 'ref-git': good }, names);
97 assert.equal(classify(S0, client.find(d => d.pair === 'ref-ply~expect'), client).class, 'client-bug');
98});
100test('allow-list: a listed difference is expected, an unlisted one is a finding, an unused entry is reported', () => {
101 const good = obs('landed', null, { 'refs/heads/main': 'b' });
102 const odd = obs('landed', null, { 'refs/heads/main': 'b' });
103 const diffs = compareScenario(S0, { 'ref-ply': good, 'ref-git': good, 'art-ply': { ...odd, end: { ...odd.end, head: null } }, 'art-git': good }, names);
104 const d = diffs.find(x => x.field === 'head' && x.pair === 'art-ply~ref-ply');
105 const entry = { scenario: S0.id, pair: d.pair, field: d.field, left: d.left, right: d.right, reason: 'synthetic: the server names no HEAD symref in this made-up case' };
106 const stale = { ...entry, field: 'refs', reason: 'synthetic: an entry no difference uses must be reported' };
107 const evaluated = [{ scenario: S0.id, pairs: evaluablePairs({ 'ref-ply': good, 'ref-git': good, 'art-ply': good, 'art-git': good }) }];
108 const v = judge(SCENARIOS, diffs, [entry, stale], evaluated);
109 assert.equal(v.expected.filter(e => e.difference === d).length, 1);
110 assert.ok(!v.findings.some(f => f.field === 'head' && f.pair === 'art-ply~ref-ply'));
111 assert.ok(v.findings.some(f => f.pair === 'art-ply~art-git' && f.field === 'head'), 'the cross-client pair is still a finding');
112 assert.deepEqual(v.unused, [stale]);
113 // reference-only runs do not evaluate Artifacts pairs, so an Artifacts entry is not "unused" there
114 assert.deepEqual(judge(SCENARIOS, [], [entry], [{ scenario: S0.id, pairs: ['ref-ply~ref-git', 'ref-ply~expect', 'ref-git~expect'] }]).unused, []);
115});
117test('claims: a client that says landed when the refs do not show it is a finding', () => {
118 const said = obs('landed', null, { 'refs/heads/main': 'a' }); // landed, but main is still base
119 const good = obs('landed', null, { 'refs/heads/main': 'b' });
120 const d = compareScenario(S0, { 'ref-ply': good, 'ref-git': good, 'art-ply': good, 'art-git': said }, names);
121 const c = d.find(x => x.pair === 'art-git~claims');
122 assert.equal(c.left, 'push 0 landed: refs/heads/main=base');
123 assert.equal(classify(S0, c, d).class, 'server-bug');
124 assert.deepEqual(compareScenario(S0, { 'ref-ply': good }, names).filter(x => x.field === 'claims'), []);
125});
127test('solo (one corner, the workbench): ply against the server read against the stated expectation', () => {
128 const good = obs('landed', null, { 'refs/heads/main': 'b' });
129 assert.deepEqual(soloDiffs(S0, good, names), [], 'a run that meets the expectation has no difference');
130 const bad = obs('rejected', 'push_rejected', { 'refs/heads/main': 'a' });
131 const d = soloDiffs(S0, bad, names);
132 assert.deepEqual(d.map(x => `${x.pair} ${x.field} ${x.left} | ${x.right}`), [
133 'art-ply~expect outcome s0=rejected | s0=landed',
134 'art-ply~expect error s0=push_rejected | s0=null',
135 'art-ply~expect expectation refs/heads/main=base | refs/heads/main=ff',
136 ]);
137 // a solo difference reads as the art-ply~ref-ply difference a full run records, so it is classified (unresolved:
138 // stock git did not run) and the same allow entries cover it
139 const full = compareScenario(S0, { 'ref-ply': good, 'art-ply': bad }, names).filter(x => x.pair === 'art-ply~ref-ply' && (x.field === 'outcome' || x.field === 'error'));
140 assert.deepEqual(full.map(x => [x.field, x.left, x.right]), d.slice(0, 2).map(x => [x.field, x.left, x.right]));
141 assert.equal(classify(S0, d[0], d).class, 'unresolved');
142 const entry = { scenario: S0.id, pair: 'art-ply~ref-ply', field: 'error', left: 's0=push_rejected', right: 's0=null', reason: 'synthetic: an entry written for a full run' };
143 const v = judge(SCENARIOS, d, [entry], [{ scenario: S0.id, pairs: ['art-ply~expect', 'art-ply~claims'] }]);
144 assert.equal(v.expected.length, 1);
145 assert.equal(v.findings.length, 2);
146 const lied = soloDiffs(S0, obs('landed', null, { 'refs/heads/main': 'a' }), names);
147 assert.ok(lied.some(x => x.pair === 'art-ply~claims' && x.left === 'push 0 landed: refs/heads/main=base'));
148 // the stated expectation of the size probe meets the allow entry ply already keeps for it
149 const size = SCENARIOS.find(s => s.id === 'push.size-limits#pack-over-cap');
150 const sd = soloDiffs(size, { steps: [{ outcomes: [{ outcome: 'rejected', error: 'limit_exceeded', detail: '' }] }], end: end({ 'refs/heads/main': 'a' }) }, names);
151 assert.equal(judge(SCENARIOS, sd, ALLOW, [{ scenario: size.id, pairs: ['art-ply~expect'] }]).findings.length, 0);
152});
154let ref;
155before(async () => { ref = await startReference(); });
156after(async () => { await ref.close(); });
158const diffs = [], evaluated = [];
159for (const s of SCENARIOS) {
160 test(`probe ${s.id}: ply and stock git against the reference meet the expectation and leave the same repository`, async () => {
161 const runs = {}; let names = {};
162 for (const t of ['ref-ply', 'ref-git'].filter(x => runsFor(s, x === 'ref-git' ? 'git' : 'ply'))) {
163 const root = mkdtempSync(join(tmpdir(), 'ply-probe-'));
164 try {
165 const repo = await ref.repo(s);
166 const r = await runScenario(s, { name: t, client: t.slice(4), proxy: ref.proxy, repoPath: repo.repoPath }, { tracer: newTracer().tracer, root });
167 runs[t] = r.observation; names = r.byOid;
168 // every planned fault fired
169 for (const st of r.observation.steps) for (const o of st.outcomes) assert.doesNotMatch(o.detail, /never fired/, `${s.id} ${t}`);
170 } finally { rmSync(root, { recursive: true, force: true }); }
171 }
172 const d = compareScenario(s, runs, names);
173 diffs.push(...d); evaluated.push({ scenario: s.id, pairs: evaluablePairs(runs) });
174 const v = judge(SCENARIOS, d, ALLOW, [{ scenario: s.id, pairs: evaluablePairs(runs) }]);
175 assert.deepEqual(v.findings, [], `${s.id}: findings against the reference`);
176 });
179test('either: any listed answer meets the step, as one outcome/error pair (a git-version-dependent refusal)', () => {
180 const df = SCENARIOS.find(s => s.id === 'refs.directory-file-conflict#file-then-dir');
181 assert.equal(df.expect[0].tag, 'either');
182 const steps = (outcome, error) => ({ steps: [{ outcomes: [{ outcome, error, detail: '' }] }], end: end({ 'refs/heads/main': 'a', 'refs/heads/a': 'a' }) });
183 const stepDiffs = o => soloDiffs(df, o, names).filter(x => x.field === 'outcome' || x.field === 'error').map(x => `${x.field} ${x.left} | ${x.right}`);
184 assert.deepEqual(stepDiffs(steps('conflict', 'cas_conflict')), [], 'git 2.47: failed to update ref');
185 assert.deepEqual(stepDiffs(steps('rejected', 'push_rejected')), [], 'git >= 2.51: refname conflict');
186 // a pair taken half from each listed answer meets neither
187 assert.deepEqual(stepDiffs(steps('conflict', 'push_rejected')), ['outcome s0=conflict | s0=conflict|rejected', 'error s0=push_rejected | s0=cas_conflict|push_rejected']);
188 assert.deepEqual(stepDiffs(steps('landed', null)), ['outcome s0=landed | s0=conflict|rejected', 'error s0=null | s0=cas_conflict|push_rejected']);
189 const ref = o => compareScenario(df, { 'ref-ply': o }, names).filter(x => x.pair === 'ref-ply~expect' && x.left.startsWith('s0=')).map(x => `${x.left} | ${x.right}`);
190 assert.deepEqual(ref(steps('rejected', 'push_rejected')), []);
191 assert.deepEqual(ref(steps('landed', null)), ['s0=landed/null | s0=conflict/cas_conflict|rejected/push_rejected']);
192});
194test('the proxy reads the per-command push report, inside side-band 1 or bare', () => {
195 const pkt = (s) => { const b = Buffer.from(s, 'latin1'); return Buffer.concat([Buffer.from((b.length + 4).toString(16).padStart(4, '0')), b]); };
196 const status = Buffer.concat([pkt('unpack ok\n'), pkt('ok refs/heads/a\n'), pkt('ng refs/heads/a/b failed to update ref\n'), Buffer.from('0000')]);
197 const want = ['unpack ok', 'ok refs/heads/a', 'ng refs/heads/a/b failed to update ref'];
198 assert.deepEqual(reportOf(status), want);
199 assert.deepEqual(reportOf(Buffer.concat([pkt('\x02progress\n'), pkt(`\x01${status.toString('latin1')}`), Buffer.from('0000')])), want);
200 assert.deepEqual(reportOf(Buffer.alloc(0)), []);
201 assert.deepEqual(reportOf(Buffer.from('0010ERR refused\n')), []);
202});
204test('no allow entry is unused on the reference pairs', () => {
205 assert.deepEqual(judge(SCENARIOS, diffs, ALLOW, evaluated).unused, []);
206});
Diagnostics7 git calls · 232 ms
CallStatusSizeTime0232 ms
discover200191 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=191
git.server.agent=git/github-9922ec520325-Linux
git.server.object_format=sha1
git.server.caps=agent ls-refs fetch server-option object-format
git.server.fetch=shallow wait-for-done filter
git.protocol.version=2
git.pkt.frames=9
git.pkt.data=7
git.pkt.flush=2
git.pkt.delim=0
git.pkt.bytes=191
git.pkt.payload.max=36
ls-refs20012 KiB · hit2 ms
git.upload-pack ls-refs
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=ls-refs
git.upstream.dur_ms=2
git.response.bytes=11990
git.response.cache=HIT
git.response.duration_ms=2
git.protocol.version=2
git.pkt.frames=152
git.pkt.data=151
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=11990
git.pkt.payload.max=122
git.ls_refs.count=151
git.ls_refs.head=refs/heads/main
fetchtree:0 · deepen 102004.2 KiB · hit14 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=14
git.response.bytes=4347
git.response.cache=HIT
git.response.duration_ms=14
git.fetch.filter=tree:0
git.fetch.wants=19912563f540228593df0c489082e5e2508e21e4
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=7
git.pkt.data=5
git.pkt.flush=1
git.pkt.delim=1
git.pkt.bytes=4347
git.pkt.payload.max=4247
git.sideband.band1.bytes=4247
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=10
git.pack.bytes=4247
git.pack.ofs_delta=0
git.pack.ref_delta=0
git.pack.chain.max=0
git.pack.trailer=a6caf8e129bea82c9bae4cbc7c130c9205add400
git.pack.full=10
Open pack map
fetchtree:0200919 B · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=919
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=800d30ba8923860bfc460ca884b7f9ba22083588
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=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=919
git.pkt.payload.max=892
git.sideband.band1.bytes=892
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=892
git.pack.trailer=5323b9266eea5ded637285d1c5320699f12be76e
Open pack map
fetchtree:02005.6 KiB · hit2 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=2
git.response.bytes=5724
git.response.cache=HIT
git.response.duration_ms=2
git.fetch.filter=tree:0
git.fetch.wants=58fabb6768b3f737ee9cd8bac647bdc27405fb4d
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=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=5724
git.pkt.payload.max=5697
git.sideband.band1.bytes=5697
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=5697
git.pack.trailer=be7e0453974a5fe832f9065a33bb7e3434c10e9b
Open pack map
fetchtree:0200305 B · 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=305
git.response.cache=HIT
git.response.duration_ms=3
git.fetch.filter=tree:0
git.fetch.wants=facf357dda5424ce8c1bda8ebca6cacc9b5bfc3a
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=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=305
git.pkt.payload.max=278
git.sideband.band1.bytes=278
git.sideband.band2.bytes=0
git.sideband.band3.bytes=0
git.pack.objects=1
git.pack.bytes=278
git.pack.trailer=36c263093b3db739addfdbaa3928c1028217ea9e
Open pack map
fetch2005.0 KiB209 ms
git.upload-pack fetch
http.response.status_code=200
git.upstream.cf_ray=-
git.upstream.phase=fetch
git.upstream.dur_ms=209
git.response.bytes=5082
git.response.cache=MISS
git.response.duration_ms=209
git.fetch.wants=fb32a6a3185c148bdea1e27bca90510701f0e166
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=4
git.pkt.data=3
git.pkt.flush=1
git.pkt.delim=0
git.pkt.bytes=5082
git.pkt.payload.max=5055
git.sideband.band1.bytes=5055
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://github.com/ivarvong/ply
Ref
refs/heads/main
Commit
19912563f540228593df0c489082e5e2508e21e4
cf-ray
a5e2ff5fdcf3f3c9
Request
ade49afa…
Protocol
v2 · sha1
Agent
git/github-9922ec520325-Linux
Filter
advertised
Fetch
shallow wait-for-done filter
Capabilities
agent ls-refs fetch server-option object-format