Incubating: Add minimum severity and trace-based logger configuration

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/ExtendedSdkLogRecordBuilder.java

@@ -25,8 +25,10 @@ final class ExtendedSdkLogRecordBuilder extends SdkLogRecordBuilder
   @Nullable private ExtendedAttributesMap extendedAttributes;
 
   ExtendedSdkLogRecordBuilder(
-      LoggerSharedState loggerSharedState, InstrumentationScopeInfo instrumentationScopeInfo) {
-    super(loggerSharedState, instrumentationScopeInfo);
+      LoggerSharedState loggerSharedState,
+      InstrumentationScopeInfo instrumentationScopeInfo,
+      SdkLogger logger) {
+    super(loggerSharedState, instrumentationScopeInfo, logger);
   }
 
   @Override
@@ -128,30 +130,18 @@ public <T> ExtendedSdkLogRecordBuilder setAttribute(AttributeKey<T> key, @Nullab
   }
 
   @Override
-  public void emit() {
-    if (loggerSharedState.hasBeenShutdown()) {
-      return;
-    }
-    Context context = this.context == null ? Context.current() : this.context;
-    long observedTimestampEpochNanos =
-        this.observedTimestampEpochNanos == 0
-            ? this.loggerSharedState.getClock().now()
-            : this.observedTimestampEpochNanos;
-    loggerSharedState
-        .getLogRecordProcessor()
-        .onEmit(
-            context,
-            ExtendedSdkReadWriteLogRecord.create(
-                loggerSharedState.getLogLimits(),
-                loggerSharedState.getResource(),
-                instrumentationScopeInfo,
-                eventName,
-                timestampEpochNanos,
-                observedTimestampEpochNanos,
-                Span.fromContext(context).getSpanContext(),
-                severity,
-                severityText,
-                body,
-                extendedAttributes));
+  protected ReadWriteLogRecord createLogRecord(Context context, long observedTimestampEpochNanos) {
+    return ExtendedSdkReadWriteLogRecord.create(
+        loggerSharedState.getLogLimits(),
+        loggerSharedState.getResource(),
+        instrumentationScopeInfo,
+        eventName,
+        timestampEpochNanos,
+        observedTimestampEpochNanos,
+        Span.fromContext(context).getSpanContext(),
+        severity,
+        severityText,
+        body,
+        extendedAttributes);
   }
 }

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/IncubatingUtil.java

@@ -25,7 +25,9 @@ static SdkLogger createExtendedLogger(
   }
 
   static SdkLogRecordBuilder createExtendedLogRecordBuilder(
-      LoggerSharedState loggerSharedState, InstrumentationScopeInfo instrumentationScopeInfo) {
-    return new ExtendedSdkLogRecordBuilder(loggerSharedState, instrumentationScopeInfo);
+      LoggerSharedState loggerSharedState,
+      InstrumentationScopeInfo instrumentationScopeInfo,
+      SdkLogger logger) {
+    return new ExtendedSdkLogRecordBuilder(loggerSharedState, instrumentationScopeInfo, logger);
   }
 }

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilder.java

