main
1import { readFile } from 'node:fs/promises'
2import { join } from 'node:path'
3import { CLEANUP_FILE, cleanupLeakNames } from './cleanup.ts'
4import type { CdConfig } from './config.ts'
5import { cfOk, ROOT } from './cf.ts'
6import { fullSplit, isTrafficSplit, versionsFromList, type VersionShare } from './deploy-plan.ts'
7import { asRecord, extractJson } from './json.ts'
8import { isoOffset, type RunLog } from './log.ts'
9import { liveVerdict, nextPhase, pipelineStart, type PhaseOutcome, type PipelineState } from './pipeline-plan.ts'
10import { errorMessage } from './proc.ts'
11import { liveSmokeAlreadyPassed, reconcile, reconcileReason, type Reconcile } from './reconcile.ts'
12import { checkoutReason, readCheckout, releasePair, releaseTag, type ReleaseId } from './release.ts'
13import { fail, type Fail, type StageResult } from './result.ts'
14import { confirmRoute, failureFault, logRoute, ROUTE_TUNABLES, SYSTEM_ROUTE_IO, type RouteIo, type RouteTunables } from './route-confirm.ts'
15import { writeJson } from './run-dir.ts'
16import { stageBump } from './stage-bump.ts'
17import { stageDeploy } from './stage-deploy.ts'
18import { stageRamp } from './stage-ramp.ts'
19import { stageRollback } from './stage-rollback.ts'
20import { stageSmoke } from './stage-smoke.ts'
21import { reportPath, stageTelemetry } from './stage-telemetry.ts'
22import { stageVisual } from './stage-visual.ts'
23import { readDeployment } from './traffic.ts'
25export type PipelineExit = {
26 readonly code: number
27 readonly reason: string | null
28}
30async function recordedProbeLoss(runDir: string): Promise<readonly { readonly percent: number; readonly count: number; readonly rate: number; readonly ids: readonly string[] }[]> {
31 let text: string
32 try {
33 text = await readFile(join(runDir, 'ramp.json'), 'utf8')
34 } catch {
35 return []
36 }
37 let value: unknown
38 try {
39 value = JSON.parse(text) as unknown
40 } catch {
41 return []
42 }
43 const rec = asRecord(value)
44 if (!rec || !Array.isArray(rec.probeLoss)) return []
45 const rows: { readonly percent: number; readonly count: number; readonly rate: number; readonly ids: readonly string[] }[] = []
46 for (const item of rec.probeLoss) {
47 const row = asRecord(item)
48 if (!row) continue
49 const ids = Array.isArray(row.ids) ? row.ids.filter(id => typeof id === 'string') : []
50 if (typeof row.percent !== 'number' || typeof row.count !== 'number' || typeof row.rate !== 'number') continue
51 rows.push({ percent: row.percent, count: row.count, rate: row.rate, ids })
52 }
53 return rows
54}
56async function recordedCleanupLeaks(runDir: string): Promise<readonly string[]> {
57 let text: string
58 try {
59 text = await readFile(join(runDir, CLEANUP_FILE), 'utf8')
60 } catch {
61 return []
62 }
63 try {
64 return cleanupLeakNames(JSON.parse(text) as unknown)
65 } catch {
66 return []
67 }
68}
70function outcomeOf(result: StageResult<unknown>): PhaseOutcome {
71 if (result.kind === 'pass') return 'pass'
72 if (result.fault === 'harness_fault' || result.fault === 'harness_unhealthy') return 'harness-stop'
73 if (result.fault === 'state_conflict') return 'state-conflict'
74 return result.rolledBack ? 'rolled-back' : 'fail'
75}
77async function plyMergedAt(sha: string): Promise<string | null> {
78 try {
79 const response = await fetch(`https://api.github.com/repos/ivarvong/ply/commits/${sha}`, {
80 headers: { accept: 'application/vnd.github+json', 'user-agent': 'ply-web-cd' },
81 })
82 if (!response.ok) return null
83 const body = await response.json() as { commit?: { committer?: { date?: unknown } } }
84 const date = body.commit?.committer?.date
85 return typeof date === 'string' ? date : null
86 } catch {
87 return null
88 }
89}
91async function previousFromDeploy(runDir: string, version: string): Promise<string | null> {
92 try {
93 const rec = asRecord(JSON.parse(await readFile(join(runDir, 'deploy.json'), 'utf8')))
94 if (!rec || rec.kind !== 'pass') return null
95 const value = asRecord(rec.value)
96 if (!value || value.version !== version || typeof value.previous !== 'string' || value.previous === '') return null
97 return value.previous
98 } catch {
99 return null
100 }
101}
103async function readReconcile(config: CdConfig, release: ReleaseId, runLog: RunLog): Promise<Reconcile> {
104 const at = Date.now()
105 const pair = releasePair(release)
106 const tag = releaseTag(release)
107 let versionId: string | null = null
108 let split: VersionShare[] = []
109 let liveSmokePassed = false
110 let error: string | null = null
111 let versions: ReturnType<typeof versionsFromList> = []
112 try {
113 const listed = await cfOk(['workers', 'versions', 'list', '--worker-id', config.worker, '--page', '1', '--per-page', '100'])
114 let payload: unknown = listed
115 try {
116 payload = extractJson(listed)
117 } catch {
118 payload = listed
119 }
120 versions = versionsFromList(payload)
121 versionId = versions.find(version => version.tag === tag)?.id ?? null
122 split = (await readDeployment(config.worker)).versions.map(share => ({ versionId: share.versionId, percentage: share.percentage }))
123 if (versionId) liveSmokePassed = await liveSmokeAlreadyPassed(config.runRoot, versionId)
124 } catch (caught) {
125 error = errorMessage(caught)
126 }
127 const decision = error
128 ? { stage: 'refuse' as const, reason: error }
129 : reconcile({ release, versions, split, liveSmokePassed, rampPercents: config.policy.steps.map(step => step.percent) })
130 runLog.useStage('reconcile')
131 const ref = await runLog.observation({
132 measurement: {
133 source: 'reconcile',
134 sha: release.ply,
135 release: pair,
136 versionId,
137 split,
138 liveSmokePassed,
139 ...(error ? { error } : {}),
140 },
141 query: { source: 'cf workers deployments list', worker: config.worker, tag },
142 from: at,
143 to: Date.now(),
144 raw: JSON.stringify({ release: pair, versionId, split, liveSmokePassed, error }),
145 })
146 await runLog.decision({
147 inputs: [ref],
148 rules: [{ name: 'reconcile', value: decision.stage }],
149 outcome: decision.stage === 'refuse' ? 'harness_fault' : 'advance',
150 reason: reconcileReason(decision),
151 })
152 return decision
153}
155function jumpedState(next: Exclude<Reconcile, { stage: 'upload' | 'refuse' }>): PipelineState {
156 switch (next.stage) {
157 case 'smoke-canary':
158 return { phase: 'smoke-canary', smoke: null }
159 case 'ramp':
160 return { phase: 'ramp', smoke: 'pass' }
161 case 'smoke-live':
162 return { phase: 'smoke-live', smoke: 'pass' }
163 case 'done':
164 return { phase: 'done', smoke: 'pass' }
165 }
166}
168async function span<T>(log: RunLog, name: string, fn: () => Promise<T>): Promise<T> {
169 log.useStage(name)
170 const started = Date.now()
171 try {
172 return await fn()
173 } finally {
174 log.addStage({
175 name,
176 startedAt: isoOffset(new Date(started)),
177 finishedAt: isoOffset(new Date()),
178 durationMs: Date.now() - started,
179 })
180 }
181}
183/**
184 * Unpinned traffic serves `version` on every fresh connection (route-confirm.ts). Null when confirmed; otherwise the
185 * Fail that liveVerdict judges: a routing failure is a harness fault (halt), a 5xx served by `version` or answers with
186 * no version header are the Worker (rollback; ply-web#146).
187 */
188export async function liveRoute(
189 config: Pick<CdConfig, 'baseUrl'>,
190 opts: { readonly version: string; readonly log: (line: string) => void },
191 io: RouteIo = SYSTEM_ROUTE_IO,
192 tunables: RouteTunables = ROUTE_TUNABLES,
193): Promise<Fail | null> {
194 const started = io.now()
195 const verdict = await confirmRoute({ url: `${config.baseUrl}/`, version: opts.version, headers: {}, since: started }, io, tunables)
196 opts.log(await logRoute({ purpose: 'live', version: opts.version, since: started, started }, verdict))
197 if (verdict.kind === 'confirmed') return null
198 return fail('smoke', `live: ${verdict.reason}; prod is already at 100% on ${opts.version}`, false, failureFault(verdict))
199}
201/**
202 * After promotion: the live lifecycle smoke and its telemetry, beside the CDP visual smoke.
203 * Each failure is returned in the order the checks finished; a pass is an empty list.
204 */
205async function liveChecks(
206 config: CdConfig,
207 runLog: RunLog,
208 opts: { readonly version: string; readonly token: string; readonly runDir: string; readonly log: (line: string) => void },
209): Promise<readonly StageResult<unknown>[]> {
210 // The split write returns before every colo serves it (98.74% at 100% on run 2026-11-06T20-11-49-685Z). The unpinned
211 // smoke asserts x-ply-version, so first confirm unpinned traffic the same way the pin is confirmed (route-confirm.ts:
212 // fresh connections, a sustained all-new window). A routing failure is a harness fault, never a product verdict; a 5xx
213 // served by the new version is the Worker and rolls back (ply-web#146).
214 const smokeAndTelemetry = async (): Promise<StageResult<unknown>[]> => {
215 const route = await liveRoute(config, opts)
216 if (route !== null) {
217 opts.log(`smoke: ${route.reason}`)
218 return [route]
219 }
220 const started = Date.now()
221 const smoke = await span(runLog, 'smoke-live', () => stageSmoke(config, { version: opts.version, pin: false, token: opts.token, runDir: opts.runDir }))
222 if (smoke.kind === 'fail') {
223 opts.log(`smoke: ${smoke.reason}`)
224 return [smoke]
225 }
226 const telemetry = await span(runLog, 'telemetry-live', () => stageTelemetry(config, {
227 version: opts.version,
228 since: started,
229 reportPath: reportPath(opts.runDir, true),
230 runDir: opts.runDir,
231 live: true,
232 }))
233 await writeJson(opts.runDir, 'live-telemetry-stage.json', telemetry, [opts.token])
234 if (telemetry.kind === 'fail') opts.log(`telemetry: ${telemetry.reason}`)
235 else opts.log(telemetry.value.line)
236 return [smoke, telemetry]
237 }
238 const visual = async (): Promise<StageResult<unknown>[]> => {
239 const result = await span(runLog, 'visual', () => stageVisual(config, { runDir: opts.runDir, version: opts.version }))
240 opts.log(result.kind === 'pass' ? (result.value.skipped ? `visual: skipped (${result.value.skipped})` : `visual smoke: ${result.value.pages} views ok`) : `visual: ${result.reason}`)
241 return [result]
242 }
243 const settled = await Promise.all([smokeAndTelemetry(), visual()])
244 return settled.flat()
245}
247export async function runPipeline(
248 config: CdConfig,
249 opts: {
250 readonly token: string
251 readonly sha: string | null
252 readonly noBump: boolean
253 /** A 0% version this run may replace in the canary slot (`--replace-canary <id>`). Null refuses any foreign one. */
254 readonly replaceCanary: string | null
255 readonly release: ReleaseId
256 readonly log: (line: string) => void
257 readonly runDir: string
258 readonly runLog: RunLog
259 },
260): Promise<PipelineExit> {
261 const runDir = opts.runDir
262 const runLog = opts.runLog
263 runLog.patch({ plySha: opts.release.ply, plyWebSha: opts.release.web, release: releasePair(opts.release) })
264 opts.log(`run: ${runDir}`)
265 let state = pipelineStart()
266 let failure: Fail | null = null
267 let version = ''
268 let previous = ''
269 let fromPercent: number | undefined
270 let reconciled = false
271 const note = async (result: StageResult<unknown>) => {
272 if (result.kind === 'fail' && !failure) {
273 failure = result
274 if (!runLog.facts.failedAt) runLog.patch({ failedAt: isoOffset(new Date()) })
275 if (result.rolledBack) {
276 runLog.patch({ rolledBack: true, rollbackReason: result.reason, restoredAt: isoOffset(new Date()) })
277 }
278 runLog.patch({ fault: result.fault })
279 await runLog.error(result.reason, { stage: result.stage, rolledBack: result.rolledBack, fault: result.fault })
280 }
281 }
282 const rampOpts = () => ({
283 version,
284 previous,
285 verdictPath: join(runDir, 'telemetry.json'),
286 runDir,
287 token: opts.token,
288 log: opts.log,
289 ...(fromPercent === undefined ? {} : { fromPercent }),
290 })
291 while (state.phase !== 'halt' && state.phase !== 'done') {
292 if (state.phase === 'bump') {
293 if (opts.noBump) {
294 const at = Date.now()
295 const ref = await runLog.observation({
296 measurement: { source: 'bump', skipped: true },
297 query: { source: 'no-bump' },
298 from: at,
299 to: at,
300 raw: '{"noBump":true}',
301 })
302 await runLog.decision({
303 inputs: [ref],
304 rules: [{ name: 'no_bump', value: 1 }],
305 outcome: 'advance',
306 reason: 'no-bump: deploy the current main as it is',
307 })
308 state = nextPhase(state, 'pass')
309 continue
310 }
311 const result = await span(runLog, 'bump', () => stageBump(config, opts.sha))
312 await writeJson(runDir, 'bump.json', result)
313 await note(result)
314 if (result.kind === 'pass' && result.value.sha !== opts.release.ply) {
315 await note(fail('bump', 'bad-ply-sha: bump resolved a different ply sha than this release', false, 'harness_fault'))
316 state = { phase: 'halt', smoke: null }
317 continue
318 }
319 if (result.kind === 'pass') {
320 runLog.patch({ plySha: result.value.sha, plyMergedAt: await plyMergedAt(result.value.sha) })
321 } else opts.log(`bump: ${result.reason}`)
322 state = nextPhase(state, outcomeOf(result))
323 continue
324 }
325 if (state.phase === 'deploy-canary') {
326 if (!reconciled) {
327 reconciled = true
328 const checkout = await readCheckout(ROOT)
329 if (!checkout.ok || checkout.web !== opts.release.web) {
330 const reason = !checkout.ok
331 ? checkoutReason(checkout)
332 : `checkout-unavailable: HEAD ${checkout.web} is not the release ply-web sha`
333 await note(fail('deploy-canary', reason, false, 'harness_fault'))
334 state = { phase: 'halt', smoke: null }
335 continue
336 }
337 const next = await readReconcile(config, opts.release, runLog)
338 opts.log(`reconcile: ${reconcileReason(next)}`)
339 if (next.stage === 'refuse') {
340 await note(fail('deploy-canary', next.reason, false, 'harness_fault'))
341 state = { phase: 'halt', smoke: null }
342 continue
343 }
344 if (next.stage !== 'upload') {
345 version = next.versionId
346 runLog.patch({ versionId: version })
347 opts.log(`version: ${version}`)
348 if (next.stage === 'smoke-canary' || next.stage === 'ramp') {
349 previous = next.previous
350 opts.log(`previous: ${previous}`)
351 }
352 if (next.stage === 'smoke-live') {
353 previous = await previousFromDeploy(runDir, next.versionId) ?? ''
354 if (previous) opts.log(`previous: ${previous}`)
355 }
356 if (next.stage === 'ramp') fromPercent = next.percent
357 state = jumpedState(next)
358 continue
359 }
360 }
361 const result = await span(runLog, 'deploy-canary', () => stageDeploy(config, opts.release, { replaceCanary: opts.replaceCanary }))
362 await writeJson(runDir, 'deploy.json', result, [opts.token])
363 await note(result)
364 if (result.kind === 'pass') {
365 version = result.value.version
366 previous = result.value.previous
367 runLog.patch({ versionId: version })
368 opts.log(`version: ${version}`)
369 opts.log(`previous: ${previous}`)
370 } else opts.log(`deploy-canary: ${result.reason}`)
371 state = nextPhase(state, outcomeOf(result))
372 continue
373 }
374 if (state.phase === 'smoke-canary' || state.phase === 'smoke-live') {
375 const live = state.phase === 'smoke-live'
376 const started = Date.now()
377 const result = await span(runLog, live ? 'smoke-live' : 'smoke', () => stageSmoke(config, { version, pin: !live, token: opts.token, runDir }))
378 await note(result)
379 if (result.kind === 'fail') opts.log(`smoke: ${result.reason}`)
380 state = nextPhase(state, outcomeOf(result))
381 if (state.phase === 'telemetry-canary' || state.phase === 'telemetry-live') {
382 const telemetry = await span(runLog, live ? 'telemetry-live' : 'telemetry', () => stageTelemetry(config, {
383 version,
384 since: started,
385 reportPath: reportPath(runDir, live),
386 runDir,
387 live,
388 }))
389 await writeJson(runDir, live ? 'live-telemetry-stage.json' : 'telemetry-stage.json', telemetry, [opts.token])
390 await note(telemetry)
391 if (telemetry.kind === 'fail') opts.log(`telemetry: ${telemetry.reason}`)
392 else opts.log(telemetry.value.line)
393 state = nextPhase(state, outcomeOf(telemetry))
394 }
395 continue
396 }
397 if (state.phase === 'ramp') {
398 // The stepped ramp is the only promotion path (Ivar, 2026-11-08: "Ramp should be the only option."). The live
399 // smoke, its telemetry (with the rate gate) and the visual smoke start the moment the 100% step's split is written
400 // and run during that step's dwell, which is the live watch: a new-version regression in it rolls back.
401 let live: Promise<readonly StageResult<unknown>[]> | null = null
402 const result = await span(runLog, 'ramp', () => stageRamp(config, rampOpts(), {
403 policy: config.policy,
404 onApplied: percent => {
405 if (percent < 100 || live) return
406 const last = config.policy.steps[config.policy.steps.length - 1]
407 opts.log(`ramp: ${version} at 100% (previous ${previous}); live watch ${last ? last.dwellMs : 0} ms beside live smoke + visual smoke`)
408 live = liveChecks(config, runLog, { version, token: opts.token, runDir, log: opts.log })
409 },
410 }))
411 const promoted: Promise<readonly StageResult<unknown>[]> | null = live
412 if (result.kind === 'fail') {
413 // Settle the live checks before the verdict so nothing writes into a sealed log; the watch decided.
414 if (promoted) await promoted
415 await note(result)
416 opts.log(`ramp: ${result.reason}`)
417 state = nextPhase(state, outcomeOf(result))
418 continue
419 }
420 runLog.patch({ liveAt: isoOffset(new Date()) })
421 // A resumed run whose 100% split was already in place still calls onApplied; this is the belt to that brace.
422 const checks = await (promoted === null ? liveChecks(config, runLog, { version, token: opts.token, runDir, log: opts.log }) : promoted)
423 // A Worker failure in any live check rolls back; a harness fault stops with the new version live and says so.
424 const verdict = liveVerdict(checks)
425 const decisive = checks.find(check => check.kind === 'fail' && (verdict !== 'rollback' || check.fault === 'worker'))
426 if (decisive) await note(decisive)
427 state = { phase: verdict, smoke: state.smoke }
428 continue
429 }
430 if (state.phase === 'rollback') {
431 const expected = fullSplit(version)
432 const prior = isTrafficSplit(expected) ? expected.versions : []
433 const result = await span(runLog, 'rollback', () => stageRollback(config, previous, prior))
434 await writeJson(runDir, 'rollback.json', result)
435 if (result.kind === 'pass') {
436 runLog.patch({ rolledBack: true, rollbackReason: failure?.reason ?? null, restoredAt: isoOffset(new Date()) })
437 if (failure) {
438 const current: Fail = failure
439 failure = { ...current, rolledBack: true }
440 }
441 }
442 if (result.kind === 'fail') {
443 const reason = failure ? `${failure.reason}; ${result.reason}` : result.reason
444 const fault = result.fault === 'state_conflict' ? 'state_conflict' : 'worker'
445 failure = fail(failure?.stage ?? 'rollback', reason, false, fault)
446 runLog.patch({ fault, failedAt: runLog.facts.failedAt ?? isoOffset(new Date()) })
447 await runLog.error(result.reason, { stage: 'rollback' })
448 opts.log(`rollback: ${result.reason}`)
449 }
450 state = nextPhase(state, outcomeOf(result))
451 continue
452 }
453 state = { phase: 'halt', smoke: state.smoke }
454 }
455 const fault = failure === null ? null : failure.fault
456 const verdictKind = fault === 'harness_fault'
457 ? 'harness_fault' as const
458 : fault === 'state_conflict'
459 ? 'state_conflict' as const
460 : fault === 'insufficient_samples'
461 ? 'insufficient_samples' as const
462 : fault === 'harness_unhealthy'
463 ? 'harness_unhealthy' as const
464 : 'fail' as const
465 const probeLoss = await recordedProbeLoss(runDir)
466 const cleanupLeak = await recordedCleanupLeaks(runDir)
467 const verdict = failure
468 ? { kind: verdictKind, version, previous, stage: failure.stage, reason: failure.reason, rolledBack: failure.rolledBack, fault: failure.fault, failures: [failure.reason], probe_loss: probeLoss, cleanup_leak: cleanupLeak }
469 : { kind: 'pass' as const, version, previous, failures: [] as string[], probe_loss: probeLoss, cleanup_leak: cleanupLeak }
470 await writeJson(runDir, 'verdict.json', verdict, [opts.token])
471 if (failure) {
472 const label = failure.fault === 'worker' ? 'FAIL' : failure.fault
473 opts.log(`cd: ${label} ${failure.stage}: ${failure.reason}`)
474 return { code: 1, reason: `${failure.stage}: ${failure.reason}` }
475 }
476 opts.log(`cd: PASS ${version} ply ${opts.release.ply} web ${opts.release.web}`)
477 return { code: 0, reason: null }
478}
Diagnostics4 git calls · 363 ms
CallStatusSizeTime0363 ms
discover200152 B3 ms
git.upload-pack discover http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs 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 · hit3 ms
git.upload-pack ls-refs http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=ls-refs git.upstream.dur_ms=3 git.response.bytes=145 git.response.cache=HIT git.response.duration_ms=3 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=61Open pack map
fetch2005.8 KiB357 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=357 git.response.bytes=5891 git.response.cache=MISS git.response.duration_ms=357 git.fetch.wants=bcf0ac0dd6021c9e6285e7c053bb8b464a2e4641 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=5891 git.pkt.payload.max=5870 git.sideband.band1.bytes=5869 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
- a5e2fe2edfbcf3c9
- Request
- 928b9599…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format