feat(api-logs, sdk-logs)!: add Logger#enabled method

experimental/CHANGELOG.md

@@ -30,6 +30,7 @@ For notes on migrating to 2.x / 0.200.x see [the upgrade guide](doc/upgrade-to-2
     `NodeSDK` from `@opentelemetry/sdk-node` to get automatic environment variable configuration.
 * fix(instrumentation-http)!: do not normalize hyphens to underscores in captured header attribute names if using stable semconv [#6381](https://github.com/open-telemetry/opentelemetry-js/issues/6381) @trentm
   * With the `headersToSpanAttributes` option, one can specify that HTTP headers should be captured as span attributes named `http.{request,response}.header.HEADERNAME`. With old Semantic Conventions, the `HEADERNAME` normalizes hyphens to underscores, e.g. `http.response.header.content_length`. When stable HTTP semconv is enabled (via `OTEL_SEMCONV_STABILITY_OPT_IN`), hyphens are no longer changed, e.g. `http.response.header.content-length`.
+* feat(api-logs, sdk-logs)!: add `enabled` method to Logger interface and implementi it in logs API and SDK [#6371](https://github.com/open-telemetry/opentelemetry-js/pull/6371) @david-luna
 
 ### :rocket: Features
 

experimental/packages/api-logs/src/NoopLogger.ts

@@ -19,6 +19,9 @@ import { LogRecord } from './types/LogRecord';
 
 export class NoopLogger implements Logger {
   emit(_logRecord: LogRecord): void {}
+  enabled(): boolean {
+    return false;
+  }
 }
 
 export const NOOP_LOGGER = new NoopLogger();

experimental/packages/api-logs/src/ProxyLogger.ts

@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
+import { Context } from '@opentelemetry/api';
 import { NOOP_LOGGER } from './NoopLogger';
 import { Logger } from './types/Logger';
 import { LoggerOptions } from './types/LoggerOptions';
-import { LogRecord } from './types/LogRecord';
+import { LogRecord, SeverityNumber } from './types/LogRecord';
 
 export class ProxyLogger implements Logger {
   // When a real implementation is provided, this will be it
@@ -48,6 +49,19 @@ export class ProxyLogger implements Logger {
     this._getLogger().emit(logRecord);
   }
 
+  /**
+   * Returns `true` if the logger is enabled for the given options.
+   *
+   * @param options
+   */
+  enabled(options?: {
+    context?: Context;
+    severityNumber?: SeverityNumber;
+    eventName?: string;
+  }): boolean {
+    return this._getLogger().enabled(options);
+  }
+
   /**
    * Try to get a logger from the proxy logger provider.
    * If the proxy logger provider has no delegate, return a noop logger.

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

@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-import { LogRecord } from './LogRecord';
+import type { Context } from '@opentelemetry/api';
+import { LogRecord, SeverityNumber } from './LogRecord';
 
 export interface Logger {
   /**
@@ -23,4 +24,15 @@ export interface Logger {
    * @param logRecord
    */
   emit(logRecord: LogRecord): void;
+
+  /**
+   * Tells if the logger is enabled for the given context, severity number and event
+   * name if provided.
+   * @param options the context, severity number and event name
+   */
+  enabled(options?: {
+    context?: Context;
+    severityNumber?: SeverityNumber;
+    eventName?: string;
+  }): boolean;
 }

experimental/packages/api-logs/test/noop-implementations/noop-logger.test.ts

@@ -32,4 +32,9 @@ describe('NoopLogger', () => {
       body: 'log body',
     });
   });
+
+  it('calling enabled should return false', () => {
+    const logger = new NoopLoggerProvider().getLogger('test-noop');
+    assert.ok(!logger.enabled());
+  });
 });

experimental/packages/api-logs/test/proxy-implementations/proxy-logger.test.ts

@@ -85,13 +85,18 @@ describe('ProxyLogger', () => {
 
     let delegateLogger: Logger;
     let emitCalled: boolean;
+    let enabledCalled: boolean;
 
     beforeEach(() => {
       emitCalled = false;
       delegateLogger = {
         emit() {
           emitCalled = true;
         },
+        enabled() {
+          enabledCalled = true;
+          return true;
+        },
       };
 
       logger = provider.getLogger('test');
@@ -110,5 +115,10 @@ describe('ProxyLogger', () => {
       });
       assert.ok(emitCalled);
     });
+
+    it('should call enabled from the delegate logger', () => {
+      logger.enabled();
+      assert.ok(enabledCalled);
+    });
   });
 });

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

@@ -15,6 +15,8 @@
  */
 
 import { Context } from '@opentelemetry/api';
