main
1// One command for the worker-mem harness: build ply, bundle + deploy ply-memlab, run every cell N times, capture heap
2// profiles under load, join each request to its Workers Observability invocation, and write reports/<run>.{json,md}.
3//
4// npm run build && node bench/worker-mem/run.mjs [--runs 10] [--profiles 10] [--cells scan,read,bomb,index,pushpack]
5// [--no-deploy] [--pending on] [--o11y-wait 90]
6// Needs .data/seed.json from seed.mjs. See README.md.
7import { spawnSync } from 'node:child_process';
8import { mkdirSync, readFileSync, writeFileSync, rmSync, existsSync } from 'node:fs';
9import { join } from 'node:path';
10import { parseArgs } from 'node:util';
11import { buildOutput, CPU_LIMIT_MS } from './build.mjs';
12import { revokeAll, mint } from './seed.mjs';
13import { DATA, REPORTS, ROOT, WORKER, HERE, NAMESPACE, cfRaw, cfJson, memlabToken, writeSecret, sleep, stamp, quantiles, redact } from './lib.mjs';
15const { values: args } = parseArgs({
16 options: {
17 runs: { type: 'string', default: '10' },
18 profiles: { type: 'string', default: '10' },
19 cells: { type: 'string', default: 'scan,read,bomb,bombworker,index,pushpack' },
20 'no-deploy': { type: 'boolean', default: false },
21 pending: { type: 'string', default: 'off' },
22 'o11y-wait': { type: 'string', default: '90' },
23 url: { type: 'string', default: process.env.MEMLAB_URL ?? '' },
24 },
25});
26const RUNS = Number(args.runs);
27const PROFILES = Number(args.profiles);
28const run = `ml-${stamp().toLowerCase()}`;
29const seed = JSON.parse(readFileSync(join(DATA, 'seed.json'), 'utf8'));
30if (seed.state !== 'seeded') throw new Error('seed repo is not seeded (run seed.mjs)');
31const bearer = memlabToken();
32mkdirSync(REPORTS, { recursive: true });
33const log = (...a) => console.log(redact(a.join(' ')));
35// The cells: route + query. bombworker is the bomb under WORKER_LIMITS.
36const CELL_QUERY = {
37 scan: { route: 'scan', q: { repo: seed.name, remote: seed.remote, commit: seed.head } },
38 // The same scan with a heap profile captured while it runs. Reported apart: profiling adds overhead.
39 scanprofiled: { route: 'scan', q: { repo: seed.name, remote: seed.remote, commit: seed.head } },
40 read: { route: 'read', q: { repo: seed.name, remote: seed.remote, blob: seed.blob } },
41 bomb: { route: 'bomb', q: { declared: String(1024 ** 3) } },
42 bombworker: { route: 'bomb', q: { declared: String(1024 ** 3), limits: 'worker' } },
43 index: { route: 'index', q: { repo: seed.name, remote: seed.remote, commit: seed.head } },
44 pushpack: { route: 'pushpack', q: { repo: seed.name, remote: seed.remote } },
45 // resolve: spool once, resolve N times, delete the spooled object (the bucket stays).
46 spool: { route: 'spool', q: { repo: seed.name, remote: seed.remote, commit: seed.head, key: `${run}.pack` } },
47 resolve: { route: 'resolve', q: { commit: seed.head, key: `${run}.pack` } },
48 spooldel: { route: 'spooldel', q: { key: `${run}.pack` } },
49};
51function versionsTagged(tag) {
52 const listed = cfJson(['workers', 'versions', 'list', '--worker-id', WORKER, '--page', '1', '--per-page', '20']);
53 const items = Array.isArray(listed) ? listed : (listed?.items ?? listed?.result ?? []);
54 const hit = items.find(v => JSON.stringify(v).includes(tag));
55 return hit?.id ?? null;
56}
58async function deploy() {
59 const sh = spawnSync('npm', ['run', 'build'], { cwd: ROOT, encoding: 'utf8' });
60 if (sh.status !== 0) throw new Error(`npm run build failed: ${sh.stderr.slice(0, 400)}`);
61 // The last commit that touched ply's source (src/): the harness's own commits (bench/, package.json scripts) are not ply.
62 const plySha = spawnSync('git', ['log', '-1', '--format=%H', '--', 'src'], { cwd: ROOT, encoding: 'utf8' }).stdout.trim();
63 const built = await buildOutput({ pendingCells: args.pending, plySha });
64 const secrets = join(DATA, 'secrets.json');
65 writeSecret(secrets, JSON.stringify({ MEMLAB_TOKEN: bearer }));
66 let r;
67 try {
68 r = cfRaw(['deploy', '--prebuilt', '--secrets-file', secrets, '--tag', run, '--message', `memlab ${run} ply ${plySha.slice(0, 12)}`], { cwd: HERE });
69 } finally { rmSync(secrets, { force: true }); }
70 if (r.code !== 0) throw new Error(`cf deploy failed: ${r.stderr.slice(0, 800)} ${redact(r.stdout).slice(-800)}`);
71 const out = `${r.stdout}\n${r.stderr}`;
72 const url = args.url || (out.match(/https:\/\/ply-memlab\.[a-z0-9-]+\.workers\.dev/) ?? [])[0];
73 const version = (out.match(/Version ID:\s*([0-9a-f-]{36})/i) ?? [])[1] ?? versionsTagged(run);
74 if (!url || !version) throw new Error(`deploy output had no url/version: ${redact(out).slice(-1200)}`);
75 for (let i = 0; i < 60; i++) {
76 const h = await fetch(`${url}/health`).catch(() => null);
77 if (h && h.headers.get('x-memlab-version') === version) return { url, version, plySha, cpuLimitMs: CPU_LIMIT_MS, bundleBytes: built.bundleBytes };
78 await sleep(2000);
79 }
80 throw new Error(`version ${version} never answered /health at ${url}`);
81}
83async function current() {
84 const url = args.url;
85 if (!url) throw new Error('--no-deploy needs --url or MEMLAB_URL');
86 const h = await fetch(`${url}/health`);
87 return { url, version: h.headers.get('x-memlab-version'), plySha: h.headers.get('x-memlab-ply'), cpuLimitMs: Number(h.headers.get('x-memlab-cpu-limit-ms')) || null, bundleBytes: null };
88}
90async function callCell(target, name, i, extra = {}) {
91 const { route, q } = CELL_QUERY[name];
92 const qs = new URLSearchParams({ ...q, ...extra, run, i: String(i), label: name });
93 const t0 = Date.now();
94 const startedAt = new Date().toISOString();
95 let res;
96 try {
97 res = await fetch(`${target.url}/cell/${route}?${qs}`, { headers: { authorization: `Bearer ${bearer}` } });
98 } catch (e) {
99 return { cell: name, i, ok: false, clientError: String(e), clientMs: Date.now() - t0, startedAt };
100 }
101 const ray = res.headers.get('cf-ray');
102 const text = await res.text().catch(e => `{"final":true,"ok":false,"clientError":${JSON.stringify(String(e))}}`);
103 const lines = text.split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return { raw: l.slice(0, 200) }; } });
104 const final = lines.find(l => l.final) ?? { ok: false, truncated: true, status: res.status, tail: text.slice(-300) };
105 return { ...final, cell: name, i, status: res.status, ray, clientMs: Date.now() - t0, progressLines: lines.filter(l => l.progress).length, startedAt, endedAt: new Date().toISOString() };
106}
108// Heap profiles: start a scan (cell `scanprofiled`), capture `cf workers versions profile --profile-type heap` while it
109// runs, and record the overlap. The profiled scans go into the results under their own label.
110async function profiles(target, n, results) {
111 const dir = join(REPORTS, `${run}-profiles`);
112 mkdirSync(dir, { recursive: true });
113 const env = { ...process.env };
114 delete env.CLOUDFLARE_API_TOKEN;
115 const out = [];
116 for (let k = 0; k < n; k++) {
117 const scan = callCell(target, 'scanprofiled', k);
118 await sleep(4000);
119 const file = join(dir, `heap-${k}.pb`);
120 let captured = null;
121 let window = null;
122 for (let attempt = 1; attempt <= 3 && !captured; attempt++) {
123 const t0 = new Date().toISOString();
124 const r = spawnSync('cf', ['workers', 'versions', 'profile', target.version, '--worker-id', WORKER, '--profile-type', 'heap', '--duration-ms', '10000'], { env, maxBuffer: 256 * 1024 * 1024 });
125 window = { from: t0, to: new Date().toISOString(), attempt };
126 if (r.status === 0 && r.stdout.length > 0) { writeFileSync(file, r.stdout); captured = file; } else { log(`profile ${k} attempt ${attempt}: ${String(r.stderr).slice(0, 200)}`); await sleep(2000); }
127 }
128 const s = await scan;
129 results.push(s);
130 const overlapped = Boolean(captured && window && s.startedAt <= window.from && (s.endedAt ?? '') >= window.to);
131 out.push({ k, file: captured, window, overlapped, scan: { i: s.i, ok: s.ok, packBytes: s.packBytes, wallMs: s.wallMs, startedAt: s.startedAt, endedAt: s.endedAt, version: s.version, ray: s.ray }, ...(captured ? pprofTotals(captured) : {}) });
132 log(`profile ${k}: ${captured ? 'captured' : 'failed'} overlapped=${overlapped} scan ok=${s.ok} pack=${s.packBytes}`);
133 }
134 return out;
135}
137// Totals per sample type from `go tool pprof -top` (the "of X total" line), in bytes.
138function pprofTotals(file) {
139 const res = {};
140 const toBytes = s => {
141 const m = /^([\d.]+)([kMG]?B)$/.exec(s);
142 if (!m) return null;
143 return Math.round(Number(m[1]) * ({ B: 1, kB: 1024, MB: 1024 ** 2, GB: 1024 ** 3 })[m[2]]);
144 };
145 for (const idx of ['inuse_space', 'alloc_space', 'space']) {
146 const r = spawnSync('go', ['tool', 'pprof', `-sample_index=${idx}`, '-top', '-nodecount=8', file], { encoding: 'utf8' });
147 const m = /of ([\d.]+[kMG]?B) total/.exec(r.stdout ?? '');
148 if (m) res[idx] = toBytes(m[1]);
149 if (idx === 'alloc_space') res[`${idx}_top`] = (r.stdout ?? '').split('\n').slice(0, 14).join('\n');
150 }
151 return res;
152}
154// Every invocation of this version in the window, joined to cells by the worker's `memlab` log line (same request id).
155async function o11y(target, from, to) {
156 const page = offset => {
157 const body = { queryId: 'ply-memlab', timeframe: { from, to }, view: 'events', limit: 2000, ...(offset ? { offset } : {}),
158 parameters: { filters: [{ key: '$metadata.service', operation: 'eq', type: 'string', value: WORKER }] } };
159 const r = cfRaw(['o11y', 'telemetry', 'query', '--body', JSON.stringify(body)]);
160 if (r.code !== 0) throw new Error(`o11y query failed: ${r.stderr.slice(0, 300)}`);
161 const d = JSON.parse(r.stdout.slice(r.stdout.indexOf('{')));
162 return d?.events?.events ?? [];
163 };
164 const events = [];
165 for (let offset = null, n = 0; n < 20; n++) {
166 const got = page(offset);
167 events.push(...got);
168 if (got.length < 2000) break;
169 offset = got[got.length - 1]?.$metadata?.id;
170 }
171 const byReq = new Map();
172 for (const e of events) {
173 const id = e.$metadata?.requestId ?? e.$workers?.requestId;
174 if (!id) continue;
175 const slot = byReq.get(id) ?? {};
176 const w = e.$workers ?? {};
177 if (typeof w.cpuTimeMs === 'number' || typeof w.wallTimeMs === 'number') Object.assign(slot, { cpuMs: w.cpuTimeMs, wallMs: w.wallTimeMs, outcome: w.outcome, version: w.scriptVersion?.id });
178 const msg = e.source?.message ?? e.$metadata?.message ?? '';
179 const src = typeof e.source === 'object' && e.source?.memlab ? e.source : null;
180 const parsed = src ?? (() => { try { const j = JSON.parse(msg); return j.memlab ? j : null; } catch { return null; } })();
181 if (parsed) Object.assign(slot, { cell: parsed.label, run: parsed.run, i: parsed.i });
182 byReq.set(id, slot);
183 }
184 const rows = [...byReq.values()].filter(r => r.run === run && (!r.version || r.version === target.version));
185 return { events: events.length, rows, sample: events.find(e => e.$workers?.cpuTimeMs !== undefined) ?? events[0] ?? null };
186}
188function summarize(target, results, telemetry, profs) {
189 const cells = {};
190 for (const name of new Set(results.map(r => r.cell))) {
191 const rs = results.filter(r => r.cell === name);
192 const tel = telemetry.rows.filter(r => r.cell === name && rs.some(x => x.i === r.i));
193 cells[name] = {
194 n: rs.length,
195 ok: rs.filter(r => r.ok).length,
196 pending: rs.filter(r => r.pending).length,
197 why: rs.find(r => r.pending)?.why ?? null,
198 errors: [...new Set(rs.filter(r => r.error).map(r => `${r.error.code}: ${String(r.error.message).slice(0, 160)}`))],
199 workerWallMs: quantiles(rs.map(r => r.wallMs ?? r.scanMs)),
200 clientMs: quantiles(rs.map(r => r.clientMs)),
201 cpuMs: quantiles(tel.map(r => r.cpuMs)),
202 platformWallMs: quantiles(tel.map(r => r.wallMs)),
203 outcomes: tel.reduce((a, r) => ({ ...a, [r.outcome]: (a[r.outcome] ?? 0) + 1 }), {}),
204 telemetryJoined: tel.length,
205 packBytes: quantiles(rs.map(r => r.packBytes)),
206 inflated: quantiles(rs.map(r => r.inflated)),
207 objects: quantiles(rs.map(r => r.objects)),
208 bytes: quantiles(rs.map(r => r.bytes)),
209 maxChunk: quantiles(rs.map(r => r.maxChunk)),
210 };
211 }
212 // cf's heap profile is allocation sampling (alloc_objects / alloc_space over the capture window), not in-use memory.
213 const heap = {
214 captured: profs.filter(p => p.file).length,
215 overlapped: profs.filter(p => p.overlapped).map(p => p.k),
216 allocatedBytesPerCapture: quantiles(profs.map(p => p.alloc_space)),
217 };
218 return { run, version: target.version, url: target.url, plySha: target.plySha, cpuLimitMs: target.cpuLimitMs, seed: { name: seed.name, head: seed.head, objects: seed.objects, localPackBytes: seed.localPackBytes }, cells, heap };
219}
221function markdown(s, profs) {
222 const fmt = q => (q ? `${q.p50} / ${q.p90} / ${q.max} (n=${q.n})` : '—');
223 const L = [`# ply-memlab ${s.run}`, '', `Version \`${s.version}\`, ply \`${s.plySha ?? '?'}\`, configured CPU limit ${s.cpuLimitMs ?? '?'} ms per request, seed \`${s.seed.name}\` (head ${s.seed.head?.slice(0, 12)}, ${s.seed.objects} objects, local pack ${s.seed.localPackBytes} B).`, '',
224 '| cell | ok / n | CPU ms p50/p90/max | platform wall ms | in-worker wall ms | outcomes | errors |', '|---|---|---|---|---|---|---|'];
225 for (const [name, c] of Object.entries(s.cells)) L.push(`| ${name} | ${c.ok} / ${c.n}${c.pending ? ` (pending: ${c.why})` : ''} | ${fmt(c.cpuMs)} | ${fmt(c.platformWallMs)} | ${fmt(c.workerWallMs)} | ${JSON.stringify(c.outcomes)} | ${c.errors.join('; ') || '—'} |`);
226 L.push('', '| cell | pack bytes p50 | inflated p50 | objects p50 | max chunk p50 |', '|---|---|---|---|---|');
227 for (const [name, c] of Object.entries(s.cells)) L.push(`| ${name} | ${c.packBytes?.p50 ?? c.bytes?.p50 ?? '—'} | ${c.inflated?.p50 ?? '—'} | ${c.objects?.p50 ?? '—'} | ${c.maxChunk?.p50 ?? '—'} |`);
228 L.push('', `Heap profiles (version \`${s.version}\`, each during a \`scanprofiled\` run): ${s.heap.captured}/${profs.length} captured, overlapping runs ${JSON.stringify(s.heap.overlapped)}; bytes allocated per 10 s capture (allocation sampling, not in-use memory) ${fmt(s.heap.allocatedBytesPerCapture)}.`);
229 if (s.relay) L.push('', `pushpack destination \`${s.relay.dst}\`: verify ${JSON.stringify(s.relay.verify)}; cleanup ${JSON.stringify(s.relay.cleanup)}.`);
230 const top = profs.find(p => p.alloc_space_top);
231 if (top) L.push('', '```', top.alloc_space_top, '```');
232 return `${L.join('\n')}\n`;
233}
235// pushpack: a throwaway destination repo, one relay request per seed commit (in order), then a stock git clone of the
236// destination with fsck --strict, then the repo and every token on it are removed.
237function createDst() {
238 const name = `ply-memlab-dst-${run}`;
239 const c = cfJson(['artifacts', 'namespaces', 'repos', 'create', NAMESPACE, '--name', name, '--default-branch', 'main', '--description', 'ply bench/worker-mem pushpack destination (deleted after the run)']);
240 const remote = c.remote ?? c.result?.remote;
241 if (!/^https:\/\/[a-z0-9]+\.artifacts\.cloudflare\.net\/git\//.test(remote ?? '')) throw new Error('dst create returned no remote');
242 revokeAll(name);
243 return { name, remote };
244}
246function verifyDst(dst) {
247 const t = mint(dst.name, 'read', 1800);
248 const auth = join(DATA, 'verify-auth.gitconfig');
249 writeSecret(auth, `[http]\n\textraHeader = Authorization: Basic ${Buffer.from(`x:${t.token}`).toString('base64')}\n`);
250 const dir = join(DATA, 'verify.git');
251 rmSync(dir, { recursive: true, force: true });
252 const g = (cwd, a) => spawnSync('git', a, { cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
253 const out = { cloned: false };
254 try {
255 const t0 = Date.now();
256 const c = g(DATA, ['-c', `include.path=${auth}`, 'clone', '--mirror', '--quiet', dst.remote, dir]);
257 out.cloneMs = Date.now() - t0;
258 out.cloned = c.status === 0;
259 if (!out.cloned) { out.cloneError = redact(c.stderr).slice(0, 400); return out; }
260 const f = g(dir, ['fsck', '--strict', '--no-dangling']);
261 out.fsck = { status: f.status, stderr: redact(f.stderr).slice(0, 400) };
262 out.head = g(dir, ['rev-parse', 'refs/heads/main']).stdout.trim();
263 out.headMatches = out.head === seed.head;
264 out.objects = g(dir, ['rev-list', '--objects', '--all']).stdout.trim().split('\n').length;
265 out.objectsMatch = out.objects === seed.objects;
266 out.treeMatches = g(dir, ['rev-parse', `${seed.head}^{tree}`]).stdout.trim().length === 40;
267 return out;
268 } finally {
269 rmSync(auth, { force: true });
270 rmSync(dir, { recursive: true, force: true });
271 }
272}
274function deleteDst(dst) {
275 const revoked = revokeAll(dst.name);
276 const r = cfRaw(['artifacts', 'namespaces', 'repos', 'delete', dst.name, '--namespace', NAMESPACE, '--force']);
277 return { revoked, deleted: r.code === 0, error: r.code === 0 ? null : r.stderr.slice(0, 200) };
278}
280const target = args['no-deploy'] ? await current() : await deploy();
281log(`run ${run} version ${target.version} url ${target.url}`);
282const from = Date.now() - 60_000;
283const results = [];
284let relay = null;
285for (const name of args.cells.split(',').filter(Boolean)) {
286 if (name === 'resolve') {
287 const sp = await callCell(target, 'spool', 0);
288 results.push(sp);
289 log(`spool: ok=${sp.ok} size=${sp.size} parts=${sp.parts} client=${sp.clientMs} ${sp.error ? JSON.stringify(sp.error).slice(0, 240) : ''}`);
290 try {
291 if (sp.ok) {
292 for (let i = 0; i < RUNS; i++) {
293 const r = await callCell(target, 'resolve', i);
294 results.push(r);
295 log(`resolve #${i}: ok=${r.ok} unknownType=${r.unknownType} unknownOid=${r.unknownOid} indexUnknown=${r.indexUnknown} held=${r.indexHeldBytes}+${r.resolvedHeldBytes} client=${r.clientMs} ${r.error ? JSON.stringify(r.error).slice(0, 240) : ''}`);
296 }
297 }
298 } finally {
299 const del = await callCell(target, 'spooldel', 0);
300 results.push(del);
301 log(`spooldel: ok=${del.ok} existed=${del.existed}`);
302 }
303 continue;
304 }
305 if (name === 'pushpack') {
306 const commits = seed.pushes ?? [];
307 const dst = createDst();
308 relay = { dst: dst.name, commits: commits.length };
309 try {
310 for (let i = 0; i < Math.min(RUNS, commits.length); i++) {
311 const r = await callCell(target, name, i, { dst: dst.name, dstRemote: dst.remote, old: i ? commits[i - 1].sha : '0'.repeat(40), new: commits[i].sha });
312 results.push(r);
313 log(`pushpack #${i}: ok=${r.ok}${r.pending ? ' pending' : ''} pack=${r.packBytes} client=${r.clientMs} ${r.error ? JSON.stringify(r.error).slice(0, 240) : ''}`);
314 if (r.pending || !r.ok) break;
315 }
316 const pushedAll = results.filter(r => r.cell === 'pushpack' && r.ok).length === commits.length;
317 relay.verify = pushedAll ? verifyDst(dst) : { skipped: 'not every commit was relayed' };
318 log(`pushpack verify: ${JSON.stringify(relay.verify).slice(0, 400)}`);
319 } finally {
320 relay.cleanup = deleteDst(dst);
321 log(`pushpack cleanup: ${JSON.stringify(relay.cleanup)}`);
322 }
323 continue;
324 }
325 for (let i = 0; i < RUNS; i++) {
326 const r = await callCell(target, name, i);
327 results.push(r);
328 log(`${name} #${i}: ok=${r.ok}${r.pending ? ' pending' : ''} wall=${r.wallMs ?? r.scanMs ?? '-'} client=${r.clientMs} ${r.error ? JSON.stringify(r.error).slice(0, 200) : ''}`);
329 if (r.pending) break;
330 }
331}
332const profs = PROFILES > 0 ? await profiles(target, PROFILES, results) : [];
333log(`waiting ${args['o11y-wait']} s for Workers Observability ingest`);
334await sleep(Number(args['o11y-wait']) * 1000);
335const telemetry = await o11y(target, from, Date.now());
336const summary = { ...summarize(target, results, telemetry, profs), relay };
337const base = join(REPORTS, run);
338writeFileSync(`${base}.json`, JSON.stringify({ summary, results, profiles: profs.map(({ alloc_space_top: _a, ...p }) => p), telemetry: { events: telemetry.events, rows: telemetry.rows, sample: telemetry.sample } }, null, 1));
339writeFileSync(`${base}.md`, markdown(summary, profs));
340log(`report ${base}.md`);
341if (!existsSync(`${base}.md`)) process.exit(1);
Diagnostics4 git calls · 438 ms
CallStatusSizeTime0438 ms
discover200152 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=3 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 B · 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=145 git.response.cache=HIT git.response.duration_ms=2 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 1020038 KiB · hit7 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=428 git.response.bytes=38434 git.response.cache=HIT git.response.duration_ms=7 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=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=6 git.pkt.data=4 git.pkt.flush=1 git.pkt.delim=1 git.pkt.bytes=38434 git.pkt.payload.max=38339 git.sideband.band1.bytes=38338 git.sideband.band2.bytes=0 git.sideband.band3.bytes=0 git.pack.objects=63 git.pack.bytes=38338 git.pack.ofs_delta=0 git.pack.ref_delta=8 git.pack.chain.max=8 git.pack.trailer=0bc36ab7adf82d3109177f11f1ea93f1ce071f77 git.pack.full=55Open pack map
fetch2007.0 KiB428 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=7123 git.response.cache=MISS git.response.duration_ms=428 git.fetch.wants=417f7a3c68a1cf07d02cf0c868d10f1982ec7d6a 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=7123 git.pkt.payload.max=7102 git.sideband.band1.bytes=7101 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.git
- Ref
- refs/heads/main
- Commit
- 19912563f540228593df0c489082e5e2508e21e4
- cf-ray
- a5e3362aae1224ce
- Request
- d563da6f…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format