main
1// scripts/calibrate (issue #73): the statistics are pure and run on a recorded query response; the query adapter runs
2// through the CD's own cf path with a fake runner. No credentials, no network.
3//
4// test/fixtures/calibrate/spans.json is shaped like a `cf o11y telemetry query` events page (events.events[], each with
5// `source`, `dataset`, `timestamp`, `$metadata`), as test/fixtures/cd/canary-spans.json recorded from prod: its first
6// event is that file's real runtime fetch span, unchanged. The ply spans after it carry ply's attributes as single
7// dotted keys under `source`; the request spans at the end carry theirs nested by dot, the way the runtime nests its own
8// (`source.http.response.status_code`). The statistics read both shapes.
9import assert from 'node:assert/strict'
10import { readFileSync } from 'node:fs'
11import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
12import { tmpdir } from 'node:os'
13import { join } from 'node:path'
14import { test } from 'node:test'
15import { useCfRunner, type CfResult } from '../scripts/cd/cf.ts'
16import { TELEMETRY_PAGE } from '../scripts/cd/baseline.ts'
17import { unwrapEvents } from '../scripts/cd/telemetry.ts'
18import { driftMarkdown, evaluate, fixtureEvents, parseArgs, parseDuration } from '../scripts/calibrate/main.ts'
19import { checkBands, citationFor, readRegistry, type Metric } from '../scripts/calibrate/provenance.ts'
20import { citedQuery, DEFAULT_CALIBRATE_ROUTES, NOISY_ROUTES, querySpanEvents, slices, spanFilters } from '../scripts/calibrate/query.ts'
21import {
22 ALL_ROUTES,
23 API_GROUP,
24 bucketUpper,
25 calibrationStats,
26 distribution,
27 EVERYTHING,
28 eventAttributes,
29 flattenAttributes,
30 groupOf,
31 numericOf,
32 log2Histogram,
33 statsText,
34 UNROUTED,
35 type CalibrationStats,
36 type Distribution,
37 type GroupStats,
38} from '../scripts/calibrate/stats.ts'
40const FIXTURE_PATH = new URL('./fixtures/calibrate/spans.json', import.meta.url)
41const FIXTURE_TEXT = readFileSync(FIXTURE_PATH, 'utf8')
42const EVENTS = unwrapEvents(JSON.parse(FIXTURE_TEXT))
43const V1 = 'bb0907e1-99f6-4a4f-8254-841909b33bdf'
44const V2 = '19ee3cab-0000-4000-8000-000000000002'
46/** One attribute's distribution; a missing one fails the test here, not as a TypeError later. */
47function dist(stats: CalibrationStats, route: string, attribute: string): Distribution {
48 const found = numericOf(stats, route, attribute)
49 assert.ok(found, `${route} ${attribute}`)
50 return found
51}
53function group(stats: CalibrationStats, route: string): GroupStats {
54 const found = groupOf(stats, route)
55 assert.ok(found, route)
56 return found
57}
59test('distribution: n, observed percentiles (the CD\'s floor((n-1)p) rule), max, and a log2 histogram', () => {
60 const values = Array.from({ length: 1000 }, (_, i) => i + 1)
61 const dist = distribution(values)
62 assert.ok(dist)
63 assert.deepEqual([dist.n, dist.min, dist.p50, dist.p90, dist.p99, dist.p999, dist.max], [1000, 1, 500, 900, 990, 999, 1000])
64 assert.equal(distribution([]), null)
65 assert.equal(distribution([Number.NaN]), null)
66 const one = distribution([7])
67 assert.ok(one)
68 assert.deepEqual([one.n, one.p50, one.p999, one.max], [1, 7, 7, 7])
69 assert.deepEqual([0, 0.5, 1, 1.5, 2, 3, 1024, 1025, -3].map(bucketUpper), [1, 1, 1, 2, 2, 4, 1024, 2048, 0])
70 assert.deepEqual(log2Histogram([0, 1, 2, 3, 4, 5, 1000]), [{ upper: 1, count: 2 }, { upper: 2, count: 1 }, { upper: 4, count: 2 }, { upper: 8, count: 1 }, { upper: 1024, count: 1 }])
71 assert.equal(dist.histogram.reduce((sum, bucket) => sum + bucket.count, 0), 1000)
72})
74test('attributes are read as dotted keys or nested objects; a literal dotted key wins', () => {
75 assert.deepEqual(flattenAttributes({ git: { pack: { bytes: 3 } }, 'git.ls_tree.entries': 9, http: { response: { status_code: 200 } } }), {
76 'git.pack.bytes': 3,
77 'git.ls_tree.entries': 9,
78 'http.response.status_code': 200,
79 })
80 assert.deepEqual(flattenAttributes({ 'git.pack.bytes': 5, git: { pack: { bytes: 4 } } }), { 'git.pack.bytes': 5 })
81 // The real runtime fetch span: no ply.route, so unrouted; the version is the runtime's own script version.
82 const fetch = eventAttributes(EVENTS[0])
83 assert.ok(fetch)
84 assert.equal(fetch.route, UNROUTED)
85 assert.equal(fetch.version, V1)
86 assert.equal(eventAttributes({ $metadata: {} }), null)
87})
89test('the fixture window, per route: every input attribute\'s distribution, categorical counts, versions', () => {
90 const stats = calibrationStats(EVENTS)
91 assert.equal(stats.events, EVENTS.length)
92 assert.deepEqual(stats.groups.map(group => group.route), [ALL_ROUTES, API_GROUP, 'GET /v1/refs', 'GET /v1/tree', 'POST /v1/edit', UNROUTED, 'viewer'])
93 const tree = group(stats, 'GET /v1/tree')
94 assert.deepEqual(tree.versions, [V2, V1].sort())
95 const entries = dist(stats, 'GET /v1/tree', 'git.ls_tree.entries')
96 assert.deepEqual([entries.n, entries.p50, entries.p90, entries.p99, entries.p999, entries.max], [120, 60, 108, 118, 119, 120])
97 assert.equal(numericOf(stats, 'GET /v1/tree', 'git.protocol.version'), null, 'a protocol constant is not an input distribution')
98 assert.deepEqual(tree.categorical['git.response.cache'], { MISS: 80, HIT: 40 })
99 assert.deepEqual(tree.categorical['git.ls_tree.outcome'], { ok: 117, error: 3 })
100 assert.deepEqual(tree.categorical['error.type'], { not_found: 3 })
101 // Request spans (nested attributes): the route's counts and its status and error code.
102 const refs = group(stats, 'GET /v1/refs')
103 assert.equal(dist(stats, 'GET /v1/refs', 'ply.spans').n, 5)
104 assert.deepEqual(refs.categorical['http.response.status_code'], { 200: 4, 404: 1 })
105 assert.deepEqual(refs.categorical['ply.error.code'], { not_found: 1 })
106 // `api` is every /v1 route; `*` adds the viewer and unrouted spans.
107 assert.equal(dist(stats, API_GROUP, 'git.pack.bytes').n, 120)
108 assert.equal(dist(stats, ALL_ROUTES, 'git.pack.bytes').n, 130)
109 // A long tail: p99.9 and max differ on a small n only by the floor rule.
110 const push = dist(stats, 'POST /v1/edit', 'git.push.pack.bytes')
111 assert.deepEqual([push.n, push.p50, push.max], [40, 332, 2 ** 20])
112})
114test('route, version and attribute filters', () => {
115 const v2 = calibrationStats(EVENTS, { ...EVERYTHING, versions: [V2] })
116 assert.equal(v2.events, 80)
117 assert.equal(dist(v2, 'GET /v1/tree', 'git.ls_tree.entries').min, 81)
118 const only = calibrationStats(EVENTS, { ...EVERYTHING, routes: ['viewer'], attributes: ['git.pack.chain.max'] })
119 assert.deepEqual(only.groups.map(group => group.route), [ALL_ROUTES, API_GROUP, 'viewer'])
120 assert.deepEqual(Object.keys(group(only, 'viewer').numeric), ['git.pack.chain.max'])
121 assert.equal(group(only, API_GROUP).events, 0)
122})
124test('the printed report has, per route and attribute, n, p50/p90/p99/p99.9 and max, and the histogram', () => {
125 const text = statsText(calibrationStats(EVENTS), { from: 0, to: 1000 })
126 assert.match(text, /^calibrate: 1970-01-01T00:00:00\.000Z \.\. 1970-01-01T00:00:01\.000Z span events=296 skipped=0$/m)
127 assert.match(text, /^route GET \/v1\/tree events=240 /m)
128 assert.match(text, /^ {4}git\.ls_tree\.entries n=120 p50=60 p90=108 p99=118 p99\.9=119 max=120$/m)
129 assert.match(text, /^ {6}<= +128 +56 #+$/m)
130 assert.match(text, /^ {4}git\.response\.cache MISS=80 HIT=40$/m)
131 assert.doesNotMatch(statsText(calibrationStats(EVENTS), { from: 0, to: 1000 }, false), /<=/)
132})
134const METRIC: Metric = { attribute: 'git.ls_tree.entries', route: 'GET /v1/tree', quantile: 0.99, headroom: 2, band: 2 }
136function registry(entries: Record<string, unknown>, minN = 30) {
137 const parsed = readRegistry({ minN: { value: minN, status: 'PRIOR (uncalibrated)', why: 'test' }, thresholds: entries })
138 assert.deepEqual(parsed.problems, [])
139 return parsed.registry
140}
142const CITED = { status: 'calibrated', source: 'run x', query: 'q', window: 'w', date: '2026-11-01', n: 120, percentile: 'p99', headroom: 'x2' }
144test('bands: tight below the observed quantile; drift outside band x headroom; priors report a suggestion', () => {
145 const stats = calibrationStats(EVENTS)
146 // p99 of entries is 118; suggested is 236; the band is 118..472.
147 const results = checkBands(registry({
148 'a:ok': { ...CITED, value: 236, metric: METRIC },
149 'a:loose': { ...CITED, value: 1000, metric: METRIC },
150 'a:tight': { ...CITED, value: 100, metric: METRIC },
151 'a:prior': { value: 5000, status: 'PRIOR (uncalibrated)', why: 'test', metric: METRIC },
152 'a:prior-tight': { value: 50, status: 'PRIOR (uncalibrated)', why: 'test', metric: METRIC },
153 'a:thin': { ...CITED, value: 10, metric: { ...METRIC, route: 'viewer', attribute: 'git.pack.chain.max' } },
154 'a:none': { value: 1, status: 'PRIOR (uncalibrated)', why: 'no metric' },
155 }), stats)
156 assert.deepEqual(results.map(r => [r.key, r.verdict]), [
157 ['a:loose', 'drift'],
158 ['a:ok', 'ok'],
159 ['a:prior', 'uncalibrated'],
160 ['a:prior-tight', 'tight'],
161 ['a:thin', 'insufficient'],
162 ['a:tight', 'tight'],
163 ])
164 const line = (key: string): string => {
165 const found = results.find(r => r.key === key)
166 assert.ok(found, key)
167 return found.line
168 }
169 assert.equal(line('a:loose'), 'drift a:loose=1000 git.ls_tree.entries@GET /v1/tree q0.99: n=120 observed=118 suggested=236 (x2); outside 118..472')
170 assert.equal(line('a:thin'), 'insufficient a:thin=10 git.pack.chain.max@viewer q0.99: n=10 < 30')
171})
173test('a citation block cites the query, window, date, n, percentile and headroom', () => {
174 const stats = calibrationStats(EVENTS)
175 const query = citedQuery({ worker: 'ply', from: Date.parse('2026-11-01T00:00:00Z'), to: Date.parse('2026-11-08T00:00:00Z'), sliceMs: 3_600_000, routes: null, includeNoisy: false })
176 const block = citationFor({ metric: METRIC, stats, query, from: query.timeframe.from, to: query.timeframe.to, source: 'scripts/calibrate test' })
177 assert.ok(block)
178 assert.equal(block.value, 236)
179 assert.equal(block.n, 120)
180 assert.equal(block.date, '2026-11-08')
181 assert.equal(block.window, '2026-11-01T00:00:00.000Z..2026-11-08T00:00:00.000Z')
182 assert.equal(block.percentile, 'git.ls_tree.entries @ GET /v1/tree q0.99 = 118')
183 assert.match(String(block.query), /"\$metadata\.type".*"span"/)
184 // The block is itself a valid calibrated entry.
185 assert.deepEqual(readRegistry({ minN: { value: 1, status: 'PRIOR (uncalibrated)', why: 't' }, thresholds: { 'a:b': block } }).problems, [])
186 assert.equal(citationFor({ metric: { ...METRIC, attribute: 'git.nope' }, stats, query, from: 0, to: 1, source: 's' }), null)
187})
189test('the query adapter slices the window and pages each slice through cf o11y telemetry query', async () => {
190 assert.deepEqual(slices(0, 250, 100), [{ from: 0, to: 100 }, { from: 100, to: 200 }, { from: 200, to: 250 }])
191 assert.throws(() => slices(10, 10, 5), /end after/)
192 assert.throws(() => slices(0, 10, 0), /positive/)
193 const bodies: Record<string, unknown>[] = []
194 // A full first page forces a second page (the CD's cursor rule); then a short page ends the slice.
195 const full = { events: { events: Array.from({ length: TELEMETRY_PAGE }, (_, i) => ({ ...(EVENTS[1] as object), $metadata: { id: `page-${i}`, type: 'span' } })), count: TELEMETRY_PAGE } }
196 try {
197 let calls = 0
198 useCfRunner(async (args): Promise<CfResult> => {
199 assert.deepEqual(args.slice(0, 4), ['o11y', 'telemetry', 'query', '--body'])
200 const body = JSON.parse(String(args[4])) as Record<string, unknown>
201 bodies.push(body)
202 calls += 1
203 // A banner before the JSON, as cf prints one; the second call times out once and is retried.
204 if (calls === 2) return { code: 1, stdout: '', stderr: 'APIError: timeout Envelope Error' }
205 const page = calls === 1 ? JSON.stringify(full) : FIXTURE_TEXT
206 return { code: 0, stdout: `cf o11y\n${page}`, stderr: '' }
207 })
208 const retry = { bound: { attempts: 3, backoffMs: 1 }, sleep: async () => {}, note: async () => {} }
209 const events = await querySpanEvents({ worker: 'ply', from: 0, to: 7_200_000, sliceMs: 3_600_000, routes: null, includeNoisy: false }, retry)
210 assert.equal(events.length, TELEMETRY_PAGE + 2 * EVENTS.length)
211 } finally {
212 useCfRunner(null)
213 }
214 assert.equal(bodies.length, 4)
215 const firstBody = bodies[0]
216 assert.ok(firstBody)
217 const filters = (firstBody.parameters as { filters: unknown[] }).filters
218 assert.deepEqual(filters, [
219 { key: '$metadata.service', operation: 'eq', type: 'string', value: 'ply' },
220 { key: '$metadata.type', operation: 'eq', type: 'string', value: 'span' },
221 { key: 'ply.route', operation: 'in', type: 'string', value: DEFAULT_CALIBRATE_ROUTES.join(',') },
222 ])
223 assert.deepEqual(bodies.map(body => body.timeframe), [{ from: 0, to: 3_600_000 }, { from: 0, to: 3_600_000 }, { from: 0, to: 3_600_000 }, { from: 3_600_000, to: 7_200_000 }])
224 assert.equal(bodies[1].offset, `page-${TELEMETRY_PAGE - 2}`, 'stepped back one id: the cursor is the last id that differs from the page tail')
225})
227test('cli arguments: window, filters, and errors', () => {
228 const now = Date.parse('2026-11-08T00:00:00Z')
229 const args = parseArgs(['--since', '7d', '--route', 'GET /v1/tree', '--route', 'viewer', '--check'], now, {})
230 assert.equal(args.to - args.from, 7 * 86_400_000)
231 assert.deepEqual(args.routes, ['GET /v1/tree', 'viewer'])
232 assert.equal(args.check, true)
233 assert.equal(args.worker, 'ply')
234 assert.equal(parseArgs([], now, { PLY_WORKER: 'ply-staging' }).worker, 'ply-staging')
235 const fixed = parseArgs(['--from', '2026-11-01T00:00:00Z', '--to', '2026-11-02T00:00:00Z'], now, {})
236 assert.equal(fixed.to - fixed.from, 86_400_000)
237 assert.equal(parseDuration('90m'), 5_400_000)
238 assert.throws(() => parseDuration('7w'), /not <n>m/)
239 assert.throws(() => parseArgs(['--bogus', '1'], now, {}), /unknown option/)
240 assert.throws(() => parseArgs(['--since', '1d', '--from', '2026-11-01'], now, {}), /exclusive/)
241 assert.throws(() => parseArgs(['--from', '2026-11-03T00:00:00Z', '--to', '2026-11-02T00:00:00Z'], now, {}), /end after/)
242})
244test('--check over the fixture: the checked-in registry is in band (thin metrics are insufficient, not drift)', () => {
245 const args = parseArgs(['--from', '2026-11-01T00:00:00Z', '--to', '2026-11-02T00:00:00Z', '--check', '--no-histogram', '--cite', 'api:maxPackBytes'], 0, {})
246 const outcome = evaluate(args, fixtureEvents([FIXTURE_TEXT]), 'fixture')
247 assert.equal(outcome.code, 0, outcome.text)
248 assert.deepEqual(outcome.problems, [])
249 assert.ok(outcome.bands.length > 0)
250 assert.ok(outcome.bands.every(band => band.verdict === 'insufficient' || band.verdict === 'uncalibrated' || band.verdict === 'ok'))
251 assert.match(outcome.text, /^cite api:maxPackBytes:$/m)
252 assert.match(outcome.text, /^check: ok$/m)
253})
255test('--check fails on a threshold out of band, and the issue body names it', () => {
256 const dir = mkdtempSync(join(tmpdir(), 'calibrate-'))
257 try {
258 const path = join(dir, 'thresholds.json')
259 const raw = JSON.parse(readFileSync(new URL('../scripts/calibrate/thresholds.json', import.meta.url), 'utf8')) as { thresholds: Record<string, Record<string, unknown>> }
260 // Point one threshold (100) at a distribution whose p99.9 is 119: it no longer holds the traffic it bounds.
261 raw.thresholds['viewer:maxTagsShown'] = { ...raw.thresholds['viewer:maxTagsShown'], metric: { attribute: 'git.ls_tree.entries', route: 'GET /v1/tree', quantile: 0.999, headroom: 1, band: 2 } }
262 writeFileSync(path, JSON.stringify(raw))
263 const args = parseArgs(['--from', '2026-11-01T00:00:00Z', '--to', '2026-11-02T00:00:00Z', '--check', '--registry', path], 0, {})
264 const outcome = evaluate(args, fixtureEvents([FIXTURE_TEXT]), 'fixture')
265 assert.equal(outcome.code, 1)
266 // 100 tags shown < p99.9 119 tree entries: tight.
267 assert.ok(outcome.bands.some(band => band.key === 'viewer:maxTagsShown' && band.verdict === 'tight'))
268 const body = driftMarkdown({ from: args.from, to: args.to, events: outcome.stats.events, bands: outcome.bands, problems: outcome.problems })
269 assert.match(body, /^## Thresholds out of band$/m)
270 assert.match(body, /`tight viewer:maxTagsShown=100 git\.ls_tree\.entries@GET \/v1\/tree q0\.999: n=120 observed=119/)
271 } finally {
272 rmSync(dir, { recursive: true, force: true })
273 }
274})
277test('spanFilters: default allowlists /v1 + GET /; --include-noisy and --route override', () => {
278 const keys = (filters: ReturnType<typeof spanFilters>) => filters.map(f => `${f.operation}:${f.key}=${f.value}`)
279 const base = keys(spanFilters('ply'))
280 assert.ok(base.includes('eq:$metadata.service=ply'))
281 assert.ok(base.includes('eq:$metadata.type=span'))
282 assert.ok(base.includes(`in:ply.route=${DEFAULT_CALIBRATE_ROUTES.join(',')}`))
283 for (const route of NOISY_ROUTES) {
284 assert.equal(DEFAULT_CALIBRATE_ROUTES.includes(route), false, route)
285 }
286 const noisy = keys(spanFilters('ply', { routes: null, includeNoisy: true }))
287 assert.equal(noisy.some(line => line.startsWith('in:ply.route=') || line.startsWith('neq:ply.route=')), false)
288 assert.deepEqual(
289 keys(spanFilters('ply', { routes: ['GET /v1/tree'], includeNoisy: false })),
290 ['eq:$metadata.service=ply', 'eq:$metadata.type=span', 'eq:ply.route=GET /v1/tree'],
291 )
292 assert.deepEqual(
293 keys(spanFilters('ply', { routes: ['GET /v1/tree', 'POST /v1/edit'], includeNoisy: false })),
294 ['eq:$metadata.service=ply', 'eq:$metadata.type=span', 'in:ply.route=GET /v1/tree,POST /v1/edit'],
295 )
296 // An explicit route list wins over includeNoisy.
297 assert.deepEqual(
298 keys(spanFilters('ply', { routes: ['viewer'], includeNoisy: true })),
299 ['eq:$metadata.service=ply', 'eq:$metadata.type=span', 'eq:ply.route=viewer'],
300 )
301})
303test('parseArgs: --include-noisy is a boolean flag', () => {
304 const args = parseArgs(['--since', '1h', '--include-noisy'], Date.parse('2026-11-08T12:00:00Z'), {})
305 assert.equal(args.includeNoisy, true)
306 const off = parseArgs(['--since', '1h'], Date.parse('2026-11-08T12:00:00Z'), {})
307 assert.equal(off.includeNoisy, false)
308})
Diagnostics4 git calls · 49 ms
CallStatusSizeTime049 ms
discover200152 B2 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 1020040 KiB · hit8 ms
git.upload-pack fetch http.response.status_code=200 git.upstream.cf_ray=- git.upstream.phase=fetch git.upstream.dur_ms=39 git.response.bytes=41349 git.response.cache=HIT git.response.duration_ms=8 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.7 KiB · hit39 ms
git.upload-pack fetch http.response.status_code=200 git.response.bytes=5852 git.response.cache=HIT git.response.duration_ms=39 git.fetch.wants=c8817b8477576a1e8ada50f13539a3b4c1c44c60 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=5852 git.pkt.payload.max=5831 git.sideband.band1.bytes=5830 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
- a5e301850edd7929
- Request
- dcddd923…
- Protocol
- v2 · sha1
- Agent
- gitty/1.0
- Filter
- advertised
- Fetch
- shallow filter sideband-all
- Capabilities
- agent ls-refs fetch object-format