+import { SeverityNumber } from '@opentelemetry/api-logs';
+import { InstrumentationScope } from '@opentelemetry/core';
 
 import { SdkLogRecord } from './export/SdkLogRecord';
 
@@ -36,4 +38,16 @@ export interface LogRecordProcessor {
    * opportunity for processor to do any cleanup required.
    */
   shutdown(): Promise<void>;
+
+  /**
+   * Tells if the logger is enabled for the given context, severity number and event
+   * name if provided.
+   * @param options
+   */
+  enabled?(options: {
+    context: Context;
+    instrumentationScope: InstrumentationScope;
+    severityNumber?: SeverityNumber;
+    eventName?: string;
+  }): boolean;
 }

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

@@ -22,6 +22,7 @@ import {
   trace,
   TraceFlags,
   isSpanContextValid,
+  Context,
 } from '@opentelemetry/api';
 
 import { LogRecordImpl } from './LogRecordImpl';
@@ -108,4 +109,46 @@ export class Logger implements logsAPI.Logger {
      */
     logRecordInstance._makeReadonly();
   }
+
+  public enabled(options?: {
+    context?: Context;
+    severityNumber?: SeverityNumber;
+    eventName?: string;
+  }): boolean {
+    // This logger is disabled
+    if (this._loggerConfig.disabled) {
+      return false;
+    }
+
+    // Severity number given and lower than the min configured
+    let severityNumber = options?.severityNumber;
+    if (typeof severityNumber !== 'number' || isNaN(severityNumber)) {
+      severityNumber = SeverityNumber.UNSPECIFIED;
+    }
+    if (severityNumber < this._loggerConfig.minimumSeverity) {
+      return false;
+    }
+
+    // Trace based: the context (given or the active) has a unsampled Span
+    if (this._loggerConfig.traceBased) {
+      const span = trace.getSpan(options?.context || context.active());
+      if (span && span.spanContext().traceFlags === TraceFlags.NONE) {
+        return false;
+      }
+    }
+
+    // Lastly check if there is any enabled processor
+    const enabledOpts = {
+      context: options?.context || context.active(),
+      instrumentationScope: this.instrumentationScope,
+      severityNumber: options?.severityNumber,
+      eventName: options?.eventName,
+    };
+    for (const processor of this._sharedState.processors) {
+      if (!processor.enabled || processor.enabled(enabledOpts)) {
+        return true;
+      }
+    }
+    return false;
+  }
 }

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

@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
-import { callWithTimeout } from '@opentelemetry/core';
+import { callWithTimeout, InstrumentationScope } from '@opentelemetry/core';
 import type { Context } from '@opentelemetry/api';
 import type { LogRecordProcessor } from './LogRecordProcessor';
 import type { SdkLogRecord } from './export/SdkLogRecord';
+import { SeverityNumber } from '@opentelemetry/api-logs';
 
 /**
  * Implementation of the {@link LogRecordProcessor} that simply forwards all
@@ -52,4 +53,18 @@ export class MultiLogRecordProcessor implements LogRecordProcessor {
   public async shutdown(): Promise<void> {
     await Promise.all(this.processors.map(processor => processor.shutdown()));
   }
+
+  public enabled(options: {
+    context: Context;
+    instrumentationScope: InstrumentationScope;
+    severityNumber?: SeverityNumber;
+    eventName?: string;
+  }): boolean {
+    for (const processor of this.processors) {
+      if (!processor.enabled || processor.enabled(options)) {
+        return true;
+      }
+    }
+    return false;
+  }
 }

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

@@ -15,17 +15,28 @@
  */
 
 import { Context } from '@opentelemetry/api';
+import { SeverityNumber } from '@opentelemetry/api-logs';
+import { InstrumentationScope } from '@opentelemetry/core';
 import { LogRecordProcessor } from '../LogRecordProcessor';
 import { ReadableLogRecord } from './ReadableLogRecord';
 
 export class NoopLogRecordProcessor implements LogRecordProcessor {
-  forceFlush(): Promise<void> {
+  public forceFlush(): Promise<void> {
     return Promise.resolve();
   }
 
-  onEmit(_logRecord: ReadableLogRecord, _context: Context): void {}
+  public onEmit(_logRecord: ReadableLogRecord, _context: Context): void {}
 
-  shutdown(): Promise<void> {
+  public shutdown(): Promise<void> {
     return Promise.resolve();
   }
+
+  public enabled(_options: {
+    context: Context;
+    instrumentationScope: InstrumentationScope;
+    severityNumber?: SeverityNumber;
+    eventName?: string;
+  }): boolean {
+    return false;
+  }
 }