From 43f10abd61652a8e473a499285f159f7d6f29266 Mon Sep 17 00:00:00 2001 From: Lukas Stracke Date: Thu, 5 Mar 2026 10:57:08 +0100 Subject: [PATCH 1/8] fix(browser): Apply Http timing attributes to streamed `http.client` spans --- .../http-timings-streamed/test.ts | 12 +---- .../nested-parentAlwaysRoot/test.ts | 11 ++--- .../setSpanActive-streamed/nested/test.ts | 11 ++--- .../browser/src/integrations/spanstreaming.ts | 7 ++- packages/browser/src/tracing/request.ts | 48 +++++++++++++++++-- 5 files changed, 57 insertions(+), 32 deletions(-) diff --git a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/test.ts b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/test.ts index ffa63937bf32..25d4ac497992 100644 --- a/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/test.ts +++ b/dev-packages/browser-integration-tests/suites/tracing/browserTracingIntegration/http-timings-streamed/test.ts @@ -3,16 +3,8 @@ import { sentryTest } from '../../../../utils/fixtures'; import { shouldSkipTracingTest, testingCdnBundle } from '../../../../utils/helpers'; import { getSpanOp, waitForStreamedSpans } from '../../../../utils/spanUtils'; -/** - * This test details a limitation of span streaming in comparison to transaction-based tracing: - * We can no longer attach http PerformanceResourceTiming attributes to http.client spans in - * span streaming mode. The reason is that we track `http.client` spans in real time but only - * get the detailed timing information after the span already ended. - * We can probably fix this (somehat at least) but will do so in a follow-up PR. - * @see https://github.com/getsentry/sentry-javascript/issues/19613 - */ sentryTest( - "[limitation] doesn't add http timing to http.client spans in span streaming mode", + 'adds http timing to http.client spans in span streaming mode', async ({ browserName, getLocalTestUrl, page }) => { const supportedBrowsers = ['chromium', 'firefox']; @@ -49,7 +41,7 @@ sentryTest( end_timestamp: expect.any(Number), trace_id: pageloadSpan?.trace_id, status: 'ok', - attributes: expect.not.objectContaining({ + attributes: expect.objectContaining({ 'http.request.redirect_start': expect.any(Object), 'http.request.redirect_end': expect.any(Object), 'http.request.worker_start': expect.any(Object), diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/test.ts b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/test.ts index 58728bba07f9..8f5e54e1fba0 100644 --- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/test.ts +++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested-parentAlwaysRoot/test.ts @@ -11,18 +11,14 @@ sentryTest( const checkoutSpansPromise = waitForStreamedSpans(page, spans => spans.some(s => s.name === 'checkout-flow' && s.is_segment), ); - const postCheckoutSpansPromise = waitForStreamedSpans(page, spans => - spans.some(s => s.name === 'post-checkout' && s.is_segment), - ); const url = await getLocalTestUrl({ testDir: __dirname }); await page.goto(url); const checkoutSpans = await checkoutSpansPromise; - const postCheckoutSpans = await postCheckoutSpansPromise; const checkoutSpan = checkoutSpans.find(s => s.name === 'checkout-flow'); - const postCheckoutSpan = postCheckoutSpans.find(s => s.name === 'post-checkout'); + const postCheckoutSpan = checkoutSpans.find(s => s.name === 'post-checkout'); const checkoutSpanId = checkoutSpan?.span_id; const postCheckoutSpanId = postCheckoutSpan?.span_id; @@ -30,8 +26,7 @@ sentryTest( expect(checkoutSpanId).toMatch(/[a-f\d]{16}/); expect(postCheckoutSpanId).toMatch(/[a-f\d]{16}/); - expect(checkoutSpans.filter(s => !s.is_segment)).toHaveLength(4); - expect(postCheckoutSpans.filter(s => !s.is_segment)).toHaveLength(1); + expect(checkoutSpans.filter(s => !s.is_segment)).toHaveLength(5); const checkoutStep1 = checkoutSpans.find(s => s.name === 'checkout-step-1'); const checkoutStep2 = checkoutSpans.find(s => s.name === 'checkout-step-2'); @@ -56,7 +51,7 @@ sentryTest( // post-checkout trace is started as a new trace because ending checkoutSpan removes the active // span on the scope - const postCheckoutStep1 = postCheckoutSpans.find(s => s.name === 'post-checkout-1'); + const postCheckoutStep1 = checkoutSpans.find(s => s.name === 'post-checkout-1'); expect(postCheckoutStep1).toBeDefined(); expect(postCheckoutStep1?.parent_span_id).toBe(postCheckoutSpanId); }, diff --git a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/test.ts b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/test.ts index 4d11a36982b7..1b04553090bc 100644 --- a/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/test.ts +++ b/dev-packages/browser-integration-tests/suites/tracing/setSpanActive-streamed/nested/test.ts @@ -11,18 +11,14 @@ sentryTest( const checkoutSpansPromise = waitForStreamedSpans(page, spans => spans.some(s => s.name === 'checkout-flow' && s.is_segment), ); - const postCheckoutSpansPromise = waitForStreamedSpans(page, spans => - spans.some(s => s.name === 'post-checkout' && s.is_segment), - ); const url = await getLocalTestUrl({ testDir: __dirname }); await page.goto(url); const checkoutSpans = await checkoutSpansPromise; - const postCheckoutSpans = await postCheckoutSpansPromise; const checkoutSpan = checkoutSpans.find(s => s.name === 'checkout-flow'); - const postCheckoutSpan = postCheckoutSpans.find(s => s.name === 'post-checkout'); + const postCheckoutSpan = checkoutSpans.find(s => s.name === 'post-checkout'); const checkoutSpanId = checkoutSpan?.span_id; const postCheckoutSpanId = postCheckoutSpan?.span_id; @@ -30,8 +26,7 @@ sentryTest( expect(checkoutSpanId).toMatch(/[a-f\d]{16}/); expect(postCheckoutSpanId).toMatch(/[a-f\d]{16}/); - expect(checkoutSpans.filter(s => !s.is_segment)).toHaveLength(4); - expect(postCheckoutSpans.filter(s => !s.is_segment)).toHaveLength(1); + expect(checkoutSpans.filter(s => !s.is_segment)).toHaveLength(5); const checkoutStep1 = checkoutSpans.find(s => s.name === 'checkout-step-1'); const checkoutStep2 = checkoutSpans.find(s => s.name === 'checkout-step-2'); @@ -51,7 +46,7 @@ sentryTest( // root span due to this being default behaviour in browser environments expect(checkoutStep21?.parent_span_id).toBe(checkoutSpanId); - const postCheckoutStep1 = postCheckoutSpans.find(s => s.name === 'post-checkout-1'); + const postCheckoutStep1 = checkoutSpans.find(s => s.name === 'post-checkout-1'); expect(postCheckoutStep1).toBeDefined(); expect(postCheckoutStep1?.parent_span_id).toBe(postCheckoutSpanId); }, diff --git a/packages/browser/src/integrations/spanstreaming.ts b/packages/browser/src/integrations/spanstreaming.ts index f741e2746885..ab07f75c2b7d 100644 --- a/packages/browser/src/integrations/spanstreaming.ts +++ b/packages/browser/src/integrations/spanstreaming.ts @@ -58,7 +58,12 @@ export const spanStreamingIntegration = defineIntegration(() => { // In addition to capturing the span, we also flush the trace when the segment // span ends to ensure things are sent timely. We never know when the browser // is closed, users navigate away, etc. - client.on('afterSegmentSpanEnd', segmentSpan => buffer.flush(segmentSpan.spanContext().traceId)); + client.on('afterSegmentSpanEnd', segmentSpan => { + const traceId = segmentSpan.spanContext().traceId; + setTimeout(() => { + buffer.flush(traceId); + }, 500); + }); }, }; }) satisfies IntegrationFn; diff --git a/packages/browser/src/tracing/request.ts b/packages/browser/src/tracing/request.ts index 85faf0871a55..02b3bec29159 100644 --- a/packages/browser/src/tracing/request.ts +++ b/packages/browser/src/tracing/request.ts @@ -5,6 +5,7 @@ import type { ResponseHookInfo, SentryWrappedXMLHttpRequest, Span, + SpanTimeInput, } from '@sentry/core'; import { addFetchEndInstrumentationHandler, @@ -238,8 +239,17 @@ export function instrumentOutgoingRequests(client: Client, _options?: Partial { + capturedEndTimestamp = endTimestamp; + // Do not call originalEnd here; finishSpan() handles that once timing data + // has arrived (or the timeout fires). + }; + + const endSpanAndCleanup = (): void => { + if (isEnded) { + return; + } + isEnded = true; + // In the next tick, clean up the performance observer + // We have to wait here because otherwise we clean it up before it is fully done + setTimeout(cleanup); + originalEnd(capturedEndTimestamp); + clearTimeout(fallbackTimeout); + }; + const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => { entries.forEach(entry => { if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) { span.setAttributes(resourceTimingToSpanAttributes(entry)); - // In the next tick, clean this handler up - // We have to wait here because otherwise this cleans itself up before it is fully done - setTimeout(cleanup); + endSpanAndCleanup(); } }); }); + + // Fallback: always end the span after HTTP_TIMING_WAIT_MS even if no + // PerformanceResourceTiming entry arrives (e.g. cross-origin without + // Timing-Allow-Origin, or the browser didn't fire the observer in time). + const fallbackTimeout = setTimeout(endSpanAndCleanup, HTTP_TIMING_WAIT_MS); } /** From 526846a92244fa55cd6f7fe51161ee076bff5d47 Mon Sep 17 00:00:00 2001 From: Lukas Stracke Date: Thu, 5 Mar 2026 13:12:58 +0100 Subject: [PATCH 2/8] add distinct implementation for static vs streamed spans --- packages/browser/src/tracing/request.ts | 83 ++++++++++++++----------- 1 file changed, 47 insertions(+), 36 deletions(-) diff --git a/packages/browser/src/tracing/request.ts b/packages/browser/src/tracing/request.ts index 02b3bec29159..151cb4bcf8f2 100644 --- a/packages/browser/src/tracing/request.ts +++ b/packages/browser/src/tracing/request.ts @@ -1,3 +1,4 @@ +/* eslint-disable max-lines */ import type { Client, HandlerDataXhr, @@ -15,6 +16,7 @@ import { getLocationHref, getTraceData, hasSpansEnabled, + hasSpanStreamingEnabled, instrumentFetchRequest, parseUrl, SEMANTIC_ATTRIBUTE_SENTRY_OP, @@ -206,7 +208,7 @@ export function instrumentOutgoingRequests(client: Client, _options?: Partial { - capturedEndTimestamp = endTimestamp; - // Do not call originalEnd here; finishSpan() handles that once timing data - // has arrived (or the timeout fires). - }; + // For streamed spans, we have to artificially delay the ending of the span until we + // either receive the timing data, or HTTP_TIMING_WAIT_MS elapses. + if (hasSpanStreamingEnabled(client)) { + const originalEnd = span.end.bind(span); + let capturedEndTimestamp: SpanTimeInput | undefined; + let isEnded = false; - const endSpanAndCleanup = (): void => { - if (isEnded) { - return; - } - isEnded = true; - // In the next tick, clean up the performance observer - // We have to wait here because otherwise we clean it up before it is fully done - setTimeout(cleanup); - originalEnd(capturedEndTimestamp); - clearTimeout(fallbackTimeout); - }; + span.end = (endTimestamp?: SpanTimeInput) => { + capturedEndTimestamp = endTimestamp; + }; + + const endSpanAndCleanup = (): void => { + if (isEnded) { + return; + } + isEnded = true; + // In the next tick, clean up the performance observer + // We have to wait here because otherwise we clean it up before it is fully done + setTimeout(cleanup); + originalEnd(capturedEndTimestamp); + clearTimeout(fallbackTimeout); + }; + + const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => { + entries.forEach(entry => { + if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) { + span.setAttributes(resourceTimingToSpanAttributes(entry)); + endSpanAndCleanup(); + } + }); + }); + + // Fallback: always end the span after HTTP_TIMING_WAIT_MS even if no + // PerformanceResourceTiming entry arrives (e.g. cross-origin without + // Timing-Allow-Origin, or the browser didn't fire the observer in time). + const fallbackTimeout = setTimeout(endSpanAndCleanup, HTTP_TIMING_WAIT_MS); + return; + } const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => { entries.forEach(entry => { if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) { span.setAttributes(resourceTimingToSpanAttributes(entry)); - endSpanAndCleanup(); + // In the next tick, clean this handler up + // We have to wait here because otherwise this cleans itself up before it is fully done + setTimeout(cleanup); } }); }); - - // Fallback: always end the span after HTTP_TIMING_WAIT_MS even if no - // PerformanceResourceTiming entry arrives (e.g. cross-origin without - // Timing-Allow-Origin, or the browser didn't fire the observer in time). - const fallbackTimeout = setTimeout(endSpanAndCleanup, HTTP_TIMING_WAIT_MS); } /** From 6b0eb4f7a3c655b63779f9e5330190515d94af7d Mon Sep 17 00:00:00 2001 From: Lukas Stracke Date: Thu, 5 Mar 2026 13:21:37 +0100 Subject: [PATCH 3/8] decrease bundle size hit, fix unit test --- packages/browser/src/tracing/request.ts | 21 +++++++------------ .../test/integrations/spanstreaming.test.ts | 7 ++++++- 2 files changed, 13 insertions(+), 15 deletions(-) diff --git a/packages/browser/src/tracing/request.ts b/packages/browser/src/tracing/request.ts index 151cb4bcf8f2..ecb2c178905c 100644 --- a/packages/browser/src/tracing/request.ts +++ b/packages/browser/src/tracing/request.ts @@ -260,6 +260,11 @@ function addHTTPTimings(span: Span, client: Client): void { return; } + // Clean up the performance observer and other resources + // We have to wait here because otherwise this cleans itself up before it is fully done. + // Default (non-streaming): just deregister the observer. + let onEntryFound = (): void => void setTimeout(cleanup); + // For streamed spans, we have to artificially delay the ending of the span until we // either receive the timing data, or HTTP_TIMING_WAIT_MS elapses. if (hasSpanStreamingEnabled(client)) { @@ -276,36 +281,24 @@ function addHTTPTimings(span: Span, client: Client): void { return; } isEnded = true; - // In the next tick, clean up the performance observer - // We have to wait here because otherwise we clean it up before it is fully done setTimeout(cleanup); originalEnd(capturedEndTimestamp); clearTimeout(fallbackTimeout); }; - const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => { - entries.forEach(entry => { - if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) { - span.setAttributes(resourceTimingToSpanAttributes(entry)); - endSpanAndCleanup(); - } - }); - }); + onEntryFound = endSpanAndCleanup; // Fallback: always end the span after HTTP_TIMING_WAIT_MS even if no // PerformanceResourceTiming entry arrives (e.g. cross-origin without // Timing-Allow-Origin, or the browser didn't fire the observer in time). const fallbackTimeout = setTimeout(endSpanAndCleanup, HTTP_TIMING_WAIT_MS); - return; } const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => { entries.forEach(entry => { if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) { span.setAttributes(resourceTimingToSpanAttributes(entry)); - // In the next tick, clean this handler up - // We have to wait here because otherwise this cleans itself up before it is fully done - setTimeout(cleanup); + onEntryFound(); } }); }); diff --git a/packages/browser/test/integrations/spanstreaming.test.ts b/packages/browser/test/integrations/spanstreaming.test.ts index 63e07738570c..5b84c52f8d7e 100644 --- a/packages/browser/test/integrations/spanstreaming.test.ts +++ b/packages/browser/test/integrations/spanstreaming.test.ts @@ -171,7 +171,8 @@ describe('spanStreamingIntegration', () => { expect(mockSpanBufferInstance.flush).not.toHaveBeenCalled(); }); - it('flushes the trace when the segment span ends', () => { + it('flushes the trace when the segment span ends after a delay for close to finished child spans', () => { + vi.useFakeTimers(); const client = new BrowserClient({ ...getDefaultBrowserClientOptions(), dsn: 'https://username@domain/123', @@ -185,6 +186,10 @@ describe('spanStreamingIntegration', () => { const span = new SentryCore.SentrySpan({ name: 'test' }); client.emit('afterSegmentSpanEnd', span); + vi.advanceTimersByTime(500); + expect(mockSpanBufferInstance.flush).toHaveBeenCalledWith(span.spanContext().traceId); + + vi.useRealTimers(); }); }); From 7d0fe48f9e99e588479e9e370872b7497645d48c Mon Sep 17 00:00:00 2001 From: Lukas Stracke Date: Fri, 6 Mar 2026 17:51:20 +0100 Subject: [PATCH 4/8] fix race condition and registering fallback incorrectly --- packages/browser/src/tracing/request.ts | 32 ++++++++++++------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/packages/browser/src/tracing/request.ts b/packages/browser/src/tracing/request.ts index ecb2c178905c..9316e95df457 100644 --- a/packages/browser/src/tracing/request.ts +++ b/packages/browser/src/tracing/request.ts @@ -274,24 +274,24 @@ function addHTTPTimings(span: Span, client: Client): void { span.end = (endTimestamp?: SpanTimeInput) => { capturedEndTimestamp = endTimestamp; - }; - const endSpanAndCleanup = (): void => { - if (isEnded) { - return; - } - isEnded = true; - setTimeout(cleanup); - originalEnd(capturedEndTimestamp); - clearTimeout(fallbackTimeout); + const endSpanAndCleanup = (): void => { + if (isEnded) { + return; + } + isEnded = true; + setTimeout(cleanup); + originalEnd(capturedEndTimestamp); + clearTimeout(fallbackTimeout); + }; + + onEntryFound = endSpanAndCleanup; + + // Fallback: always end the span after HTTP_TIMING_WAIT_MS even if no + // PerformanceResourceTiming entry arrives (e.g. cross-origin without + // Timing-Allow-Origin, or the browser didn't fire the observer in time). + const fallbackTimeout = setTimeout(endSpanAndCleanup, HTTP_TIMING_WAIT_MS); }; - - onEntryFound = endSpanAndCleanup; - - // Fallback: always end the span after HTTP_TIMING_WAIT_MS even if no - // PerformanceResourceTiming entry arrives (e.g. cross-origin without - // Timing-Allow-Origin, or the browser didn't fire the observer in time). - const fallbackTimeout = setTimeout(endSpanAndCleanup, HTTP_TIMING_WAIT_MS); } const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => { From e60978f0c08808a3a3df476a4725062f73d5845e Mon Sep 17 00:00:00 2001 From: Lukas Stracke Date: Fri, 6 Mar 2026 17:53:56 +0100 Subject: [PATCH 5/8] fix another bug with missing timestamp --- packages/browser/src/tracing/request.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/browser/src/tracing/request.ts b/packages/browser/src/tracing/request.ts index 9316e95df457..b3a2f422b426 100644 --- a/packages/browser/src/tracing/request.ts +++ b/packages/browser/src/tracing/request.ts @@ -28,6 +28,7 @@ import { stringMatchesSomePattern, stripDataUrlContent, stripUrlQueryAndFragment, + timestampInSeconds, } from '@sentry/core'; import type { XhrHint } from '@sentry-internal/browser-utils'; import { @@ -269,11 +270,10 @@ function addHTTPTimings(span: Span, client: Client): void { // either receive the timing data, or HTTP_TIMING_WAIT_MS elapses. if (hasSpanStreamingEnabled(client)) { const originalEnd = span.end.bind(span); - let capturedEndTimestamp: SpanTimeInput | undefined; - let isEnded = false; span.end = (endTimestamp?: SpanTimeInput) => { - capturedEndTimestamp = endTimestamp; + const capturedEndTimestamp = endTimestamp || timestampInSeconds(); + let isEnded = false; const endSpanAndCleanup = (): void => { if (isEnded) { From 8bb267bebf926cc680434f5ae2a8dba1ea0c0894 Mon Sep 17 00:00:00 2001 From: Lukas Stracke Date: Fri, 6 Mar 2026 17:54:20 +0100 Subject: [PATCH 6/8] ?? --- packages/browser/src/tracing/request.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/browser/src/tracing/request.ts b/packages/browser/src/tracing/request.ts index b3a2f422b426..fc3e4c261d0c 100644 --- a/packages/browser/src/tracing/request.ts +++ b/packages/browser/src/tracing/request.ts @@ -272,7 +272,7 @@ function addHTTPTimings(span: Span, client: Client): void { const originalEnd = span.end.bind(span); span.end = (endTimestamp?: SpanTimeInput) => { - const capturedEndTimestamp = endTimestamp || timestampInSeconds(); + const capturedEndTimestamp = endTimestamp ?? timestampInSeconds(); let isEnded = false; const endSpanAndCleanup = (): void => { From fc373deec6ebb0945ba69a6cdbd921c41d0552f1 Mon Sep 17 00:00:00 2001 From: Lukas Stracke Date: Fri, 6 Mar 2026 17:55:55 +0100 Subject: [PATCH 7/8] naming --- packages/browser/src/tracing/request.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/packages/browser/src/tracing/request.ts b/packages/browser/src/tracing/request.ts index fc3e4c261d0c..6211cf72947a 100644 --- a/packages/browser/src/tracing/request.ts +++ b/packages/browser/src/tracing/request.ts @@ -264,7 +264,7 @@ function addHTTPTimings(span: Span, client: Client): void { // Clean up the performance observer and other resources // We have to wait here because otherwise this cleans itself up before it is fully done. // Default (non-streaming): just deregister the observer. - let onEntryFound = (): void => void setTimeout(cleanup); + let onEntryFound = (): void => void setTimeout(unsubscribePerformanceObsever); // For streamed spans, we have to artificially delay the ending of the span until we // either receive the timing data, or HTTP_TIMING_WAIT_MS elapses. @@ -280,7 +280,7 @@ function addHTTPTimings(span: Span, client: Client): void { return; } isEnded = true; - setTimeout(cleanup); + setTimeout(unsubscribePerformanceObsever); originalEnd(capturedEndTimestamp); clearTimeout(fallbackTimeout); }; @@ -294,7 +294,7 @@ function addHTTPTimings(span: Span, client: Client): void { }; } - const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => { + const unsubscribePerformanceObsever = addPerformanceInstrumentationHandler('resource', ({ entries }) => { entries.forEach(entry => { if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) { span.setAttributes(resourceTimingToSpanAttributes(entry)); From 9502ae030de9293386081a765539a638ed4b0798 Mon Sep 17 00:00:00 2001 From: Lukas Stracke Date: Mon, 9 Mar 2026 13:46:14 +0100 Subject: [PATCH 8/8] fix size limit --- .size-limit.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.size-limit.js b/.size-limit.js index 44e701b3466b..3a4689d59faa 100644 --- a/.size-limit.js +++ b/.size-limit.js @@ -241,7 +241,7 @@ module.exports = [ path: createCDNPath('bundle.tracing.min.js'), gzip: false, brotli: false, - limit: '129 KB', + limit: '130 KB', }, { name: 'CDN Bundle (incl. Logs, Metrics) - uncompressed',