Add minimum severity and trace-based logger configuration

trask · trask · commit d8f0544be239 · 2025-10-22T09:55:42.000-07:00
diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/ExtendedSdkLogRecordBuilder.java b/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
@@ -132,7 +134,13 @@ public void emit() {
     if (loggerSharedState.hasBeenShutdown()) {
       return;
     }
+
     Context context = this.context == null ? Context.current() : this.context;
+    Span span = Span.fromContext(context);
+    if (shouldDropLog(span)) {
+      return;
+    }
+
     long observedTimestampEpochNanos =
         this.observedTimestampEpochNanos == 0
             ? this.loggerSharedState.getClock().now()
@@ -148,7 +156,7 @@ public void emit() {
                 eventName,
                 timestampEpochNanos,
                 observedTimestampEpochNanos,
-                Span.fromContext(context).getSpanContext(),
+                span.getSpanContext(),
                 severity,
                 severityText,
                 body,
diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/IncubatingUtil.java b/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);
   }
 }
diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilder.java b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilder.java
@@ -10,6 +10,7 @@
 import io.opentelemetry.api.logs.LogRecordBuilder;
 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.internal.AttributesMap;
@@ -22,6 +23,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 +36,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,6 +126,11 @@ public void emit() {
       return;
     }
     Context context = this.context == null ? Context.current() : this.context;
+    Span span = Span.fromContext(context);
+    if (shouldDropLog(span)) {
+      return;
+    }
+    SpanContext spanContext = span.getSpanContext();
     long observedTimestampEpochNanos =
         this.observedTimestampEpochNanos == 0
             ? this.loggerSharedState.getClock().now()
@@ -135,11 +145,27 @@ public void emit() {
                 instrumentationScopeInfo,
                 timestampEpochNanos,
                 observedTimestampEpochNanos,
-                Span.fromContext(context).getSpanContext(),
+                spanContext,
                 severity,
                 severityText,
                 body,
                 attributes,
                 eventName));
   }
+
+  protected boolean shouldDropLog(Span span) {
+    if (severity != Severity.UNDEFINED_SEVERITY_NUMBER
+        && severity.getSeverityNumber() < logger.minimumSeverity) {
+      return true;
+    }
+
+    if (logger.traceBased) {
+      SpanContext spanContext = span.getSpanContext();
+      if (spanContext.isValid() && !spanContext.getTraceFlags().isSampled()) {
+        return true;
+      }
+    }
+
+    return false;
+  }
 }
diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/SdkLogger.java b/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 int 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) {
+      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();
   }
 }
