Add E2E test app for node-core-light-otlp

Author: andreiborza

dev-packages/e2e-tests/test-applications/node-core-light-otlp/.gitignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+.env
+pnpm-lock.yaml

dev-packages/e2e-tests/test-applications/node-core-light-otlp/.npmrc

@@ -0,0 +1,2 @@
+@sentry:registry=http://127.0.0.1:4873
+@sentry-internal:registry=http://127.0.0.1:4873

dev-packages/e2e-tests/test-applications/node-core-light-otlp/package.json

@@ -0,0 +1,40 @@
+{
+"name": "node-core-light-otlp-app",
+"version": "1.0.0",
+"private": true,
+"type": "module",
+"scripts": {
+"build": "tsc",
+"start": "node dist/app.js",
+"test": "playwright test",
+"clean": "npx rimraf node_modules pnpm-lock.yaml",
+"test:build": "pnpm install && pnpm build",
+"test:assert": "pnpm test"
+ },
+"dependencies": {
+"@opentelemetry/api": "^1.9.0",
+"@opentelemetry/exporter-trace-otlp-http": "^0.211.0",
+"@opentelemetry/sdk-trace-base": "^2.5.1",
+"@opentelemetry/sdk-trace-node": "^2.5.1",
+"@sentry/node-core": "latest || *",
+"@types/express": "^4.17.21",
+"@types/node": "^22.0.0",
+"express": "^4.21.2",
+"typescript": "~5.0.0"
+ },
+"devDependencies": {
+"@playwright/test": "~1.56.0",
+"@sentry-internal/test-utils": "link:../../../test-utils",
+"@sentry/core": "latest || *"
+ },
+"volta": {
+"node": "22.18.0"
+ },
+"sentryTest": {
+"variants": [
+ {
+"label": "node 22 (light mode + OTLP integration)"
+ }
+ ]
+ }
+}

dev-packages/e2e-tests/test-applications/node-core-light-otlp/playwright.config.ts

@@ -0,0 +1,34 @@
+import{getPlaywrightConfig}from'@sentry-internal/test-utils';
+
+constconfig=getPlaywrightConfig(
+{
+startCommand: 'pnpm start',
+},
+{
+webServer: [
+{
+command: 'node ./start-event-proxy.mjs',
+port: 3031,
+stdout: 'pipe',
+stderr: 'pipe',
+},
+{
+command: 'node ./start-otel-proxy.mjs',
+port: 3032,
+stdout: 'pipe',
+stderr: 'pipe',
+},
+{
+command: 'pnpm start',
+port: 3030,
+stdout: 'pipe',
+stderr: 'pipe',
+env: {
+PORT: '3030',
+},
+},
+],
+},
+);
+
+exportdefaultconfig;

dev-packages/e2e-tests/test-applications/node-core-light-otlp/src/app.ts

@@ -0,0 +1,90 @@
+import{trace}from'@opentelemetry/api';
+import{BatchSpanProcessor}from'@opentelemetry/sdk-trace-base';
+import{NodeTracerProvider}from'@opentelemetry/sdk-trace-node';
+import{OTLPTraceExporter}from'@opentelemetry/exporter-trace-otlp-http';
+import*asSentryfrom'@sentry/node-core/light';
+import{otlpIntegration}from'@sentry/node-core/light/otlp';
+importexpressfrom'express';
+
+constprovider=newNodeTracerProvider({
+spanProcessors: [
+// The user's own exporter (sends to test proxy for verification)
+newBatchSpanProcessor(
+newOTLPTraceExporter({
+url: 'http://localhost:3032/',
+}),
+),
+],
+});
+
+provider.register();
+
+Sentry.init({
+dsn: process.env.E2E_TEST_DSN,
+debug: true,
+tracesSampleRate: 1.0,
+tunnel: 'http://localhost:3031/',// Use event proxy for testing
+integrations: [otlpIntegration()],
+});
+
+constapp=express();
+constport=3030;
+consttracer=trace.getTracer('test-app');
+
+app.get('/test-error',(_req,res)=>{
+Sentry.setTag('test','error');
+Sentry.captureException(newError('Test error from light+otel'));
+res.status(500).json({error: 'Error captured'});
+});
+
+app.get('/test-otel-span',(_req,res)=>{
+tracer.startActiveSpan('test-span',span=>{
+Sentry.captureException(newError('Error inside OTel span'));
+span.end();
+});
+
+res.json({ok: true});
+});
+
+app.get('/test-isolation/:userId',async(req,res)=>{
+constuserId=req.params.userId;
+
+// The light httpIntegration provides request isolation via diagnostics_channel.
+// This should still work alongside the OTLP integration.
+Sentry.setUser({id: userId});
+Sentry.setTag('user_id',userId);
+
+// Simulate async work
+awaitnewPromise(resolve=>setTimeout(resolve,Math.random()*200+50));
+
+constisolationScope=Sentry.getIsolationScope();
+constscopeData=isolationScope.getScopeData();
+
+constisIsolated=scopeData.user?.id===userId&&scopeData.tags?.user_id===userId;
+
+res.json({
+ userId,
+ isIsolated,
+scope: {
+userId: scopeData.user?.id,
+userIdTag: scopeData.tags?.user_id,
+},
+});
+});
+
+app.get('/test-isolation-error/:userId',(req,res)=>{
+constuserId=req.params.userId;
+Sentry.setTag('user_id',userId);
+Sentry.setUser({id: userId});
+
+Sentry.captureException(newError(`Error for user ${userId}`));
+res.json({ userId,captured: true});
+});
+
+app.get('/health',(_req,res)=>{
+res.json({status: 'ok'});
+});
+
+app.listen(port,()=>{
+console.log(`Example app listening on port ${port}`);
+});

