Skip to content

Commit d4950a5

Browse files
s1gr1ds1gr1d
committed
Remove Http integration from Next.js
1 parent b1a2f8b commit d4950a5

File tree

4 files changed

+130
-69
lines changed

4 files changed

+130
-69
lines changed

‎packages/nextjs/src/common/wrapRouteHandlerWithSentry.ts‎

Lines changed: 45 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,14 @@
11
import {
2-
SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
3-
SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
42
SPAN_STATUS_ERROR,
53
addTracingExtensions,
64
captureException,
7-
continueTrace,
5+
getActiveSpan,
6+
getIsolationScope,
7+
getRootSpan,
88
handleCallbackErrors,
99
setHttpStatus,
10-
startSpan,
11-
withIsolationScope,
1210
} from '@sentry/core';
1311
import { winterCGHeadersToDict } from '@sentry/utils';
14-
1512
import { isNotFoundNavigationError, isRedirectNavigationError } from './nextNavigationErrorUtils';
1613
import type { RouteHandlerContext } from './types';
1714
import { platformSupportsStreaming } from './utils/platformSupportsStreaming';
@@ -26,73 +23,55 @@ export function wrapRouteHandlerWithSentry<F extends (...args: any[]) => any>(
2623
context: RouteHandlerContext,
2724
): (...args: Parameters<F>) => ReturnType<F> extends Promise<unknown> ? ReturnType<F> : Promise<ReturnType<F>> {
2825
addTracingExtensions();
29-
const { method, parameterizedRoute, headers } = context;
26+
27+
const { headers } = context;
28+
3029
return new Proxy(routeHandler, {
31-
apply: (originalFunction, thisArg, args) => {
32-
return withIsolationScope(async isolationScope => {
33-
isolationScope.setSDKProcessingMetadata({
34-
request: {
35-
headers: headers ? winterCGHeadersToDict(headers) : undefined,
36-
},
37-
});
38-
return continueTrace(
39-
{
40-
// TODO(v8): Make it so that continue trace will allow null as sentryTrace value and remove this fallback here
41-
sentryTrace: headers?.get('sentry-trace') ?? undefined,
42-
baggage: headers?.get('baggage'),
43-
},
44-
async () => {
45-
try {
46-
return await startSpan(
47-
{
48-
op: 'http.server',
49-
name: `${method} ${parameterizedRoute}`,
50-
forceTransaction: true,
51-
attributes: {
52-
[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'route',
53-
[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.function.nextjs',
54-
},
55-
},
56-
async span => {
57-
const response: Response = await handleCallbackErrors(
58-
() => originalFunction.apply(thisArg, args),
59-
error => {
60-
// Next.js throws errors when calling `redirect()`. We don't wanna report these.
61-
if (isRedirectNavigationError(error)) {
62-
// Don't do anything
63-
} else if (isNotFoundNavigationError(error)) {
64-
span.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
65-
} else {
66-
captureException(error, {
67-
mechanism: {
68-
handled: false,
69-
},
70-
});
71-
}
72-
},
73-
);
30+
apply: async (originalFunction, thisArg, args) => {
31+
getIsolationScope().setSDKProcessingMetadata({
32+
request: {
33+
headers: headers ? winterCGHeadersToDict(headers) : undefined,
34+
},
35+
});
7436

75-
try {
76-
if (span && response.status) {
77-
setHttpStatus(span, response.status);
78-
}
79-
} catch {
80-
// best effort - response may be undefined?
81-
}
37+
try {
38+
const activeSpan = getActiveSpan();
39+
const rootSpan = activeSpan && getRootSpan(activeSpan);
8240

83-
return response;
41+
const response: Response = await handleCallbackErrors(
42+
() => originalFunction.apply(thisArg, args),
43+
error => {
44+
// Next.js throws errors when calling `redirect()`. We don't wanna report these.
45+
if (isRedirectNavigationError(error)) {
46+
// Don't do anything
47+
} else if (isNotFoundNavigationError(error) && rootSpan) {
48+
rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'not_found' });
49+
} else {
50+
captureException(error, {
51+
mechanism: {
52+
handled: false,
8453
},
85-
);
86-
} finally {
87-
if (!platformSupportsStreaming() || process.env.NEXT_RUNTIME === 'edge') {
88-
// 1. Edge transport requires manual flushing
89-
// 2. Lambdas require manual flushing to prevent execution freeze before the event is sent
90-
await flushQueue();
91-
}
54+
});
9255
}
9356
},
9457
);
95-
});
58+
59+
try {
60+
if (rootSpan && response.status) {
61+
setHttpStatus(rootSpan, response.status);
62+
}
63+
} catch {
64+
// best effort - response may be undefined?
65+
}
66+
67+
return response;
68+
} finally {
69+
if (!platformSupportsStreaming() || process.env.NEXT_RUNTIME === 'edge') {
70+
// 1. Edge transport requires manual flushing
71+
// 2. Lambdas require manual flushing to prevent execution freeze before the event is sent
72+
await flushQueue();
73+
}
74+
}
9675
},
9776
});
9877
}

‎packages/nextjs/src/server/index.ts‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -75,8 +75,9 @@ export function init(options: NodeOptions): void {
7575
...getDefaultIntegrations(options).filter(
7676
integration =>
7777
integration.name !== 'OnUncaughtException' &&
78-
// Next.js comes with its own Node-Fetch instrumentation so we shouldn't add ours on-top
79-
integration.name !== 'NodeFetch',
78+
// Next.js comes with its own Node-Fetch and Http instrumentation, so we shouldn't add ours on-top
79+
integration.name !== 'NodeFetch' &&
80+
integration.name !== 'Http',
8081
),
8182
onUncaughtExceptionIntegration(),
8283
];

‎packages/opentelemetry/src/sampler.ts‎

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@ import type { Client } from '@sentry/types';
88
import { logger } from '@sentry/utils';
99
import { SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING } from './constants';
1010

11+
import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
1112
import { DEBUG_BUILD } from './debug-build';
1213
import { getPropagationContextFromSpan } from './propagator';
1314
import { getSamplingDecision } from './utils/getSamplingDecision';
@@ -30,7 +31,7 @@ export class SentrySampler implements Sampler {
3031
traceId: string,
3132
spanName: string,
3233
_spanKind: unknown,
33-
spanAttributes: unknown,
34+
spanAttributes: SpanAttributes,
3435
_links: unknown,
3536
): SamplingResult {
3637
const options = this._client.getOptions();
@@ -72,6 +73,15 @@ export class SentrySampler implements Sampler {
7273
[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE]: sampleRate,
7374
};
7475

76+
const method = `${spanAttributes[SemanticAttributes.HTTP_METHOD]}`.toUpperCase();
77+
if (method === 'OPTIONS' || method === 'HEAD') {
78+
return {
79+
decision: SamplingDecision.NOT_RECORD,
80+
attributes,
81+
traceState: traceState.set(SENTRY_TRACE_STATE_SAMPLED_NOT_RECORDING, '1'),
82+
};
83+
}
84+
7585
if (!sampled) {
7686
return {
7787
decision: SamplingDecision.NOT_RECORD,

‎packages/opentelemetry/test/trace.test.ts‎

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ import {
2020
import type { Event, Scope } from '@sentry/types';
2121
import { makeTraceState } from '../src/propagator';
2222

23+
import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
2324
import { continueTrace, startInactiveSpan, startSpan, startSpanManual } from '../src/trace';
2425
import type { AbstractSpan } from '../src/types';
2526
import { getDynamicSamplingContextFromSpan } from '../src/utils/dynamicSamplingContext';
@@ -1358,6 +1359,76 @@ describe('trace (sampling)', () => {
13581359
});
13591360
});
13601361

1362+
describe('HTTP methods (sampling)', () => {
1363+
beforeEach(() => {
1364+
mockSdkInit({ enableTracing: true });
1365+
});
1366+
1367+
afterEach(() => {
1368+
cleanupOtel();
1369+
});
1370+
1371+
it('does sample when HTTP method is other than OPTIONS or HEAD', () => {
1372+
const spanGET = startSpanManual(
1373+
{ name: 'test span', attributes: { [SemanticAttributes.HTTP_METHOD]: 'GET' } },
1374+
span => {
1375+
return span;
1376+
},
1377+
);
1378+
expect(spanIsSampled(spanGET)).toBe(true);
1379+
expect(getSamplingDecision(spanGET.spanContext())).toBe(true);
1380+
1381+
const spanPOST = startSpanManual(
1382+
{ name: 'test span', attributes: { [SemanticAttributes.HTTP_METHOD]: 'POST' } },
1383+
span => {
1384+
return span;
1385+
},
1386+
);
1387+
expect(spanIsSampled(spanPOST)).toBe(true);
1388+
expect(getSamplingDecision(spanPOST.spanContext())).toBe(true);
1389+
1390+
const spanPUT = startSpanManual(
1391+
{ name: 'test span', attributes: { [SemanticAttributes.HTTP_METHOD]: 'PUT' } },
1392+
span => {
1393+
return span;
1394+
},
1395+
);
1396+
expect(spanIsSampled(spanPUT)).toBe(true);
1397+
expect(getSamplingDecision(spanPUT.spanContext())).toBe(true);
1398+
1399+
const spanDELETE = startSpanManual(
1400+
{ name: 'test span', attributes: { [SemanticAttributes.HTTP_METHOD]: 'DELETE' } },
1401+
span => {
1402+
return span;
1403+
},
1404+
);
1405+
expect(spanIsSampled(spanDELETE)).toBe(true);
1406+
expect(getSamplingDecision(spanDELETE.spanContext())).toBe(true);
1407+
});
1408+
1409+
it('does not sample when HTTP method is OPTIONS', () => {
1410+
const span = startSpanManual(
1411+
{ name: 'test span', attributes: { [SemanticAttributes.HTTP_METHOD]: 'OPTIONS' } },
1412+
span => {
1413+
return span;
1414+
},
1415+
);
1416+
expect(spanIsSampled(span)).toBe(false);
1417+
expect(getSamplingDecision(span.spanContext())).toBe(false);
1418+
});
1419+
1420+
it('does not sample when HTTP method is HEAD', () => {
1421+
const span = startSpanManual(
1422+
{ name: 'test span', attributes: { [SemanticAttributes.HTTP_METHOD]: 'HEAD' } },
1423+
span => {
1424+
return span;
1425+
},
1426+
);
1427+
expect(spanIsSampled(span)).toBe(false);
1428+
expect(getSamplingDecision(span.spanContext())).toBe(false);
1429+
});
1430+
});
1431+
13611432
describe('continueTrace', () => {
13621433
beforeEach(() => {
13631434
mockSdkInit({ enableTracing: true });

0 commit comments

Comments
 (0)