feat(sdk-logs): logger option support includeTraceContext & LogRecordProcessor onEmit suport context

Author: fuaiyi

experimental/packages/api-logs/src/types/LogRecord.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { Attributes } from '@opentelemetry/api';
+import { Attributes, Context } from '@opentelemetry/api';
 
 export enum SeverityNumber {
   UNSPECIFIED = 0,
@@ -71,17 +71,7 @@ export interface LogRecord {
   attributes?: Attributes;
 
   /**
-   * 8 least significant bits are the trace flags as defined in W3C Trace Context specification.
+   * The Context associated with the LogRecord.
    */
-  traceFlags?: number;
-
-  /**
-   * A unique identifier for a trace.
-   */
-  traceId?: string;
-
-  /**
-   * A unique identifier for a span within a trace.
-   */
-  spanId?: string;
+  context?: Context;
 }

experimental/packages/api-logs/src/types/LoggerOptions.ts

@@ -27,4 +27,10 @@ export interface LoggerOptions {
    * The instrumentation scope attributes to associate with emitted telemetry
    */
   scopeAttributes?: Attributes;
+
+  /**
+   * Specifies whether the Trace Context should automatically be passed on to the LogRecords emitted by the Logger.
+   * @default true
+   */
+  includeTraceContext?: boolean;
 }

experimental/packages/sdk-logs/src/LogRecord.ts

@@ -28,17 +28,16 @@ import type { ReadableLogRecord } from './export/ReadableLogRecord';
 import type { LogRecordLimits } from './types';
 import { Logger } from './Logger';
 
-export class LogRecord implements logsAPI.LogRecord, ReadableLogRecord {
-  readonly time: api.HrTime;
-  readonly traceId?: string;
-  readonly spanId?: string;
-  readonly traceFlags?: number;
+export class LogRecord implements ReadableLogRecord {
+  readonly hrTime: api.HrTime;
+  readonly spanContext?: api.SpanContext;
   readonly resource: IResource;
   readonly instrumentationScope: InstrumentationScope;
   readonly attributes: Attributes = {};
   private _severityText?: string;
   private _severityNumber?: logsAPI.SeverityNumber;
   private _body?: string;
+
   private _isReadonly: boolean = false;
   private readonly _logRecordLimits: LogRecordLimits;
 
@@ -79,15 +78,16 @@ export class LogRecord implements logsAPI.LogRecord, ReadableLogRecord {
       severityText,
       body,
       attributes = {},
-      spanId,
-      traceFlags,
-      traceId,
+      context,
     } = logRecord;
 
-    this.time = timeInputToHrTime(timestamp);
-    this.spanId = spanId;
-    this.traceId = traceId;
-    this.traceFlags = traceFlags;
+    this.hrTime = timeInputToHrTime(timestamp);
+    if (context) {
+      const spanContext = api.trace.getSpanContext(context);
+      if (spanContext && api.isSpanContextValid(spanContext)) {
+        this.spanContext = spanContext;
+      }
+    }
     this.severityNumber = severityNumber;
     this.severityText = severityText;
     this.body = body;

experimental/packages/sdk-logs/src/LogRecordProcessor.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import { Context } from '@opentelemetry/api';
+
 import { LogRecord } from './LogRecord';
 
 export interface LogRecordProcessor {
@@ -25,8 +27,9 @@ export interface LogRecordProcessor {
   /**
    * Called when a {@link LogRecord} is emit
    * @param logRecord the ReadWriteLogRecord that just emitted.
+   * @param context the current Context, or an empty Context if the Logger was obtained with include_trace_context=false
    */
-  onEmit(logRecord: LogRecord): void;
+  onEmit(logRecord: LogRecord, context?: Context): void;
 
   /**
    * Shuts down the processor. Called when SDK is shut down. This is an

experimental/packages/sdk-logs/src/Logger.ts

@@ -17,6 +17,7 @@
 import type * as logsAPI from '@opentelemetry/api-logs';
 import type { IResource } from '@opentelemetry/resources';
 import type { InstrumentationScope } from '@opentelemetry/core';
+import { context } from '@opentelemetry/api';
 
 import type { LoggerConfig, LogRecordLimits } from './types';
 import { LogRecord } from './LogRecord';
@@ -26,21 +27,38 @@ import { LogRecordProcessor } from './LogRecordProcessor';
 
 export class Logger implements logsAPI.Logger {
   public readonly resource: IResource;
-  private readonly _logRecordLimits: LogRecordLimits;
+  private readonly _loggerConfig: Required<LoggerConfig>;
 
   constructor(
     public readonly instrumentationScope: InstrumentationScope,
     config: LoggerConfig,
     private _loggerProvider: LoggerProvider
   ) {
-    const localConfig = mergeConfig(config);
+    this._loggerConfig = mergeConfig(config);
     this.resource = _loggerProvider.resource;
-    this._logRecordLimits = localConfig.logRecordLimits!;
   }
 
   public emit(logRecord: logsAPI.LogRecord): void {
-    const logRecordInstance = new LogRecord(this, logRecord);
-    this.getActiveLogRecordProcessor().onEmit(logRecordInstance);
+    const currentContext = this._loggerConfig.includeTraceContext
+      ? context.active()
+      : undefined;
+    /**
+     * If a Logger was obtained with include_trace_context=true,
+     * the LogRecords it emits MUST automatically include the Trace Context from the active Context,
+     * if Context has not been explicitly set.
+     */
+    const logRecordInstance = new LogRecord(this, {
+      context: currentContext,
+      ...logRecord,
+    });
+    /**
+     * the explicitly passed Context,
+     * the current Context, or an empty Context if the Logger was obtained with include_trace_context=false
+     */
+    this.getActiveLogRecordProcessor().onEmit(
+      logRecordInstance,
+      currentContext
+    );
     /**
      * A LogRecordProcessor may freely modify logRecord for the duration of the OnEmit call.
      * If logRecord is needed after OnEmit returns (i.e. for asynchronous processing) only reads are permitted.
@@ -49,7 +67,7 @@ export class Logger implements logsAPI.Logger {
   }
 
   public getLogRecordLimits(): LogRecordLimits {
-    return this._logRecordLimits;
+    return this._loggerConfig.logRecordLimits;
   }
 
   public getActiveLogRecordProcessor(): LogRecordProcessor {

experimental/packages/sdk-logs/src/LoggerProvider.ts

@@ -82,7 +82,10 @@ export class LoggerProvider implements logsAPI.LoggerProvider {
         key,
         new Logger(
           { name: loggerName, version, schemaUrl: options?.schemaUrl },
-          this._config,
+          {
+            logRecordLimits: this._config.logRecordLimits,
+            includeTraceContext: options?.includeTraceContext,
+          },
           this
         )
       );

experimental/packages/sdk-logs/src/config.ts

@@ -20,7 +20,7 @@ import {
   getEnv,
   getEnvWithoutDefaults,
 } from '@opentelemetry/core';
-import { LoggerConfig, LogRecordLimits } from './types';
+import { LoggerConfig } from './types';
 
 export function loadDefaultConfig() {
   return {
@@ -30,6 +30,7 @@ export function loadDefaultConfig() {
         getEnv().OTEL_LOGRECORD_ATTRIBUTE_VALUE_LENGTH_LIMIT,
       attributeCountLimit: getEnv().OTEL_LOGRECORD_ATTRIBUTE_COUNT_LIMIT,
     },
+    includeTraceContext: true,
   };
 }
 
@@ -68,9 +69,7 @@ export function reconfigureLimits(userConfig: LoggerConfig): LoggerConfig {
  * Function to merge Default configuration (as specified in './config') with
  * user provided configurations.
  */
-export function mergeConfig(userConfig: LoggerConfig): LoggerConfig & {
-  logRecordLimits: LogRecordLimits;
-} {
+export function mergeConfig(userConfig: LoggerConfig): Required<LoggerConfig> {
   const DEFAULT_CONFIG = loadDefaultConfig();
 
   const target = Object.assign({}, DEFAULT_CONFIG, userConfig);

experimental/packages/sdk-logs/src/export/ConsoleLogRecordExporter.ts

@@ -52,10 +52,10 @@ export class ConsoleLogRecordExporter implements LogRecordExporter {
    */
   private _exportInfo(logRecord: ReadableLogRecord) {
     return {
-      timestamp: hrTimeToMicroseconds(logRecord.time),
-      traceId: logRecord.traceId,
-      spanId: logRecord.spanId,
-      traceFlags: logRecord.traceFlags,
+      timestamp: hrTimeToMicroseconds(logRecord.hrTime),
+      traceId: logRecord.spanContext?.traceId,
+      spanId: logRecord.spanContext?.spanId,
+      traceFlags: logRecord.spanContext?.traceFlags,
       severityText: logRecord.severityText,
       severityNumber: logRecord.severityNumber,
       body: logRecord.body,

experimental/packages/sdk-logs/src/export/ReadableLogRecord.ts

@@ -15,15 +15,13 @@
  */
 
 import type { IResource } from '@opentelemetry/resources';
-import type { Attributes, HrTime } from '@opentelemetry/api';
+import type { Attributes, HrTime, SpanContext } from '@opentelemetry/api';
 import type { InstrumentationScope } from '@opentelemetry/core';
 import type { SeverityNumber } from '@opentelemetry/api-logs';
 
 export interface ReadableLogRecord {
-  readonly time: HrTime;
-  readonly traceId?: string;
-  readonly spanId?: string;
-  readonly traceFlags?: number;
+  readonly hrTime: HrTime;
+  readonly spanContext?: SpanContext;
   readonly severityText?: string;
   readonly severityNumber?: SeverityNumber;
   readonly body?: string;

experimental/packages/sdk-logs/src/types.ts

@@ -16,7 +16,7 @@
 
 import type { IResource } from '@opentelemetry/resources';
 
-export interface LoggerProviderConfig extends LoggerConfig {
+export interface LoggerProviderConfig {
   /** Resource associated with trace telemetry  */
   resource?: IResource;
 
@@ -25,11 +25,17 @@ export interface LoggerProviderConfig extends LoggerConfig {
    * The default value is 30000ms
    */
   forceFlushTimeoutMillis?: number;
+
+  /** Log Record Limits*/
+  logRecordLimits?: LogRecordLimits;
 }
 
 export interface LoggerConfig {
   /** Log Record Limits*/
   logRecordLimits?: LogRecordLimits;
+
+  /** include Trace Context */
+  includeTraceContext?: boolean;
 }
 
 export interface LogRecordLimits {

experimental/packages/sdk-logs/test/common/LogRecord.test.ts

@@ -16,7 +16,14 @@
 
 import * as sinon from 'sinon';
 import * as assert from 'assert';
-import { Attributes, AttributeValue, diag } from '@opentelemetry/api';
+import {
+  Attributes,
+  AttributeValue,
+  diag,
+  ROOT_CONTEXT,
+  trace,
+  TraceFlags,
+} from '@opentelemetry/api';
 import * as logsAPI from '@opentelemetry/api-logs';
 import type { HrTime } from '@opentelemetry/api';
 import { hrTimeToMilliseconds, timeInputToHrTime } from '@opentelemetry/core';
@@ -61,14 +68,21 @@ describe('LogRecord', () => {
 
     it('should have a default timestamp', () => {
       const { logRecord } = setup();
-      assert.ok(logRecord.time !== undefined);
+      assert.ok(logRecord.hrTime !== undefined);
       assert.ok(
-        hrTimeToMilliseconds(logRecord.time) >
+        hrTimeToMilliseconds(logRecord.hrTime) >
           hrTimeToMilliseconds(performanceTimeOrigin)
       );
     });
 
     it('should return LogRecord', () => {
+      const spanContext = {
+        traceId: 'd4cda95b652f4a1592b449d5929fda1b',
+        spanId: '6e0c63257de34c92',
+        traceFlags: TraceFlags.SAMPLED,
+      };
+      const activeContext = trace.setSpanContext(ROOT_CONTEXT, spanContext);
+
       const logRecordData: logsAPI.LogRecord = {
         timestamp: new Date().getTime(),
         severityNumber: logsAPI.SeverityNumber.DEBUG,
@@ -77,16 +91,14 @@ describe('LogRecord', () => {
         attributes: {
           name: 'test name',
         },
-        traceId: 'trance id',
-        spanId: 'span id',
-        traceFlags: 1,
+        context: activeContext,
       };
       const { logRecord, resource, instrumentationScope } = setup(
         undefined,
         logRecordData
       );
       assert.deepStrictEqual(
-        logRecord.time,
+        logRecord.hrTime,
         timeInputToHrTime(logRecordData.timestamp!)
       );
       assert.strictEqual(
@@ -96,9 +108,12 @@ describe('LogRecord', () => {
       assert.strictEqual(logRecord.severityText, logRecordData.severityText);
       assert.strictEqual(logRecord.body, logRecordData.body);
       assert.deepStrictEqual(logRecord.attributes, logRecordData.attributes);
-      assert.deepStrictEqual(logRecord.traceId, logRecordData.traceId);
-      assert.deepStrictEqual(logRecord.spanId, logRecordData.spanId);
-      assert.deepStrictEqual(logRecord.traceFlags, logRecordData.traceFlags);
+      assert.strictEqual(logRecord.spanContext?.traceId, spanContext.traceId);
+      assert.strictEqual(logRecord.spanContext?.spanId, spanContext.spanId);
+      assert.strictEqual(
+        logRecord.spanContext?.traceFlags,
+        spanContext.traceFlags
+      );
       assert.deepStrictEqual(logRecord.resource, resource);
       assert.deepStrictEqual(
         logRecord.instrumentationScope,
@@ -115,9 +130,6 @@ describe('LogRecord', () => {
         attributes: {
           name: 'test name',
         },
-        traceId: 'trance id',
-        spanId: 'span id',
-        traceFlags: 1,
       };
       const { logRecord } = setup(undefined, logRecordData);
 
@@ -258,9 +270,6 @@ describe('LogRecord', () => {
       attributes: {
         name: 'test name',
       },
-      traceId: 'trance id',
-      spanId: 'span id',
-      traceFlags: 1,
     };
 
     const newBody = 'this is a new body';
@@ -302,9 +311,6 @@ describe('LogRecord', () => {
       attributes: {
         name: 'test name',
       },
-      traceId: 'trance id',
-      spanId: 'span id',
-      traceFlags: 1,
     };
 
     const newBody = 'this is a new body';