Flush the DDIntakeWriter track instead of adding a second LLM Obs writer

The DDAgentWriter branch's dedicated LLM Obs DDIntakeWriter duplicated the
LLM Obs track that the DD_INTAKE_WRITER_TYPE branch already builds whenever
llmObsEnabled is true (Agent.java defaults to
MultiWriter:DDIntakeWriter,DDAgentWriter for that case), so every span was
sent twice. Verified live on Lambda: the pre-fix build sent LLMOBS/v2
payloads twice per invocation.

The original bug this branch was fixing -- spans silently dropped in
Lambda -- was actually caused by the DDIntakeWriter branch never setting
alwaysFlush, so the periodic flush timer rarely beat the execution
environment freezing after the handler returns. Verified live: without
alwaysFlush, 0/8 invocations delivered a span; with it, 8/8 did, one send
each.

Author: purple4reina

dd-trace-core/src/main/java/datadog/trace/common/writer/WriterFactory.java

@@ -134,19 +134,27 @@ public static Writer createWriter(
       }
     }
 
-    Writer remoteWriter;
+    RemoteWriter remoteWriter;
     if (DD_INTAKE_WRITER_TYPE.equals(configuredType)) {
       final TrackType trackType = DDIntakeTrackTypeResolver.resolve(config);
       final RemoteApi remoteApi =
           createDDIntakeRemoteApi(config, commObjects, featuresDiscovery, trackType);
 
+      // In a serverless environment the execution environment can freeze as soon as the handler
+      // returns, before this writer's periodic flush timer next fires -- flush synchronously so
+      // buffered events (e.g. LLM Observability spans) aren't lost when that happens.
+      boolean alwaysFlush =
+          config.isAgentConfiguredUsingDefault()
+              && ServerlessInfo.get().isRunningInServerlessEnvironment();
+
       DDIntakeWriter.DDIntakeWriterBuilder builder =
           DDIntakeWriter.builder()
               .addTrack(trackType, remoteApi)
               .prioritization(prioritization)
               .healthMetrics(healthMetrics)
               .monitoring(commObjects.monitoring)
               .singleSpanSampler(singleSpanSampler)
+              .alwaysFlush(alwaysFlush)
               .flushIntervalMilliseconds(flushIntervalMilliseconds);
 
       if (config.isCiVisibilityEnabled()) {
@@ -215,25 +223,6 @@ public static Writer createWriter(
       }
 
       remoteWriter = builder.build();
-
-      // DDAgentWriter only speaks the regular trace protocol, so LLM Observability spans
-      // (tagged with DDSpanTypes.LLMOBS) need their own track sent via the EVP proxy -- without
-      // this, they're silently dropped by the agent/extension instead of reaching LLM Obs
-      // intake. Flush this track synchronously too when the primary writer is (i.e. in a
-      // serverless environment), so spans aren't lost when the execution environment freezes.
-      if (config.isLlmObsEnabled()) {
-        final RemoteApi llmObsApi =
-            createDDIntakeRemoteApi(config, commObjects, featuresDiscovery, TrackType.LLMOBS);
-        final DDIntakeWriter llmObsWriter =
-            DDIntakeWriter.builder()
-                .addTrack(TrackType.LLMOBS, llmObsApi)
-                .healthMetrics(healthMetrics)
-                .monitoring(commObjects.monitoring)
-                .alwaysFlush(alwaysFlush)
-                .flushIntervalMilliseconds(flushIntervalMilliseconds)
-                .build();
-        remoteWriter = new MultiWriter(new Writer[] {remoteWriter, llmObsWriter});
-      }
     }
 
     return remoteWriter;