Derive OTLP export flags in Config and honor MultiWriter

bm1549 · claude · bm1549 · commit 070e7d8359f1 · 2026-07-27T12:46:11.000-04:00
Move the three derived booleans out of StatusLogger.toJson and into Config
accessors: isOtlpTracesExportEnabled, isOtlpMetricsExportEnabled, and
isOtlpLogsExportEnabled. Every other field toJson emits forwards a Config
getter, so keeping the conjunctions inline made this method the only place in
the file that derives a value it writes.

Fix otlp_traces_export_enabled. It compared dd.writer.type to OtlpWriter for
equality, so MultiWriter:OtlpWriter,DDAgentWriter reported false even though
WriterFactory builds a real OtlpWriter for it. isOtlpTracesExportEnabled now
mirrors WriterFactory's dispatch: a writer type that does not start with
MultiWriter is compared to OtlpWriter directly, and one that does has every
literal MultiWriter: removed before the remainder is split on commas and each
sub-type compared. Removing every occurrence rather than a single leading
prefix matches what MultiWriter itself does, so a repeated prefix such as
MultiWriter:DDAgentWriter,MultiWriter:OtlpWriter resolves the same way in both
places.

Drop the two comment blocks in StatusLogger explaining writer precedence and
span-metrics routing, and the three in StatusLoggerTest. StatusLogger carries
no comments anywhere else, and the reasoning belongs in the commit message and
pull request, which both record it.

Expand StatusLoggerTest to 13 tests and assert with assertFalse and assertTrue
instead of assertEquals against boolean literals. The new cases pin the writer
type grammar: a MultiWriter list that includes OtlpWriter, one that excludes
it, a repeated MultiWriter prefix, a padded sub-type, a sub-type that only
prefixes OtlpWriter, a comma-separated list without the MultiWriter prefix, and
a TraceStructureWriter value that WriterFactory dispatches before it ever
reaches the MultiWriter branch.

Co-Authored-By: Claude Opus 5 &lt;noreply@anthropic.com&gt;
diff --git a/dd-trace-core/src/main/java/datadog/trace/core/StatusLogger.java b/dd-trace-core/src/main/java/datadog/trace/core/StatusLogger.java
@@ -2,7 +2,6 @@
 
 import static datadog.trace.api.Config.isDatadogProfilerEnablementOverridden;
 import static datadog.trace.api.Config.isDatadogProfilerSafeInCurrentEnvironment;
-import static datadog.trace.bootstrap.instrumentation.api.WriterConstants.OTLP_WRITER_TYPE;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 
 import com.squareup.moshi.JsonAdapter;
