Add otlpIntegration for @sentry/node-core/light/otlp

Author: andreiborza

packages/node-core/package.json

@@ -54,6 +54,16 @@
 "require": {
 "default": "./build/cjs/init.js"
  }
+ },
+"./light/otlp": {
+"import": {
+"types": "./build/types/light/integrations/otlpIntegration.d.ts",
+"default": "./build/esm/light/integrations/otlpIntegration.js"
+ },
+"require": {
+"types": "./build/types/light/integrations/otlpIntegration.d.ts",
+"default": "./build/cjs/light/integrations/otlpIntegration.js"
+ }
  }
  },
 "typesVersions": {
@@ -73,7 +83,8 @@
 "@opentelemetry/instrumentation": ">=0.57.1 <1",
 "@opentelemetry/resources": "^1.30.1 || ^2.1.0",
 "@opentelemetry/sdk-trace-base": "^1.30.1 || ^2.1.0",
-"@opentelemetry/semantic-conventions": "^1.39.0"
+"@opentelemetry/semantic-conventions": "^1.39.0",
+"@opentelemetry/exporter-trace-otlp-http": ">=0.57.0 <1"
  },
 "peerDependenciesMeta": {
 "@opentelemetry/api": {
@@ -96,6 +107,9 @@
  },
 "@opentelemetry/semantic-conventions": {
 "optional": true
+ },
+"@opentelemetry/exporter-trace-otlp-http": {
+"optional": true
  }
  },
 "dependencies": {
@@ -107,6 +121,7 @@
 "@opentelemetry/api": "^1.9.0",
 "@opentelemetry/context-async-hooks": "^2.6.0",
 "@opentelemetry/core": "^2.6.0",
+"@opentelemetry/exporter-trace-otlp-http": "^0.213.0",
 "@opentelemetry/instrumentation": "^0.213.0",
 "@opentelemetry/resources": "^2.6.0",
 "@opentelemetry/sdk-trace-base": "^2.6.0",

packages/node-core/rollup.npm.config.mjs

@@ -19,7 +19,7 @@ export default [
 localVariablesWorkerConfig,
  ...makeNPMConfigVariants(
 makeBaseNPMConfig({
-entrypoints: ['src/index.ts','src/init.ts','src/light/index.ts'],
+entrypoints: ['src/index.ts','src/init.ts','src/light/index.ts','src/light/integrations/otlpIntegration.ts'],
 packageSpecificConfig: {
 output: {
 // set exports to 'named' or 'auto' so that rollup doesn't warn

packages/node-core/src/light/integrations/otlpIntegration.ts

@@ -0,0 +1,142 @@
+import{trace}from'@opentelemetry/api';
+import{OTLPTraceExporter}from'@opentelemetry/exporter-trace-otlp-http';
+importtype{SpanExporter}from'@opentelemetry/sdk-trace-base';
+import{BasicTracerProvider,BatchSpanProcessor}from'@opentelemetry/sdk-trace-base';
+importtype{Client,IntegrationFn}from'@sentry/core';
+import{debug,defineIntegration,registerExternalPropagationContext,SENTRY_API_VERSION}from'@sentry/core';
+
+interfaceOtlpIntegrationOptions{
+/**
+ * Whether to set up the OTLP traces exporter that sends spans to Sentry.
+ * Default: true
+ */
+setupOtlpTracesExporter?: boolean;
+
+/**
+ * URL of your own OpenTelemetry collector.
+ * When set, the exporter will send traces to this URL instead of the Sentry OTLP endpoint derived from the DSN.
+ * Default: undefined (uses DSN-derived endpoint)
+ */
+collectorUrl?: string;
+}
+
+constINTEGRATION_NAME='OtlpIntegration';
+
+const_otlpIntegration=((userOptions: OtlpIntegrationOptions={})=>{
+constoptions={
+setupOtlpTracesExporter: userOptions.setupOtlpTracesExporter??true,
+collectorUrl: userOptions.collectorUrl,
+};
+
+let_spanProcessor: BatchSpanProcessor|undefined;
+let_tracerProvider: BasicTracerProvider|undefined;
+
+return{
+name: INTEGRATION_NAME,
+
+setup(_client: Client): void{
+// Always register external propagation context so that Sentry error/log events
+// are linked to the active OTel trace context.
+registerExternalPropagationContext(()=>{
+constactiveSpan=trace.getActiveSpan();
+if(!activeSpan){
+returnundefined;
+}
+constspanContext=activeSpan.spanContext();
+return{traceId: spanContext.traceId,spanId: spanContext.spanId};
+});
+
+debug.log(`[${INTEGRATION_NAME}] External propagation context registered.`);
+},
+
+afterAllSetup(client: Client): void{
+if(options.setupOtlpTracesExporter){
+setupTracesExporter(client);
+}
+},
+};
+
+functionsetupTracesExporter(client: Client): void{
+letendpoint: string;
+letheaders: Record<string,string>|undefined;
+
+if(options.collectorUrl){
+endpoint=options.collectorUrl;
+debug.log(`[${INTEGRATION_NAME}] Sending traces to collector at ${endpoint}`);
+}else{
+constdsn=client.getDsn();
+if(!dsn){
+debug.warn(`[${INTEGRATION_NAME}] No DSN found. OTLP exporter not set up.`);
+return;
+}
+
+const{ protocol, host, port, path, projectId, publicKey }=dsn;
+
+constbasePath=path ? `/${path}` : '';
+constportStr=port ? `:${port}` : '';
+endpoint=`${protocol}://${host}${portStr}${basePath}/api/${projectId}/integration/otlp/v1/traces/`;
+
+constsdkInfo=client.getSdkMetadata()?.sdk;
+constsentryClient=sdkInfo ? `, sentry_client=${sdkInfo.name}/${sdkInfo.version}` : '';
+headers={
+'X-Sentry-Auth': `Sentry sentry_version=${SENTRY_API_VERSION}, sentry_key=${publicKey}${sentryClient}`,
+};
+}
+
+letexporter: SpanExporter;
+try{
+exporter=newOTLPTraceExporter({
+url: endpoint,
+ headers,
+});
+}catch(e){
+debug.warn(`[${INTEGRATION_NAME}] Failed to create OTLPTraceExporter:`,e);
+return;
+}
+
+_spanProcessor=newBatchSpanProcessor(exporter);
+
+// Add span processor to existing global tracer provider.
+// trace.getTracerProvider() returns a ProxyTracerProvider; unwrap it to get the real provider.
+constglobalProvider=trace.getTracerProvider();
+constdelegate=
+'getDelegate'inglobalProvider
+ ? (globalProviderasunknownas{getDelegate(): unknown}).getDelegate()
+ : globalProvider;
+
+// In OTel v2, addSpanProcessor was removed. We push into the internal _spanProcessors
+// array on the MultiSpanProcessor, which is how OTel's own forceFlush() accesses it.
+constactiveProcessor=(delegateasRecord<string,unknown>)?._activeSpanProcessoras
+|{_spanProcessors?: unknown[]}
+|undefined;
+if(activeProcessor?._spanProcessors){
+activeProcessor._spanProcessors.push(_spanProcessor);
+debug.log(`[${INTEGRATION_NAME}] Added span processor to existing TracerProvider.`);
+}else{
+// No user-configured provider; create a minimal one and set it as global
+_tracerProvider=newBasicTracerProvider({
+spanProcessors: [_spanProcessor],
+});
+trace.setGlobalTracerProvider(_tracerProvider);
+debug.log(`[${INTEGRATION_NAME}] Created new TracerProvider with OTLP span processor.`);
+}
+
+client.on('flush',()=>{
+void_spanProcessor?.forceFlush();
+});
+
+client.on('close',()=>{
+void_spanProcessor?.shutdown();
+void_tracerProvider?.shutdown();
+});
+}
+})satisfiesIntegrationFn;
+
+/**
+ * OTLP integration for the Sentry light SDK.
+ *
+ * Bridges an existing OpenTelemetry setup with Sentry by:
+ * 1. Linking Sentry error/log events to the active OTel trace context
+ * 2. Exporting OTel spans to Sentry via OTLP (or to a custom collector)
+ */
+exportconstotlpIntegration=defineIntegration(_otlpIntegration);

packages/node-core/test/light/integrations/otlpIntegration.test.ts

@@ -0,0 +1,73 @@
+import{afterEach,describe,expect,it}from'vitest';
+import{otlpIntegration}from'../../../src/light/integrations/otlpIntegration';
+import{cleanupLightSdk,mockLightSdkInit}from'../../helpers/mockLightSdkInit';
+
+describe('Light Mode | otlpIntegration',()=>{
+afterEach(()=>{
+cleanupLightSdk();
+});
+
+it('has correct integration name',()=>{
+constintegration=otlpIntegration();
+expect(integration.name).toBe('OtlpIntegration');
+});
+
+it('accepts empty options',()=>{
+constintegration=otlpIntegration();
+expect(integration.name).toBe('OtlpIntegration');
+});
+
+it('accepts all options',()=>{
+constintegration=otlpIntegration({
+setupOtlpTracesExporter: false,
+collectorUrl: 'https://my-collector.example.com/v1/traces',
+});
+expect(integration.name).toBe('OtlpIntegration');
+});
+
+describe('endpoint construction',()=>{
+it('constructs correct endpoint from DSN',()=>{
+constclient=mockLightSdkInit({
+integrations: [otlpIntegration()],
+});
+
+constdsn=client?.getDsn();
+expect(dsn).toBeDefined();
+expect(dsn?.host).toBe('domain');
+expect(dsn?.projectId).toBe('123');
+});
+
+it('handles DSN with port and path',()=>{
+constclient=mockLightSdkInit({
+dsn: 'https://key@sentry.example.com:9000/mypath/456',
+integrations: [otlpIntegration()],
+});
+
+constdsn=client?.getDsn();
+expect(dsn?.host).toBe('sentry.example.com');
+expect(dsn?.port).toBe('9000');
+expect(dsn?.path).toBe('mypath');
+expect(dsn?.projectId).toBe('456');
+});
+});
+
+describe('auth header',()=>{
+it('constructs correct X-Sentry-Auth header format with sentry_client',()=>{
+constclient=mockLightSdkInit({
+integrations: [otlpIntegration()],
+});
+
+constdsn=client?.getDsn();
+expect(dsn?.publicKey).toBe('username');
+
+constsdkInfo=client?.getSdkMetadata()?.sdk;
+expect(sdkInfo?.name).toBe('sentry.javascript.node-light');
+expect(sdkInfo?.version).toBeDefined();
+
+constexpectedAuth=`Sentry sentry_version=7, sentry_key=${dsn?.publicKey}, sentry_client=${sdkInfo?.name}/${sdkInfo?.version}`;
+expect(expectedAuth).toMatch(
+/^Sentrysentry_version=7,sentry_key=username,sentry_client=sentry\.javascript\.node-light\/.+$/,
+);
+});
+});
+});