@@ -22,6 +22,7 @@ class SdkLogRecordBuilder implements LogRecordBuilder {
 
   protected final LoggerSharedState loggerSharedState;
   protected final LogLimits logLimits;
+  protected final SdkLogger logger;
 
   protected final InstrumentationScopeInfo instrumentationScopeInfo;
   protected long timestampEpochNanos;
@@ -34,10 +35,13 @@ class SdkLogRecordBuilder implements LogRecordBuilder {
   @Nullable private AttributesMap attributes;
 
   SdkLogRecordBuilder(
-      LoggerSharedState loggerSharedState, InstrumentationScopeInfo instrumentationScopeInfo) {
+      LoggerSharedState loggerSharedState,
+      InstrumentationScopeInfo instrumentationScopeInfo,
+      SdkLogger logger) {
     this.loggerSharedState = loggerSharedState;
     this.logLimits = loggerSharedState.getLogLimits();
     this.instrumentationScopeInfo = instrumentationScopeInfo;
+    this.logger = logger;
   }
 
   @Override
@@ -121,25 +125,30 @@ public void emit() {
       return;
     }
     Context context = this.context == null ? Context.current() : this.context;
+    if (!logger.isEnabled(severity, context)) {
+      return;
+    }
     long observedTimestampEpochNanos =
         this.observedTimestampEpochNanos == 0
             ? this.loggerSharedState.getClock().now()
             : this.observedTimestampEpochNanos;
     loggerSharedState
         .getLogRecordProcessor()
-        .onEmit(
-            context,
-            SdkReadWriteLogRecord.create(
-                loggerSharedState.getLogLimits(),
-                loggerSharedState.getResource(),
-                instrumentationScopeInfo,
-                timestampEpochNanos,
-                observedTimestampEpochNanos,
-                Span.fromContext(context).getSpanContext(),
-                severity,
-                severityText,
-                body,
-                attributes,
-                eventName));
+        .onEmit(context, createLogRecord(context, observedTimestampEpochNanos));
+  }
+
+  protected ReadWriteLogRecord createLogRecord(Context context, long observedTimestampEpochNanos) {
+    return SdkReadWriteLogRecord.create(
+        loggerSharedState.getLogLimits(),
+        loggerSharedState.getResource(),
+        instrumentationScopeInfo,
+        timestampEpochNanos,
+        observedTimestampEpochNanos,
+        Span.fromContext(context).getSpanContext(),
+        severity,
+        severityText,
+        body,
+        attributes,
+        eventName);
   }
 }

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogger.java

@@ -9,6 +9,8 @@
 import io.opentelemetry.api.logs.Logger;
 import io.opentelemetry.api.logs.LoggerProvider;
 import io.opentelemetry.api.logs.Severity;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanContext;
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
 import io.opentelemetry.sdk.logs.internal.LoggerConfig;