dev-packages/e2e-tests/test-applications/node-core-light-otlp/start-event-proxy.mjs

@@ -0,0 +1,6 @@
+import{startEventProxyServer}from'@sentry-internal/test-utils';
+
+startEventProxyServer({
+port: 3031,
+proxyServerName: 'node-core-light-otlp',
+});

dev-packages/e2e-tests/test-applications/node-core-light-otlp/start-otel-proxy.mjs

@@ -0,0 +1,6 @@
+import{startProxyServer}from'@sentry-internal/test-utils';
+
+startProxyServer({
+port: 3032,
+proxyServerName: 'node-core-light-otlp-otel',
+});

dev-packages/e2e-tests/test-applications/node-core-light-otlp/tests/errors.test.ts

@@ -0,0 +1,32 @@
+import{expect,test}from'@playwright/test';
+import{waitForError}from'@sentry-internal/test-utils';
+
+test('should capture errors with correct tags',async({ request })=>{
+consterrorEventPromise=waitForError('node-core-light-otlp',event=>{
+returnevent?.exception?.values?.[0]?.value==='Test error from light+otel';
+});
+
+constresponse=awaitrequest.get('/test-error');
+expect(response.status()).toBe(500);
+
+consterrorEvent=awaiterrorEventPromise;
+expect(errorEvent).toBeDefined();
+expect(errorEvent.exception?.values?.[0]?.value).toBe('Test error from light+otel');
+expect(errorEvent.tags?.test).toBe('error');
+});
+
+test('should link error events to the active OTel trace context',async({ request })=>{
+consterrorEventPromise=waitForError('node-core-light-otlp',event=>{
+returnevent?.exception?.values?.[0]?.value==='Error inside OTel span';
+});
+
+awaitrequest.get('/test-otel-span');
+
+consterrorEvent=awaiterrorEventPromise;
+expect(errorEvent).toBeDefined();
+
+// The error event should have trace context from the OTel span
+expect(errorEvent.contexts?.trace).toBeDefined();
+expect(errorEvent.contexts?.trace?.trace_id).toMatch(/[a-f0-9]{32}/);
+expect(errorEvent.contexts?.trace?.span_id).toMatch(/[a-f0-9]{16}/);
+});

dev-packages/e2e-tests/test-applications/node-core-light-otlp/tests/otel-spans.test.ts

@@ -0,0 +1,16 @@
+import{expect,test}from'@playwright/test';
+import{waitForPlainRequest}from'@sentry-internal/test-utils';
+
+test('User OTel exporter still receives spans',async({ request })=>{
+// The user's own OTel exporter sends spans to port 3032 (our test proxy).
+// Verify that OTel span export still works alongside the Sentry OTLP integration.
+constotelPromise=waitForPlainRequest('node-core-light-otlp-otel',data=>{
+constjson=JSON.parse(data)as{resourceSpans: unknown[]};
+returnjson.resourceSpans.length>0;
+});
+
+awaitrequest.get('/test-otel-span');
+
+constotelData=awaitotelPromise;
+expect(otelData).toBeDefined();
+});

dev-packages/e2e-tests/test-applications/node-core-light-otlp/tests/request-isolation.test.ts

@@ -0,0 +1,60 @@
+import{expect,test}from'@playwright/test';
+import{waitForError}from'@sentry-internal/test-utils';
+
+test('should isolate scope data across concurrent requests',async({ request })=>{
+const[response1,response2,response3]=awaitPromise.all([
+request.get('/test-isolation/user-1'),
+request.get('/test-isolation/user-2'),
+request.get('/test-isolation/user-3'),
+]);
+
+constdata1=awaitresponse1.json();
+constdata2=awaitresponse2.json();
+constdata3=awaitresponse3.json();
+
+expect(data1.isIsolated).toBe(true);
+expect(data1.userId).toBe('user-1');
+expect(data1.scope.userId).toBe('user-1');
+expect(data1.scope.userIdTag).toBe('user-1');
+
+expect(data2.isIsolated).toBe(true);
+expect(data2.userId).toBe('user-2');
+expect(data2.scope.userId).toBe('user-2');
+expect(data2.scope.userIdTag).toBe('user-2');
+
+expect(data3.isIsolated).toBe(true);
+expect(data3.userId).toBe('user-3');
+expect(data3.scope.userId).toBe('user-3');
+expect(data3.scope.userIdTag).toBe('user-3');
+});
+
+test('should isolate errors across concurrent requests',async({ request })=>{
+consterrorPromises=[
+waitForError('node-core-light-otlp',event=>{
+returnevent?.exception?.values?.[0]?.value==='Error for user user-1';
+}),
+waitForError('node-core-light-otlp',event=>{
+returnevent?.exception?.values?.[0]?.value==='Error for user user-2';
+}),
+waitForError('node-core-light-otlp',event=>{
+returnevent?.exception?.values?.[0]?.value==='Error for user user-3';
+}),
+];
+
+awaitPromise.all([
+request.get('/test-isolation-error/user-1'),
+request.get('/test-isolation-error/user-2'),
+request.get('/test-isolation-error/user-3'),
+]);
+
+const[error1,error2,error3]=awaitPromise.all(errorPromises);
+
+expect(error1?.user?.id).toBe('user-1');
+expect(error1?.tags?.user_id).toBe('user-1');
+
+expect(error2?.user?.id).toBe('user-2');
+expect(error2?.tags?.user_id).toBe('user-2');
+
+expect(error3?.user?.id).toBe('user-3');
+expect(error3?.tags?.user_id).toBe('user-3');
+});