Allow explicit context for OpenTelemetry logs

package.json

@@ -46,6 +46,9 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@opentelemetry/context-async-hooks": "^2.7.1",
+    "@opentelemetry/sdk-logs": "^0.218.0",
+    "@opentelemetry/sdk-trace-base": "^2.7.1",
     "@types/json-stringify-safe": "^5.0.3",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^25.6.0",
@@ -75,6 +78,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.218.0",
     "ajv": "^8.18.0",
     "json-stringify-safe": "^5.0.1",

src/lib/plugins/otelOutput.ts

@@ -1,20 +1,25 @@
-
+import type { Context } from '@opentelemetry/api'
 import { logs as logsAPI, Logger, LoggerProvider, SeverityNumber, LogAttributes} from '@opentelemetry/api-logs'
 import { OutputPlugin } from './interfaces.js'
 import { Record, RecordType } from '../logger/record.js'
 import { Level } from '../logger/level.js'
 
+export type OpenTelemetryLogContextResolver = (record: Record) => Context | undefined
+export type OpenTelemetryLogContext = Context | OpenTelemetryLogContextResolver
+
 export class OpenTelemetryLogsOutputPlugin implements OutputPlugin {
     private logger: Logger
     private includeFieldsAsAttributes: FieldInclusionMode
+    private context?: OpenTelemetryLogContext
 
-    public constructor(loggerProvider?: LoggerProvider) {
+    public constructor(loggerProvider?: LoggerProvider, context?: OpenTelemetryLogContext) {
         if (loggerProvider) {
             this.logger = loggerProvider.getLogger('default')
         } else {
             this.logger = logsAPI.getLoggerProvider().getLogger("default")
         }
         this.includeFieldsAsAttributes = FieldInclusionMode.CustomFieldsOnly
+        this.context = context
     }
 
     public setIncludeFieldsAsAttributes(includeFieldsAsAttributes: FieldInclusionMode) {
@@ -31,15 +36,24 @@ export class OpenTelemetryLogsOutputPlugin implements OutputPlugin {
         this.populateAdditionalAttributes(record, attributes)
 
         const severityNumber = this.mapLevelToSeverityNumber(record.metadata.level)
+        const context = this.resolveContext(record)
 
         this.logger.emit({
             severityNumber: severityNumber,
             severityText: SeverityNumber[severityNumber],
             body: record.metadata.message,
-            attributes: attributes
+            attributes: attributes,
+            ...(context && { context })
         })
     }
 
+    private resolveContext(record: Record): Context | undefined {
+        if (typeof this.context === 'function') {
+            return this.context(record)
+        }
+        return this.context
+    }
+
     private mapLevelToSeverityNumber(level: Level): SeverityNumber {
         switch (level) {
             case Level.Error:

src/test/unit-test/otel-output.test.js

@@ -0,0 +1,118 @@
+const { context, SpanKind, trace, TraceFlags } = require('@opentelemetry/api');
+const { SeverityNumber } = require('@opentelemetry/api-logs');
+const { AsyncLocalStorageContextManager } = require('@opentelemetry/context-async-hooks');
+const {
+    InMemoryLogRecordExporter,
+    LoggerProvider,
+    SimpleLogRecordProcessor
+} = require('@opentelemetry/sdk-logs');
+const { BasicTracerProvider } = require('@opentelemetry/sdk-trace-base');
+const { expect } = require('chai');
+
+const { BUILD_CJS_LIB } = require('../paths');
+const { Level } = require(`${BUILD_CJS_LIB}/logger/level.js`);
+const { Record, RecordType } = require(`${BUILD_CJS_LIB}/logger/record.js`);
+const {
+    FieldInclusionMode,
+    OpenTelemetryLogsOutputPlugin
+} = require(`${BUILD_CJS_LIB}/plugins/otelOutput.js`);
+
+describe('OpenTelemetryLogsOutputPlugin', function () {
+    let contextManager;
+    let exporter;
+    let loggerProvider;
+    let tracerProvider;
+
+    beforeEach(function () {
+        contextManager = new AsyncLocalStorageContextManager().enable();
+        context.setGlobalContextManager(contextManager);
+        exporter = new InMemoryLogRecordExporter();
+        loggerProvider = new LoggerProvider({
+            processors: [new SimpleLogRecordProcessor(exporter)]
+        });
+    });
+
+    afterEach(async function () {
+        await loggerProvider.shutdown();
+        if (tracerProvider) {
+            await tracerProvider.shutdown();
+        }
+        context.disable();
+        contextManager.disable();
+    });
+
+    it('uses the active context when no context is configured', function () {
+        const plugin = new OpenTelemetryLogsOutputPlugin(loggerProvider);
+        const nonRecordingSpanContext = {
+            traceId: '11111111111111111111111111111111',
+            spanId: '2222222222222222',
+            traceFlags: TraceFlags.NONE
+        };
+        const activeContext = trace.setSpanContext(context.active(), nonRecordingSpanContext);
+
+        context.with(activeContext, () => plugin.writeRecord(createRecord()));
+
+        const [logRecord] = exporter.getFinishedLogRecords();
+        expect(logRecord.spanContext).to.deep.equal(nonRecordingSpanContext);
+        expect(trace.getSpan(activeContext).isRecording()).to.equal(false);
+    });
+
+    it('uses an explicitly provided context', function () {
+        const explicitSpanContext = {
+            traceId: '33333333333333333333333333333333',
+            spanId: '4444444444444444',
+            traceFlags: TraceFlags.SAMPLED
+        };
+        const explicitContext = trace.setSpanContext(context.active(), explicitSpanContext);
+        const plugin = new OpenTelemetryLogsOutputPlugin(loggerProvider, explicitContext);
+
+        plugin.writeRecord(createRecord());
+
+        const [logRecord] = exporter.getFinishedLogRecords();
+        expect(logRecord.spanContext).to.deep.equal(explicitSpanContext);
+    });
+
+    it('uses a resolved recording server context while preserving log fields', function () {
+        tracerProvider = new BasicTracerProvider();
+        const serverSpan = tracerProvider.getTracer('test').startSpan('request', {
+            kind: SpanKind.SERVER
+        });
+        const serverContext = trace.setSpan(context.active(), serverSpan);
+        const droppedSpanContext = {
+            traceId: '55555555555555555555555555555555',
+            spanId: '6666666666666666',
+            traceFlags: TraceFlags.NONE
+        };
+        const droppedContext = trace.setSpanContext(context.active(), droppedSpanContext);
+        const record = createRecord();
+        let resolvedRecord;
+        const plugin = new OpenTelemetryLogsOutputPlugin(loggerProvider, currentRecord => {
+            resolvedRecord = currentRecord;
+            return serverContext;
+        });
+        plugin.setIncludeFieldsAsAttributes(FieldInclusionMode.CustomFieldsOnly);
+
+        context.with(droppedContext, () => plugin.writeRecord(record));
+
+        const [logRecord] = exporter.getFinishedLogRecords();
+        expect(resolvedRecord).to.equal(record);
+        expect(serverSpan.isRecording()).to.equal(true);
+        expect(logRecord.spanContext).to.deep.equal(serverSpan.spanContext());
+        expect(logRecord.spanContext.spanId).not.to.equal(droppedSpanContext.spanId);
+        expect(logRecord.severityNumber).to.equal(SeverityNumber.WARN);
+        expect(logRecord.severityText).to.equal('WARN');
+        expect(logRecord.body).to.equal('context test');
+        expect(logRecord.attributes).to.deep.equal({ custom: 'value' });
+
+        serverSpan.end();
+    });
+
+    function createRecord() {
+        const record = new Record(RecordType.Message, Level.Warn);
+        record.metadata.message = 'context test';
+        record.metadata.customFieldNames.push('custom');
+        record.payload.custom = 'value';
+        record.payload.internal = 'not included';
+        return record;
+    }
+});