@@ -34,6 +36,8 @@ class SdkLogger implements Logger {
   private final InstrumentationScopeInfo instrumentationScopeInfo;
 
   protected volatile boolean loggerEnabled;
+  protected volatile Severity minimumSeverity;
+  protected volatile boolean traceBased;
 
   SdkLogger(
       LoggerSharedState loggerSharedState,
@@ -42,6 +46,8 @@ class SdkLogger implements Logger {
     this.loggerSharedState = loggerSharedState;
     this.instrumentationScopeInfo = instrumentationScopeInfo;
     this.loggerEnabled = loggerConfig.isEnabled();
+    this.minimumSeverity = loggerConfig.getMinimumSeverity();
+    this.traceBased = loggerConfig.isTraceBased();
   }
 
   static SdkLogger create(
@@ -58,8 +64,8 @@ public LogRecordBuilder logRecordBuilder() {
     if (loggerEnabled) {
       return INCUBATOR_AVAILABLE
           ? IncubatingUtil.createExtendedLogRecordBuilder(
-              loggerSharedState, instrumentationScopeInfo)
-          : new SdkLogRecordBuilder(loggerSharedState, instrumentationScopeInfo);
+              loggerSharedState, instrumentationScopeInfo, this)
+          : new SdkLogRecordBuilder(loggerSharedState, instrumentationScopeInfo, this);
     }
     return NOOP_LOGGER.logRecordBuilder();
   }
@@ -71,10 +77,28 @@ InstrumentationScopeInfo getInstrumentationScopeInfo() {
 
   // Visible for testing
   public boolean isEnabled(Severity severity, Context context) {
-    return loggerEnabled;
+    if (!loggerEnabled) {
+      return false;
+    }
+
+    if (severity != Severity.UNDEFINED_SEVERITY_NUMBER
+        && severity.getSeverityNumber() < minimumSeverity.getSeverityNumber()) {
+      return false;
+    }
+
+    if (traceBased) {
+      SpanContext spanContext = Span.fromContext(context).getSpanContext();
+      if (spanContext.isValid() && !spanContext.getTraceFlags().isSampled()) {
+        return false;
+      }
+    }
+
+    return true;
   }
 
   void updateLoggerConfig(LoggerConfig loggerConfig) {
     loggerEnabled = loggerConfig.isEnabled();
+    minimumSeverity = loggerConfig.getMinimumSeverity();
+    traceBased = loggerConfig.isTraceBased();
   }
 }

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/internal/LoggerConfig.java

@@ -7,6 +7,7 @@
 
 import com.google.auto.value.AutoValue;
 import io.opentelemetry.api.logs.Logger;
+import io.opentelemetry.api.logs.Severity;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
 import io.opentelemetry.sdk.internal.ScopeConfigurator;
 import io.opentelemetry.sdk.internal.ScopeConfiguratorBuilder;
@@ -30,9 +31,15 @@
 public abstract class LoggerConfig {
 
   private static final LoggerConfig DEFAULT_CONFIG =
-      new AutoValue_LoggerConfig(/* enabled= */ true);
+      new AutoValue_LoggerConfig(
+          /* enabled= */ true,
+          /* minimumSeverity= */ Severity.UNDEFINED_SEVERITY_NUMBER,
+          /* traceBased= */ false);
   private static final LoggerConfig DISABLED_CONFIG =
-      new AutoValue_LoggerConfig(/* enabled= */ false);
+      new AutoValue_LoggerConfig(
+          /* enabled= */ false,
+          /* minimumSeverity= */ Severity.UNDEFINED_SEVERITY_NUMBER,
+          /* traceBased= */ false);
 
   /** Returns a disabled {@link LoggerConfig}. */
   public static LoggerConfig disabled() {
@@ -44,6 +51,11 @@ public static LoggerConfig enabled() {
     return DEFAULT_CONFIG;
   }
 
+  /** Returns a new {@link LoggerConfigBuilder} for creating a {@link LoggerConfig}. */
+  public static LoggerConfigBuilder builder() {
+    return new LoggerConfigBuilder();
+  }
+
   /**
    * Returns the default {@link LoggerConfig}, which is used when no configurator is set or when the
    * logger configurator returns {@code null} for a {@link InstrumentationScopeInfo}.
@@ -62,6 +74,31 @@ public static ScopeConfiguratorBuilder<LoggerConfig> configuratorBuilder() {
 
   LoggerConfig() {}
 
+  static LoggerConfig create(boolean enabled, Severity minimumSeverity, boolean traceBased) {
+    return new AutoValue_LoggerConfig(enabled, minimumSeverity, traceBased);
+  }
+
   /** Returns {@code true} if this logger is enabled. Defaults to {@code true}. */
   public abstract boolean isEnabled();
+
+  /**
+   * Returns the minimum severity level for log records to be processed.
+   *
+   * <p>Log records with a severity number less than this value will be dropped. Log records without
+   * a specified severity are not affected by this setting.
+   *
+   * <p>Defaults to {@link Severity#UNDEFINED_SEVERITY_NUMBER}.
+   */
+  public abstract Severity getMinimumSeverity();
+
+  /**
+   * Returns {@code true} if this logger should only process log records from traces when the trace
+   * is sampled.
+   *
+   * <p>When enabled, log records from unsampled traces will be dropped. Log records that are not
+   * associated with a trace context are unaffected.
+   *
+   * <p>Defaults to {@code false}.
+   */
+  public abstract boolean isTraceBased();
 }

sdk/logs/src/main/java/io/opentelemetry/sdk/logs/internal/LoggerConfigBuilder.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs.internal;
+
+import io.opentelemetry.api.logs.Severity;
+
+/**
+ * Builder for {@link LoggerConfig}.
+ *
+ * <p>This class is internal and experimental. Its APIs are unstable and can change at any time. Its
+ * APIs (or a version of them) may be promoted to the public stable API in the future, but no
+ * guarantees are made.
+ */
+public final class LoggerConfigBuilder {
+  private boolean enabled = true;
+  private Severity minimumSeverity = Severity.UNDEFINED_SEVERITY_NUMBER;
+  private boolean traceBased = false;
+
+  LoggerConfigBuilder() {}
+
+  /**
+   * Sets whether the logger is enabled.
+   *
+   * @param enabled whether the logger is enabled
+   * @return this builder
+   */
+  public LoggerConfigBuilder setEnabled(boolean enabled) {
+    this.enabled = enabled;
+    return this;
+  }
+
+  /**
+   * Sets the minimum severity level for log records to be processed.
+   *
+   * <p>Log records with a severity number less than this value will be dropped. Log records without
+   * a specified severity are not affected by this setting.
+   *
+   * @param minimumSeverity minimum severity level for log records to be processed
+   * @return this builder
+   */
+  public LoggerConfigBuilder setMinimumSeverity(Severity minimumSeverity) {
+    this.minimumSeverity = minimumSeverity;
+    return this;
+  }
+
+  /**
+   * Sets whether to only process log records from traces when the trace is sampled.
+   *
+   * <p>When enabled, log records from unsampled traces will be dropped. Log records that are not
+   * associated with a trace context are unaffected.
+   *
+   * @param traceBased whether to only process log records from traces when the trace is sampled
+   * @return this builder
+   */
+  public LoggerConfigBuilder setTraceBased(boolean traceBased) {
+    this.traceBased = traceBased;
+    return this;
+  }
+
+  /** Builds and returns a {@link LoggerConfig}. */
+  public LoggerConfig build() {
+    return LoggerConfig.create(enabled, minimumSeverity, traceBased);
+  }
+}

sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilderTest.java

@@ -11,6 +11,9 @@
 import static io.opentelemetry.api.common.AttributeKey.stringKey;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.assertThat;
 import static io.opentelemetry.sdk.testing.assertj.OpenTelemetryAssertions.equalTo;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import io.opentelemetry.api.common.AttributeKey;
@@ -24,6 +27,7 @@
 import io.opentelemetry.context.Context;
 import io.opentelemetry.sdk.common.Clock;
 import io.opentelemetry.sdk.common.InstrumentationScopeInfo;
+import io.opentelemetry.sdk.logs.internal.LoggerConfig;
 import io.opentelemetry.sdk.resources.Resource;
 import java.time.Instant;
 import java.util.concurrent.TimeUnit;
@@ -57,7 +61,8 @@ void setup() {
     when(loggerSharedState.getResource()).thenReturn(RESOURCE);
     when(loggerSharedState.getClock()).thenReturn(clock);
 
-    builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO);
+    SdkLogger logger = new SdkLogger(loggerSharedState, SCOPE_INFO, LoggerConfig.enabled());
+    builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO, logger);
   }
 
   @Test
@@ -121,6 +126,26 @@ void emit_NoFields() {
         .hasSeverity(Severity.UNDEFINED_SEVERITY_NUMBER);
   }
 
+  @Test
+  void emit_ChecksLoggerIsEnabled() {
+    SdkLogger logger = mock(SdkLogger.class);
+    builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO, logger);
+
+    Severity severity = Severity.WARN;
+    Context context = Context.current();
+
+    // Configure mock to return false (disabled)
+    when(logger.isEnabled(severity, context)).thenReturn(false);
+
+    builder.setSeverity(severity).setContext(context).emit();
+
+    // Verify isEnabled was called with correct parameters
+    verify(logger).isEnabled(eq(severity), eq(context));
+
+    // Verify log was not processed (because isEnabled returned false)
+    assertThat(emittedLog.get()).isNull();
+  }
+
   @Test
   void testConvenienceAttributeMethods() {
     builder