Safeguard parameters in BatchSpanProcessor init (#810)

krayc425 · bryce-b · web-flow · commit 40127687b886 · 2025-06-17T21:43:52.000Z
* Safeguard parameters in BatchSpanProcessor init

* add unit tests

* apply changes to BatchLogRecordProcessor

* Update BatchLogRecordProcessor.swift

* fix a typo

---------

Co-authored-by: Bryce Buchanan &lt;75274611+bryce-b@users.noreply.github.com&gt;
diff --git a/Sources/OpenTelemetrySdk/Logs/Processors/BatchLogRecordProcessor.swift b/Sources/OpenTelemetrySdk/Logs/Processors/BatchLogRecordProcessor.swift
@@ -9,8 +9,48 @@ import OpenTelemetryApi
 public class BatchLogRecordProcessor: LogRecordProcessor {
   fileprivate var worker: BatchWorker
 
-  public init(logRecordExporter: LogRecordExporter, scheduleDelay: TimeInterval = 5, exportTimeout: TimeInterval = 30, maxQueueSize: Int = 2048, maxExportBatchSize: Int = 512, willExportCallback: ((inout [ReadableLogRecord]) -> Void)? = nil) {
-    worker = BatchWorker(logRecordExporter: logRecordExporter, scheduleDelay: scheduleDelay, exportTimeout: exportTimeout, maxQueueSize: maxQueueSize, maxExportBatchSize: maxExportBatchSize, willExportCallback: willExportCallback)
+  let safeScheduleDelay: TimeInterval
+  let safeExportTimeout: TimeInterval
+  let safeMaxQueueSize: Int
+  let safeMaxExportBatchSize: Int
+
+  public init(logRecordExporter: LogRecordExporter,
+              scheduleDelay: TimeInterval = 5,
+              exportTimeout: TimeInterval = 30,
+              maxQueueSize: Int = 2048,
+              maxExportBatchSize: Int = 512,
+              willExportCallback: ((inout [ReadableLogRecord]) -> Void)? = nil) {
+    if scheduleDelay >= 0 {
+      safeScheduleDelay = scheduleDelay
+    } else {
+      print("scheduleDelay (\(scheduleDelay)) < 0, fallback to default 5.")
+      safeScheduleDelay = 5
+    }
+    if exportTimeout >= 0 {
+      safeExportTimeout = exportTimeout
+    } else {
+      print("exportTimeout (\(exportTimeout)) < 0, fallback to default 30.")
+      safeExportTimeout = 30
+    }
+    if maxQueueSize > 0 {
+      safeMaxQueueSize = maxQueueSize
+    } else {
+      print("maxQueueSize (\(maxQueueSize)) <= 0, fallback to default 2048.")
+      safeMaxQueueSize = 2048
+    }
+    if maxExportBatchSize > 0 {
+      safeMaxExportBatchSize = maxExportBatchSize
+    } else {
+      print("maxExportBatchSize (\(maxExportBatchSize)) <= 0, fallback to default 512.")
+      safeMaxExportBatchSize = 512
+    }
+
+    worker = BatchWorker(logRecordExporter: logRecordExporter,
+                         scheduleDelay: safeScheduleDelay,
+                         exportTimeout: safeExportTimeout,
+                         maxQueueSize: safeMaxQueueSize,
+                         maxExportBatchSize: safeMaxExportBatchSize,
+                         willExportCallback: willExportCallback)
 
     worker.start()
   }
diff --git a/Sources/OpenTelemetrySdk/Trace/SpanProcessors/BatchSpanProcessor.swift b/Sources/OpenTelemetrySdk/Trace/SpanProcessors/BatchSpanProcessor.swift
@@ -25,19 +25,49 @@ public struct BatchSpanProcessor: SpanProcessor {
     String(describing: Self.self)
   }
 
+  let safeScheduleDelay: TimeInterval
+  let safeExportTimeout: TimeInterval
+  let safeMaxQueueSize: Int
+  let safeMaxExportBatchSize: Int
+
   public init(spanExporter: SpanExporter,
               meterProvider: (any StableMeterProvider)? = nil,
               scheduleDelay: TimeInterval = 5,
               exportTimeout: TimeInterval = 30,
               maxQueueSize: Int = 2048,
               maxExportBatchSize: Int = 512,
               willExportCallback: ((inout [SpanData]) -> Void)? = nil) {
+    if scheduleDelay >= 0 {
+      safeScheduleDelay = scheduleDelay
+    } else {
+      print("scheduleDelay (\(scheduleDelay)) < 0, fallback to default 5.")
+      safeScheduleDelay = 5
+    }
+    if exportTimeout >= 0 {
+      safeExportTimeout = exportTimeout
+    } else {
+      print("exportTimeout (\(exportTimeout)) < 0, fallback to default 30.")
+      safeExportTimeout = 30
+    }
+    if maxQueueSize > 0 {
+      safeMaxQueueSize = maxQueueSize
+    } else {
+      print("maxQueueSize (\(maxQueueSize)) <= 0, fallback to default 2048.")
+      safeMaxQueueSize = 2048
+    }
+    if maxExportBatchSize > 0 {
+      safeMaxExportBatchSize = maxExportBatchSize
+    } else {
+      print("maxExportBatchSize (\(maxExportBatchSize)) <= 0, fallback to default 512.")
+      safeMaxExportBatchSize = 512
+    }
+
     worker = BatchWorker(spanExporter: spanExporter,
                          meterProvider: meterProvider,
-                         scheduleDelay: scheduleDelay,
-                         exportTimeout: exportTimeout,
-                         maxQueueSize: maxQueueSize,
-                         maxExportBatchSize: maxExportBatchSize,
+                         scheduleDelay: safeScheduleDelay,
+                         exportTimeout: safeExportTimeout,
+                         maxQueueSize: safeMaxQueueSize,
+                         maxExportBatchSize: safeMaxExportBatchSize,
                          willExportCallback: willExportCallback)
     worker.start()
   }
diff --git a/Tests/ExportersTests/OpenTelemetryProtocol/SpanAdapterTests.swift b/Tests/ExportersTests/OpenTelemetryProtocol/SpanAdapterTests.swift
@@ -23,7 +23,7 @@ class SpanAdapterTests: XCTestCase {
     spanContext = SpanContext.create(traceId: traceId, spanId: spanId, traceFlags: TraceFlags(), traceState: tracestate)
   }
 
-  func testToPRotoResourceSpans() {
+  func testToProtoResourceSpans() {
     let libInfo = InstrumentationScopeInfo(name: "testScope", version: "semver:0.0.1")
 
     let event = RecordEventsReadableSpan.startSpan(context: spanContext, name: "GET /api/endpoint", instrumentationScopeInfo: libInfo, kind: SpanKind.server, parentContext: nil, hasRemoteParent: false, spanLimits: SpanLimits(), spanProcessor: NoopSpanProcessor(), clock: MillisClock(), resource: Resource(), attributes: AttributesDictionary(capacity: 0), links: [], totalRecordedLinks: 0, startTime: Date())
diff --git a/Tests/OpenTelemetrySdkTests/Logs/BatchLogRecordProcessorTests.swift b/Tests/OpenTelemetrySdkTests/Logs/BatchLogRecordProcessorTests.swift
@@ -121,6 +121,43 @@ class BatchLogRecordProcessorTests: XCTestCase {
     // Interestingly, this will always succeed on macOS even if you intentionally create a strong reference cycle between the BatchWorker and the Thread's closure. I assume either calling cancel or the thread exiting releases the closure which breaks the cycle. This is not the case on Linux where the test will fail as expected.
     XCTAssertNil(exporter)
   }
+
+  func testInitializeWithDefaultParameters() {
+    let processor = BatchLogRecordProcessor(logRecordExporter: WaitingLogRecordExporter(numberToWaitFor: 0))
+    XCTAssertEqual(processor.safeScheduleDelay, 5)
+    XCTAssertEqual(processor.safeExportTimeout, 30)
+    XCTAssertEqual(processor.safeMaxQueueSize, 2048)
+    XCTAssertEqual(processor.safeMaxExportBatchSize, 512)
+  }
+
+  func testInitializeWithValidParameters() {
+    let processor = BatchLogRecordProcessor(
+      logRecordExporter: WaitingLogRecordExporter(numberToWaitFor: 0),
+      scheduleDelay: 99,
+      exportTimeout: 99,
+      maxQueueSize: 99,
+      maxExportBatchSize: 99
+    )
+    XCTAssertEqual(processor.safeScheduleDelay, 99)
+    XCTAssertEqual(processor.safeExportTimeout, 99)
+    XCTAssertEqual(processor.safeMaxQueueSize, 99)
+    XCTAssertEqual(processor.safeMaxExportBatchSize, 99)
+  }
+
+  func testInitializeWithInvalidParameters() {
+    let processor = BatchLogRecordProcessor(
+      logRecordExporter: WaitingLogRecordExporter(numberToWaitFor: 0),
+      scheduleDelay: -99,
+      exportTimeout: -99,
+      maxQueueSize: 0,
+      maxExportBatchSize: 0
+    )
+    // Fallback to default parameters
+    XCTAssertEqual(processor.safeScheduleDelay, 5)
+    XCTAssertEqual(processor.safeExportTimeout, 30)
+    XCTAssertEqual(processor.safeMaxQueueSize, 2048)
+    XCTAssertEqual(processor.safeMaxExportBatchSize, 512)
+  }
 }
 
 class BlockingLogRecordExporter: LogRecordExporter {
diff --git a/Tests/OpenTelemetrySdkTests/Trace/Export/BatchSpansProcessorTests.swift b/Tests/OpenTelemetrySdkTests/Trace/Export/BatchSpansProcessorTests.swift
@@ -70,7 +70,8 @@ class BatchSpansProcessorTests: XCTestCase {
     tracerSdkFactory.addSpanProcessor(BatchSpanProcessor(spanExporter: waitingSpanExporter,
                                                          meterProvider: DefaultStableMeterProvider.instance,
                                                          scheduleDelay: maxScheduleDelay,
-                                                         maxQueueSize: 6, maxExportBatchSize: 2)
+                                                         maxQueueSize: 6,
+                                                         maxExportBatchSize: 2)
     )
 
     let span1 = createSampledEndedSpan(spanName: spanName1)
@@ -247,6 +248,48 @@ class BatchSpansProcessorTests: XCTestCase {
     // Interestingly, this will always succeed on macOS even if you intentionally create a strong reference cycle between the BatchWorker and the Thread's closure. I assume either calling cancel or the thread exiting releases the closure which breaks the cycle. This is not the case on Linux where the test will fail as expected.
     XCTAssertNil(exporter)
   }
+
+  func testInitializeWithDefaultParameters() {
+    let processor = BatchSpanProcessor(
+      spanExporter: WaitingSpanExporter(numberToWaitFor: 0),
+      meterProvider: DefaultStableMeterProvider.instance
+    )
+    XCTAssertEqual(processor.safeScheduleDelay, 5)
+    XCTAssertEqual(processor.safeExportTimeout, 30)
+    XCTAssertEqual(processor.safeMaxQueueSize, 2048)
+    XCTAssertEqual(processor.safeMaxExportBatchSize, 512)
+  }
+
+  func testInitializeWithValidParameters() {
+    let processor = BatchSpanProcessor(
+      spanExporter: WaitingSpanExporter(numberToWaitFor: 0),
+      meterProvider: DefaultStableMeterProvider.instance,
+      scheduleDelay: 99,
+      exportTimeout: 99,
+      maxQueueSize: 99,
+      maxExportBatchSize: 99
+    )
+    XCTAssertEqual(processor.safeScheduleDelay, 99)
+    XCTAssertEqual(processor.safeExportTimeout, 99)
+    XCTAssertEqual(processor.safeMaxQueueSize, 99)
+    XCTAssertEqual(processor.safeMaxExportBatchSize, 99)
+  }
+
+  func testInitializeWithInvalidParameters() {
+    let processor = BatchSpanProcessor(
+      spanExporter: WaitingSpanExporter(numberToWaitFor: 0),
+      meterProvider: DefaultStableMeterProvider.instance,
+      scheduleDelay: -99,
+      exportTimeout: -99,
+      maxQueueSize: 0,
+      maxExportBatchSize: 0
+    )
+    // Fallback to default parameters
+    XCTAssertEqual(processor.safeScheduleDelay, 5)
+    XCTAssertEqual(processor.safeExportTimeout, 30)
+    XCTAssertEqual(processor.safeMaxQueueSize, 2048)
+    XCTAssertEqual(processor.safeMaxExportBatchSize, 512)
+  }
 }
 
 class BlockingSpanExporter: SpanExporter {

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class SpanAdapterTests: XCTestCase {`
`23`	`23`	`spanContext = SpanContext.create(traceId: traceId, spanId: spanId, traceFlags: TraceFlags(), traceState: tracestate)`
`24`	`24`	`}`
`25`	`25`
`26`		`- func testToPRotoResourceSpans() {`
	`26`	`+ func testToProtoResourceSpans() {`
`27`	`27`	`let libInfo = InstrumentationScopeInfo(name: "testScope", version: "semver:0.0.1")`
`28`	`28`
`29`	`29`	`let event = RecordEventsReadableSpan.startSpan(context: spanContext, name: "GET /api/endpoint", instrumentationScopeInfo: libInfo, kind: SpanKind.server, parentContext: nil, hasRemoteParent: false, spanLimits: SpanLimits(), spanProcessor: NoopSpanProcessor(), clock: MillisClock(), resource: Resource(), attributes: AttributesDictionary(capacity: 0), links: [], totalRecordedLinks: 0, startTime: Date())`