Remove unused timeout parameter from OTLP Shutdown methods

No implementation honored timeoutMilliseconds - all paths just dispose
the HttpClient. The real flush is bounded by the HTTP client timeout
during the preceding DisposeAsync/StopAsync, so Shutdown() does not
need to block. Drop the parameter and the now-unused _timeoutMs field
in MetricReader.

Author: bouwkast

tracer/src/Datadog.Trace/Logging/DirectSubmission/Sink/OtlpSubmissionLogSink.cs

@@ -76,8 +76,10 @@ protected override void DelayEvents(TimeSpan delayUntilNextFlush)
 
     public override async Task DisposeAsync()
     {
+        // Final flush is awaited by base.DisposeAsync() and bounded by the HTTP
+        // client timeout; Shutdown() just releases the HTTP client resources.
         await base.DisposeAsync().ConfigureAwait(false);
-        if (!_otlpExporter.Shutdown(timeoutMilliseconds: 5000))
+        if (!_otlpExporter.Shutdown())
         {
             _logger.Warning("OTLP exporter shutdown did not complete successfully.");
         }

tracer/src/Datadog.Trace/OpenTelemetry/Logs/IOtlpExporter.cs

@@ -26,10 +26,11 @@ internal interface IOtlpExporter
     Task<ExportResult> ExportAsync(IReadOnlyList<LogPoint> logs);
 
     /// <summary>
-    /// Shuts down the exporter and ensures all pending exports complete.
+    /// Releases the exporter's HTTP resources. Does not wait on pending exports:
+    /// the final flush runs synchronously in the sink's DisposeAsync before this is
+    /// called, bounded by the HTTP client timeout (OTEL_EXPORTER_OTLP_TIMEOUT).
     /// </summary>
-    /// <param name="timeoutMilliseconds">Maximum time to wait for shutdown</param>
     /// <returns>True if shutdown completed successfully</returns>
-    bool Shutdown(int timeoutMilliseconds);
+    bool Shutdown();
 }
 #endif

tracer/src/Datadog.Trace/OpenTelemetry/Logs/OtlpExporter.cs

@@ -129,11 +129,12 @@ public async Task<ExportResult> ExportAsync(IReadOnlyList<LogPoint> logs)
     }
 
     /// <summary>
-    /// Shuts down the exporter and ensures all pending exports complete.
+    /// Releases the exporter's HTTP resources. The final flush already ran
+    /// synchronously in the sink's DisposeAsync (bounded by the HTTP client
+    /// timeout, OTEL_EXPORTER_OTLP_TIMEOUT), so there is nothing further to wait on.
     /// </summary>
-    /// <param name="timeoutMilliseconds">Maximum time to wait for shutdown</param>
     /// <returns>True if shutdown completed successfully</returns>
-    public bool Shutdown(int timeoutMilliseconds)
+    public bool Shutdown()
     {
         try
         {

tracer/src/Datadog.Trace/OpenTelemetry/Metrics/InMemoryExporter.cs

@@ -46,7 +46,7 @@ public override Task<ExportResult> ExportAsync(IReadOnlyList<MetricPoint> metric
             return Task.FromResult(result);
         }
 
-        public override bool Shutdown(int timeoutMilliseconds)
+        public override bool Shutdown()
         {
             return true;
         }

tracer/src/Datadog.Trace/OpenTelemetry/Metrics/MetricExporter.cs

@@ -23,9 +23,11 @@ internal abstract class MetricExporter
         public abstract Task<ExportResult> ExportAsync(IReadOnlyList<MetricPoint> metrics);
 
         /// <summary>
-        /// Shuts down the exporter.
+        /// Releases exporter resources. The final flush is driven by the caller
+        /// (MetricReader.StopAsync) and bounded by the export path's own timeout;
+        /// this method is not expected to block.
         /// </summary>
-        public abstract bool Shutdown(int timeoutMilliseconds);
+        public abstract bool Shutdown();
     }
 }
 #endif

tracer/src/Datadog.Trace/OpenTelemetry/Metrics/MetricReader.cs

@@ -24,7 +24,6 @@ internal sealed class MetricReader
     {
         private static readonly IDatadogLogger Log = DatadogLogging.GetLoggerFor(typeof(MetricReader));
         private readonly int _exportIntervalMs;
-        private readonly int _timeoutMs;
         private readonly MetricReaderHandler _handler;
         private readonly MetricExporter _exporter;
         private MeterListener? _listener;
@@ -33,7 +32,6 @@ internal sealed class MetricReader
         public MetricReader(TracerSettings settings, MetricReaderHandler handler, MetricExporter exporter)
         {
             _exportIntervalMs = settings.OtelMetricExportIntervalMs;
-            _timeoutMs = settings.OtlpMetricsTimeoutMs;
             _handler = handler;
             _exporter = exporter;
         }
@@ -95,7 +93,7 @@ public async Task StopAsync()
             }
             finally
             {
-                _exporter.Shutdown(_timeoutMs);
+                _exporter.Shutdown();
                 _listener?.Dispose();
                 _listener = null;
                 Log.Debug("MetricReader stopped");

tracer/src/Datadog.Trace/OpenTelemetry/Metrics/OtlpExporter.cs

@@ -126,11 +126,13 @@ public override async Task<ExportResult> ExportAsync(IReadOnlyList<MetricPoint>
         }
 
         /// <summary>
-        /// Shuts down the exporter and ensures all pending exports complete.
+        /// Releases the exporter's HTTP resources. The final export already ran
+        /// synchronously in MetricReader.StopAsync and is bounded by the HTTP
+        /// request timeout (OTEL_EXPORTER_OTLP_METRICS_TIMEOUT), so there is
+        /// nothing further to wait on here.
         /// </summary>
-        /// <param name="timeoutMilliseconds">Maximum time to wait for shutdown</param>
         /// <returns>True if shutdown completed successfully, false otherwise</returns>
-        public override bool Shutdown(int timeoutMilliseconds)
+        public override bool Shutdown()
         {
             try
             {

tracer/test/Datadog.Trace.Tests/Logging/DirectSubmission/Sink/OtlpSinkTests.cs

@@ -263,7 +263,7 @@ public async Task<ExportResult> ExportAsync(IReadOnlyList<LogPoint> logs)
                 return await _exportFunc(logs).ConfigureAwait(false);
             }
 
-            public bool Shutdown(int timeoutMilliseconds)
+            public bool Shutdown()
             {
                 return true;
             }