Use NoopLogEmitterBuilder when no log processors are registered (#4672)

Author: jack-berg

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

@@ -8,7 +8,6 @@
 import io.opentelemetry.sdk.common.Clock;
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import io.opentelemetry.sdk.resources.Resource;
-import java.util.List;
 import java.util.function.Supplier;
 import javax.annotation.Nullable;
 
@@ -27,11 +26,11 @@ final class LogEmitterSharedState {
   LogEmitterSharedState(
       Resource resource,
       Supplier<LogLimits> logLimitsSupplier,
-      List<LogProcessor> logProcessors,
+      LogProcessor logProcessor,
       Clock clock) {
     this.resource = resource;
     this.logLimitsSupplier = logLimitsSupplier;
-    this.logProcessor = LogProcessor.composite(logProcessors);
+    this.logProcessor = logProcessor;
     this.clock = clock;
   }
 

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

@@ -0,0 +1,94 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.sdk.logs.data.Severity;
+import java.time.Instant;
+import java.util.concurrent.TimeUnit;
+
+class NoopLogEmitterBuilder implements LogEmitterBuilder {
+
+  private static final NoopLogEmitterBuilder INSTANCE = new NoopLogEmitterBuilder();
+  private static final NoopLogEmitter NOOP_LOG_EMITTER = new NoopLogEmitter();
+
+  private NoopLogEmitterBuilder() {}
+
+  static LogEmitterBuilder getInstance() {
+    return INSTANCE;
+  }
+
+  @Override
+  public LogEmitterBuilder setSchemaUrl(String schemaUrl) {
+    return this;
+  }
+
+  @Override
+  public LogEmitterBuilder setInstrumentationVersion(String instrumentationScopeVersion) {
+    return this;
+  }
+
+  @Override
+  public LogEmitter build() {
+    return NOOP_LOG_EMITTER;
+  }
+
+  private static class NoopLogEmitter implements LogEmitter {
+
+    private static final NoopLogBuilder NOOP_LOG_BUILDER = new NoopLogBuilder();
+
+    private NoopLogEmitter() {}
+
+    @Override
+    public LogRecordBuilder logRecordBuilder() {
+      return NOOP_LOG_BUILDER;
+    }
+  }
+
+  private static class NoopLogBuilder implements LogRecordBuilder {
+
+    private NoopLogBuilder() {}
+
+    @Override
+    public LogRecordBuilder setEpoch(long timestamp, TimeUnit unit) {
+      return this;
+    }
+
+    @Override
+    public LogRecordBuilder setEpoch(Instant instant) {
+      return this;
+    }
+
+    @Override
+    public LogRecordBuilder setContext(Context context) {
+      return this;
+    }
+
+    @Override
+    public LogRecordBuilder setSeverity(Severity severity) {
+      return this;
+    }
+
+    @Override
+    public LogRecordBuilder setSeverityText(String severityText) {
+      return this;
+    }
+
+    @Override
+    public LogRecordBuilder setBody(String body) {
+      return this;
+    }
+
+    @Override
+    public <T> LogRecordBuilder setAttribute(AttributeKey<T> key, T value) {
+      return this;
+    }
+
+    @Override
+    public void emit() {}
+  }
+}

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

@@ -24,6 +24,7 @@ public final class SdkLogEmitterProvider implements Closeable {
 
   private final LogEmitterSharedState sharedState;
   private final ComponentRegistry<SdkLogEmitter> logEmitterComponentRegistry;
+  private final boolean isNoopLogProcessor;
 
   /**
    * Returns a new {@link SdkLogEmitterProviderBuilder} for {@link SdkLogEmitterProvider}.
@@ -39,10 +40,12 @@ public static SdkLogEmitterProviderBuilder builder() {
       Supplier<LogLimits> logLimitsSupplier,
       List<LogProcessor> processors,
       Clock clock) {
-    this.sharedState = new LogEmitterSharedState(resource, logLimitsSupplier, processors, clock);
+    LogProcessor logProcessor = LogProcessor.composite(processors);
+    this.sharedState = new LogEmitterSharedState(resource, logLimitsSupplier, logProcessor, clock);
     this.logEmitterComponentRegistry =
         new ComponentRegistry<>(
             instrumentationScopeInfo -> new SdkLogEmitter(sharedState, instrumentationScopeInfo));
+    this.isNoopLogProcessor = logProcessor instanceof NoopLogProcessor;
   }
 
   /**
@@ -63,6 +66,9 @@ public LogEmitter get(String instrumentationScopeName) {
    * @return a log emitter builder instance
    */
   public LogEmitterBuilder logEmitterBuilder(String instrumentationScopeName) {
+    if (isNoopLogProcessor) {
+      return NoopLogEmitterBuilder.getInstance();
+    }
     if (instrumentationScopeName == null || instrumentationScopeName.isEmpty()) {
       LOGGER.fine("LogEmitter requested without instrumentation scope name.");
       instrumentationScopeName = DEFAULT_EMITTER_NAME;

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

@@ -13,8 +13,6 @@
 import io.opentelemetry.sdk.common.Clock;
 import io.opentelemetry.sdk.common.CompletableResultCode;
 import io.opentelemetry.sdk.resources.Resource;
-import java.util.Collections;
-import java.util.List;
 import org.junit.jupiter.api.Test;
 
 class LogEmitterSharedStateTest {
@@ -24,10 +22,9 @@ void shutdown() {
     LogProcessor logProcessor = mock(LogProcessor.class);
     CompletableResultCode code = new CompletableResultCode();
     when(logProcessor.shutdown()).thenReturn(code);
-    List<LogProcessor> processors = Collections.singletonList(logProcessor);
     LogEmitterSharedState state =
         new LogEmitterSharedState(
-            Resource.empty(), LogLimits::getDefault, processors, Clock.getDefault());
+            Resource.empty(), LogLimits::getDefault, logProcessor, Clock.getDefault());
     state.shutdown();
     state.shutdown();
     verify(logProcessor, times(1)).shutdown();

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

@@ -0,0 +1,34 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package io.opentelemetry.sdk.logs;
+
+import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.sdk.logs.data.Severity;
+import java.time.Instant;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Test;
+
+class NoopLogEmitterBuilderTest {
+
+  @Test
+  void buildAndEmit() {
+    NoopLogEmitterBuilder.getInstance()
+        .setSchemaUrl("http://endpoint")
+        .setInstrumentationVersion("1.0.0")
+        .build()
+        .logRecordBuilder()
+        .setAttribute(AttributeKey.stringKey("key"), "value")
+        .setEpoch(Instant.now())
+        .setEpoch(100, TimeUnit.SECONDS)
+        .setSeverity(Severity.DEBUG)
+        .setSeverityText("debug")
+        .setContext(Context.root())
+        .setBody("body")
+        .emit();
+    ;
+  }
+}

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

@@ -212,6 +212,12 @@ void logEmitterBuilder_DefaultEmitterName() {
         .isEqualTo(SdkLogEmitterProvider.DEFAULT_EMITTER_NAME);
   }
 
+  @Test
+  void logEmitterBuilder_NoProcessor_UsesNoop() {
+    assertThat(SdkLogEmitterProvider.builder().build().logEmitterBuilder("test"))
+        .isInstanceOf(NoopLogEmitterBuilder.class);
+  }
+
   @Test
   void logEmitterBuilder_WithLogProcessor() {
     Resource resource = Resource.builder().put("r1", "v1").build();