diff --git a/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/internal/LoggerConfig.java b/sdk/logs/src/main/java/io/opentelemetry/sdk/logs/internal/LoggerConfig.java
@@ -30,9 +30,11 @@
 public abstract class LoggerConfig {
 
   private static final LoggerConfig DEFAULT_CONFIG =
-      new AutoValue_LoggerConfig(/* enabled= */ true);
+      new AutoValue_LoggerConfig(
+          /* enabled= */ true, /* minimumSeverity= */ 0, /* traceBased= */ false);
   private static final LoggerConfig DISABLED_CONFIG =
-      new AutoValue_LoggerConfig(/* enabled= */ false);
+      new AutoValue_LoggerConfig(
+          /* enabled= */ false, /* minimumSeverity= */ 0, /* traceBased= */ false);
 
   /** Returns a disabled {@link LoggerConfig}. */
   public static LoggerConfig disabled() {
@@ -44,6 +46,11 @@ public static LoggerConfig enabled() {
     return DEFAULT_CONFIG;
   }
 
+  /** Returns a new {@link Builder} for creating a {@link LoggerConfig}. */
+  public static Builder builder() {
+    return new Builder();
+  }
+
   /**
    * 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 +69,85 @@ public static ScopeConfiguratorBuilder<LoggerConfig> configuratorBuilder() {
 
   LoggerConfig() {}
 
+  /**
+   * 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 static final class Builder {
+    private boolean enabled = true;
+    private int minimumSeverity = 0;
+    private boolean traceBased = false;
+
+    private Builder() {}
+
+    /**
+     * Sets whether the logger is enabled.
+     *
+     * @param enabled whether the logger is enabled
+     * @return this builder
+     */
+    public Builder 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 Builder setMinimumSeverity(int 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 Builder setTraceBased(boolean traceBased) {
+      this.traceBased = traceBased;
+      return this;
+    }
+
+    /** Builds and returns a {@link LoggerConfig}. */
+    public LoggerConfig build() {
+      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 {@code 0}.
+   */
+  public abstract int 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();
 }
diff --git a/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilderTest.java b/sdk/logs/src/test/java/io/opentelemetry/sdk/logs/SdkLogRecordBuilderTest.java
@@ -24,6 +24,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 +58,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 +123,53 @@ void emit_NoFields() {
         .hasSeverity(Severity.UNDEFINED_SEVERITY_NUMBER);
   }
 
+  @Test
+  void emit_WithMinimumSeverityConfiguration() {
+    LoggerConfig config =
+        LoggerConfig.builder().setMinimumSeverity(Severity.INFO.getSeverityNumber()).build();
+    SdkLogger logger = new SdkLogger(loggerSharedState, SCOPE_INFO, config);
+    builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO, logger);
+
+    builder.setBody("too-low").setSeverity(Severity.DEBUG).emit();
+    assertThat(emittedLog.get()).isNull();
+
+    builder.setBody("allowed").setSeverity(Severity.INFO).emit();
+    assertThat(emittedLog.get().toLogRecordData()).hasBody("allowed");
+  }
+
+  @Test
+  void emit_WithTraceBasedConfiguration() {
+    LoggerConfig config = LoggerConfig.builder().setTraceBased(true).build();
+    SdkLogger logger = new SdkLogger(loggerSharedState, SCOPE_INFO, config);
+    builder = new SdkLogRecordBuilder(loggerSharedState, SCOPE_INFO, logger);
+
+    SpanContext unsampledSpanContext =
+        SpanContext.create(
+            "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            "bbbbbbbbbbbbbbbb",
+            TraceFlags.getDefault(),
+            TraceState.getDefault());
+    builder
+        .setBody("unsampled")
+        .setContext(Span.wrap(unsampledSpanContext).storeInContext(Context.root()))
+        .emit();
+    assertThat(emittedLog.get()).isNull();
+
+    SpanContext sampledSpanContext =
+        SpanContext.create(
+            "cccccccccccccccccccccccccccccccc",
+            "dddddddddddddddd",
+            TraceFlags.getSampled(),
+            TraceState.getDefault());
+    builder
+        .setBody("sampled")
+        .setContext(Span.wrap(sampledSpanContext).storeInContext(Context.root()))
+        .emit();
+    assertThat(emittedLog.get().toLogRecordData())
+        .hasSpanContext(sampledSpanContext)
+        .hasBody("sampled");
+  }
+
   @Test
   void testConvenienceAttributeMethods() {
     builder

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,9 @@ static SdkLogger createExtendedLogger(`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`static SdkLogRecordBuilder createExtendedLogRecordBuilder(`
`28`		`- LoggerSharedState loggerSharedState, InstrumentationScopeInfo instrumentationScopeInfo) {`
`29`		`- return new ExtendedSdkLogRecordBuilder(loggerSharedState, instrumentationScopeInfo);`
	`28`	`+ LoggerSharedState loggerSharedState,`
	`29`	`+ InstrumentationScopeInfo instrumentationScopeInfo,`
	`30`	`+ SdkLogger logger) {`
	`31`	`+ return new ExtendedSdkLogRecordBuilder(loggerSharedState, instrumentationScopeInfo, logger);`
`30`	`32`	`}`
`31`	`33`	`}`