@@ -160,19 +159,11 @@ public void toJson(JsonWriter writer, Config config) throws IOException {
     writer.name("data_streams_transaction_extractors");
     writer.value(config.getDataStreamsTransactionExtractors());
     writer.name("otlp_traces_export_enabled");
-    // Report the effective trace writer, not just the exporter selection: an explicit
-    // dd.writer.type override wins over dd.trace.otel.exporter=otlp in WriterFactory, so traces are
-    // only exported over OTLP when the resolved writer is actually the OtlpWriter.
-    writer.value(OTLP_WRITER_TYPE.equals(config.getWriterType()));
+    writer.value(config.isOtlpTracesExportEnabled());
     writer.name("otlp_metrics_export_enabled");
-    // Client-side trace span-metrics are exported over OTLP whenever span metrics are enabled
-    // (MetricsAggregatorFactory routes them through OtlpStatsMetricWriter), independently of the
-    // OTel metrics signal, so OR that path in alongside OTel-API metrics export.
-    writer.value(
-        (config.isMetricsOtelEnabled() && config.isMetricsOtlpExporterEnabled())
-            || config.isOtelTracesSpanMetricsEnabled());
+    writer.value(config.isOtlpMetricsExportEnabled());
     writer.name("otlp_logs_export_enabled");
-    writer.value(config.isLogsOtelEnabled() && config.isLogsOtlpExporterEnabled());
+    writer.value(config.isOtlpLogsExportEnabled());
 
     writer.name("app_logs_collection_enabled");
     writer.value(config.isAppLogsCollectionEnabled());
diff --git a/dd-trace-core/src/test/java/datadog/trace/core/StatusLoggerTest.java b/dd-trace-core/src/test/java/datadog/trace/core/StatusLoggerTest.java
@@ -1,84 +1,141 @@
 package datadog.trace.core;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static datadog.trace.api.config.OtlpConfig.LOGS_OTEL_ENABLED;
+import static datadog.trace.api.config.OtlpConfig.LOGS_OTEL_EXPORTER;
+import static datadog.trace.api.config.OtlpConfig.METRICS_OTEL_ENABLED;
+import static datadog.trace.api.config.OtlpConfig.METRICS_OTEL_EXPORTER;
+import static datadog.trace.api.config.OtlpConfig.OTEL_TRACES_SPAN_METRICS_ENABLED;
+import static datadog.trace.api.config.OtlpConfig.TRACE_OTEL_EXPORTER;
+import static datadog.trace.api.config.TracerConfig.WRITER_TYPE;
+import static datadog.trace.bootstrap.instrumentation.api.WriterConstants.DD_AGENT_WRITER_TYPE;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.squareup.moshi.Moshi;
 import datadog.trace.api.Config;
-import datadog.trace.api.config.OtlpConfig;
-import datadog.trace.api.config.TracerConfig;
 import datadog.trace.test.junit.utils.config.WithConfig;
+import datadog.trace.test.util.DDJavaSpecification;
 import java.io.IOException;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 
 @Timeout(value = 10, unit = TimeUnit.SECONDS)
-public class StatusLoggerTest extends DDCoreJavaSpecification {
+public class StatusLoggerTest extends DDJavaSpecification {
 
   @Test
   void otlpExportDisabledByDefault() throws IOException {
-    Map<String, Object> startupLog = startupLog(Config.get());
+    Map<String, Object> startupLog = startupLog();
 
-    assertEquals(false, startupLog.get("otlp_traces_export_enabled"));
-    assertEquals(false, startupLog.get("otlp_metrics_export_enabled"));
-    assertEquals(false, startupLog.get("otlp_logs_export_enabled"));
+    assertFalse(flag(startupLog, "otlp_traces_export_enabled"));
+    assertFalse(flag(startupLog, "otlp_metrics_export_enabled"));
+    assertFalse(flag(startupLog, "otlp_logs_export_enabled"));
   }
 
   @Test
-  @WithConfig(key = OtlpConfig.TRACE_OTEL_EXPORTER, value = "otlp")
-  @WithConfig(key = OtlpConfig.METRICS_OTEL_ENABLED, value = "true")
-  @WithConfig(key = OtlpConfig.METRICS_OTEL_EXPORTER, value = "otlp")
-  @WithConfig(key = OtlpConfig.LOGS_OTEL_ENABLED, value = "true")
-  @WithConfig(key = OtlpConfig.LOGS_OTEL_EXPORTER, value = "otlp")
+  @WithConfig(key = TRACE_OTEL_EXPORTER, value = "otlp")
+  @WithConfig(key = METRICS_OTEL_ENABLED, value = "true")
+  @WithConfig(key = METRICS_OTEL_EXPORTER, value = "otlp")
+  @WithConfig(key = LOGS_OTEL_ENABLED, value = "true")
+  @WithConfig(key = LOGS_OTEL_EXPORTER, value = "otlp")
   void otlpExportEnabledWhenConfigured() throws IOException {
-    Map<String, Object> startupLog = startupLog(Config.get());
+    Map<String, Object> startupLog = startupLog();
 
-    assertEquals(true, startupLog.get("otlp_traces_export_enabled"));
-    assertEquals(true, startupLog.get("otlp_metrics_export_enabled"));
-    assertEquals(true, startupLog.get("otlp_logs_export_enabled"));
+    assertTrue(flag(startupLog, "otlp_traces_export_enabled"));
+    assertTrue(flag(startupLog, "otlp_metrics_export_enabled"));
+    assertTrue(flag(startupLog, "otlp_logs_export_enabled"));
   }
 
   @Test
-  @WithConfig(key = OtlpConfig.TRACE_OTEL_EXPORTER, value = "otlp")
-  @WithConfig(key = OtlpConfig.METRICS_OTEL_EXPORTER, value = "otlp")
-  @WithConfig(key = OtlpConfig.LOGS_OTEL_EXPORTER, value = "otlp")
+  @WithConfig(key = TRACE_OTEL_EXPORTER, value = "otlp")
+  @WithConfig(key = METRICS_OTEL_EXPORTER, value = "otlp")
+  @WithConfig(key = LOGS_OTEL_EXPORTER, value = "otlp")
   void metricsAndLogsRequireOtelSignalEnabled() throws IOException {
-    // The OTLP exporter is selected for every signal, but the metrics and logs OTel signals are
-    // left disabled, so only trace export should be reported as enabled.
-    Map<String, Object> startupLog = startupLog(Config.get());
+    Map<String, Object> startupLog = startupLog();
 
-    assertEquals(true, startupLog.get("otlp_traces_export_enabled"));
-    assertEquals(false, startupLog.get("otlp_metrics_export_enabled"));
-    assertEquals(false, startupLog.get("otlp_logs_export_enabled"));
+    assertTrue(flag(startupLog, "otlp_traces_export_enabled"));
+    assertFalse(flag(startupLog, "otlp_metrics_export_enabled"));
+    assertFalse(flag(startupLog, "otlp_logs_export_enabled"));
   }
 
   @Test
-  @WithConfig(key = OtlpConfig.TRACE_OTEL_EXPORTER, value = "otlp")
-  @WithConfig(key = TracerConfig.WRITER_TYPE, value = "DDAgentWriter")
+  @WithConfig(key = TRACE_OTEL_EXPORTER, value = "otlp")
+  @WithConfig(key = WRITER_TYPE, value = DD_AGENT_WRITER_TYPE)
   void tracesNotExportedWhenWriterTypeOverridesOtlpExporter() throws IOException {
-    // The OTLP trace exporter is selected, but an explicit dd.writer.type override wins in
-    // WriterFactory, so the effective writer is the DDAgentWriter and traces are not exported over
-    // OTLP.
-    Map<String, Object> startupLog = startupLog(Config.get());
+    assertFalse(flag(startupLog(), "otlp_traces_export_enabled"));
+  }
+
+  @Test
+  @WithConfig(key = WRITER_TYPE, value = "MultiWriter:OtlpWriter,DDAgentWriter")
+  void tracesExportedWhenMultiWriterIncludesOtlpWriter() throws IOException {
+    assertTrue(flag(startupLog(), "otlp_traces_export_enabled"));
+  }
+
+  @Test
+  @WithConfig(key = WRITER_TYPE, value = "MultiWriter:DDAgentWriter,MultiWriter:OtlpWriter")
+  void tracesExportedWhenMultiWriterPrefixRepeats() throws IOException {
+    assertTrue(flag(startupLog(), "otlp_traces_export_enabled"));
+  }
+
+  @Test
+  @WithConfig(key = WRITER_TYPE, value = "MultiWriter:LoggingWriter,DDAgentWriter")
+  void tracesNotExportedWhenMultiWriterExcludesOtlpWriter() throws IOException {
+    assertFalse(flag(startupLog(), "otlp_traces_export_enabled"));
+  }
+
+  @Test
+  @WithConfig(key = WRITER_TYPE, value = "MultiWriter: OtlpWriter")
+  void tracesNotExportedWhenMultiWriterSubTypeIsPadded() throws IOException {
+    assertFalse(flag(startupLog(), "otlp_traces_export_enabled"));
+  }
+
+  @Test
+  @WithConfig(key = WRITER_TYPE, value = "MultiWriter:OtlpWriterExtra")
+  void tracesNotExportedWhenMultiWriterSubTypeOnlyPrefixesOtlpWriter() throws IOException {
+    assertFalse(flag(startupLog(), "otlp_traces_export_enabled"));
+  }
+
+  @Test
+  @WithConfig(key = WRITER_TYPE, value = "DDAgentWriter,OtlpWriter")
+  void tracesNotExportedWhenCommaSeparatedWithoutMultiWriterPrefix() throws IOException {
+    assertFalse(flag(startupLog(), "otlp_traces_export_enabled"));
+  }
 
-    assertEquals(false, startupLog.get("otlp_traces_export_enabled"));
+  @Test
+  @WithConfig(key = WRITER_TYPE, value = "TraceStructureWriter:/tmp/out,OtlpWriter")
+  void tracesNotExportedWhenTraceStructureWriterTakesPrecedence() throws IOException {
+    assertFalse(flag(startupLog(), "otlp_traces_export_enabled"));
   }
 
   @Test
-  @WithConfig(key = OtlpConfig.OTEL_TRACES_SPAN_METRICS_ENABLED, value = "true")
+  @WithConfig(key = OTEL_TRACES_SPAN_METRICS_ENABLED, value = "true")
   void metricsExportedWhenSpanMetricsEnabled() throws IOException {
-    // Span metrics are exported over OTLP via OtlpStatsMetricWriter whenever span metrics are
-    // enabled, independently of the OTel metrics signal, so metrics export should be reported.
-    Map<String, Object> startupLog = startupLog(Config.get());
+    assertTrue(flag(startupLog(), "otlp_metrics_export_enabled"));
+  }
 
-    assertEquals(true, startupLog.get("otlp_metrics_export_enabled"));
+  @Test
+  @WithConfig(key = METRICS_OTEL_ENABLED, value = "true")
+  @WithConfig(key = METRICS_OTEL_EXPORTER, value = "otlp")
+  @WithConfig(key = OTEL_TRACES_SPAN_METRICS_ENABLED, value = "false")
+  void metricsExportedWhenOtelMetricsSignalEnabledWithoutSpanMetrics() throws IOException {
+    assertTrue(flag(startupLog(), "otlp_metrics_export_enabled"));
   }
 
   @SuppressWarnings("unchecked")
-  private static Map<String, Object> startupLog(Config config) throws IOException {
+  private static Map<String, Object> startupLog() throws IOException {
     String json =
-        new Moshi.Builder().add(new StatusLogger()).build().adapter(Config.class).toJson(config);
+        new Moshi.Builder()
+            .add(new StatusLogger())
+            .build()
+            .adapter(Config.class)
+            .toJson(Config.get());
     return (Map<String, Object>) new Moshi.Builder().build().adapter(Object.class).fromJson(json);
   }
+
+  private static boolean flag(Map<String, Object> startupLog, String name) {
+    Object value = startupLog.get(name);
+    assertTrue(value instanceof Boolean, name + " should be a boolean, was " + value);
+    return (Boolean) value;
+  }
 }
diff --git a/internal-api/src/main/java/datadog/trace/api/Config.java b/internal-api/src/main/java/datadog/trace/api/Config.java
@@ -727,6 +727,7 @@
 import static datadog.trace.api.config.TracerConfig.WRITER_LINKS_INJECT;
 import static datadog.trace.api.config.TracerConfig.WRITER_TYPE;
 import static datadog.trace.api.telemetry.LogCollector.SEND_TELEMETRY;
+import static datadog.trace.bootstrap.instrumentation.api.WriterConstants.MULTI_WRITER_TYPE;
 import static datadog.trace.bootstrap.instrumentation.api.WriterConstants.OTLP_WRITER_TYPE;
 import static datadog.trace.util.CollectionUtils.tryMakeImmutableList;
 import static datadog.trace.util.CollectionUtils.tryMakeImmutableSet;
@@ -828,6 +829,9 @@ public class Config {
   private static final int MAX_CODE_COVERAGE_FLAGS = 32;
 
   private static final Pattern COLON = Pattern.compile(":");
+  private static final Pattern COMMA = Pattern.compile(",");
+  private static final Pattern MULTI_WRITER_PREFIX =
+      Pattern.compile(MULTI_WRITER_TYPE + ":", Pattern.LITERAL);
 
   // Historical conflating-Batch size; used to translate TRACER_METRICS_MAX_PENDING (configured in
   // legacy batch units) into the new per-SpanSnapshot inbox capacity.
@@ -5577,6 +5581,10 @@ public boolean isLogsOtlpExporterEnabled() {
     return "otlp".equalsIgnoreCase(logsOtelExporter);
   }
 
+  public boolean isOtlpLogsExportEnabled() {
+    return isLogsOtelEnabled() && isLogsOtlpExporterEnabled();
+  }
+
   public int getLogsOtelInterval() {
     return logsOtelInterval;
   }
@@ -5621,6 +5629,11 @@ public boolean isMetricsOtlpExporterEnabled() {
     return "otlp".equalsIgnoreCase(metricsOtelExporter);
   }
 
+  public boolean isOtlpMetricsExportEnabled() {
+    return (isMetricsOtelEnabled() && isMetricsOtlpExporterEnabled())
+        || isOtelTracesSpanMetricsEnabled();
+  }
+
   public boolean isMetricsOtelExperimentalEnabled() {
     return metricsOtelExperimentalEnabled;
   }
@@ -5677,6 +5690,19 @@ public boolean isTraceOtlpExporterEnabled() {
     return "otlp".equalsIgnoreCase(traceOtelExporter);
   }
 
+  public boolean isOtlpTracesExportEnabled() {
+    if (!writerType.startsWith(MULTI_WRITER_TYPE)) {
+      return OTLP_WRITER_TYPE.equals(writerType);
+    }
+    String multiWriterConfig = MULTI_WRITER_PREFIX.matcher(writerType).replaceAll("");
+    for (String subWriterType : COMMA.split(multiWriterConfig)) {
+      if (OTLP_WRITER_TYPE.equals(subWriterType)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   public String getOtlpTracesEndpoint() {
     return otlpTracesEndpoint;
   }
