Apply CR suggestions

Author: barboraplasovska

DatadogRUM/Sources/Feature/RUMFeature.swift

@@ -140,7 +140,6 @@ internal final class RUMFeature: DatadogRemoteFeature, RUMSessionSamplerProvider
                 memoryReader: $0.memory,
                 featureScope: featureScope,
                 batchSize: configuration.timeseriesBatchSize,
-                collectInBackground: configuration.trackBackgroundEvents,
                 ciTest: ciTest,
                 syntheticsTest: syntheticsTest,
                 sessionSampleRate: Double(sessionSampleRate)

DatadogRUM/Sources/Timeseries/TimeseriesSessionCollector.swift

@@ -43,7 +43,6 @@ internal class TimeseriesSessionCollector: TimeseriesCollecting {
     private let cpuUsageProvider: () -> Double?
     private let batchSize: Int
     private let samplingInterval: TimeInterval
-    private let collectInBackground: Bool
     private let featureScope: FeatureScope
     private let totalRAM: Double
     private let ciTest: RUMCITest?
@@ -71,7 +70,6 @@ internal class TimeseriesSessionCollector: TimeseriesCollecting {
         featureScope: FeatureScope,
         batchSize: Int = 120,
         samplingInterval: TimeInterval = 1,
-        collectInBackground: Bool = false,
         cpuUsageProvider: (() -> Double?)? = nil,
         totalRAM: Double = Double(ProcessInfo.processInfo.physicalMemory),
         ciTest: RUMCITest? = nil,
@@ -81,7 +79,6 @@ internal class TimeseriesSessionCollector: TimeseriesCollecting {
         self.memoryReader = memoryReader
         self.batchSize = max(2, batchSize)
         self.samplingInterval = samplingInterval
-        self.collectInBackground = collectInBackground
         self.featureScope = featureScope
         self.totalRAM = totalRAM
         self.ciTest = ciTest
@@ -90,6 +87,10 @@ internal class TimeseriesSessionCollector: TimeseriesCollecting {
         self.cpuUsageProvider = cpuUsageProvider ?? { TimeseriesSessionCollector.processCPU() }
     }
 
+    deinit {
+        timer?.cancel()
+    }
+
     /// Per-process CPU as a percentage (0–100+), summed across all app threads.
     /// Separated into a static so it can be called from the init closure without capturing self.
     private static func processCPU() -> Double? {
@@ -121,7 +122,7 @@ internal class TimeseriesSessionCollector: TimeseriesCollecting {
             var info = thread_basic_info()
             var infoCount = mach_msg_type_number_t(THREAD_INFO_MAX)
             let kr = withUnsafeMutablePointer(to: &info) {
-                $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
+                $0.withMemoryRebound(to: integer_t.self, capacity: Int(infoCount)) {
                     thread_info(threadsList[Int(i)], thread_flavor_t(THREAD_BASIC_INFO), $0, &infoCount)
                 }
             }
@@ -130,7 +131,7 @@ internal class TimeseriesSessionCollector: TimeseriesCollecting {
             }
             total += Double(info.cpu_usage) / Double(TH_USAGE_SCALE) * 100.0
         }
-        return total
+        return min(total, 100.0)
         #endif
     }
 
@@ -155,13 +156,12 @@ internal class TimeseriesSessionCollector: TimeseriesCollecting {
     }
 
     /// Suspends sampling and flushes buffered data. Session state is preserved for `resume()`. Idempotent.
-    /// No-op when `collectInBackground` is `true`.
     func pause() {
         queue.async { [weak self] in
             guard let self = self else {
                 return
             }
-            if self.collectInBackground || self.isPaused || self.timer == nil {
+            if self.isPaused || self.timer == nil {
                 return
             }
             self.timer?.cancel()

DatadogRUM/Tests/Timeseries/TimeseriesSessionCollectorTests.swift

@@ -627,15 +627,14 @@ class TimeseriesSessionCollectorTests: XCTestCase {
         XCTAssertGreaterThan(countAfterResume, countAfterPause, "Expected new events after resume")
     }
 
-    func testWhenCollectInBackgroundEnabled_pauseIsNoOp() {
+    func testWhenBackgrounded_pauseAlwaysStopsSampling() {
         // Given
         memoryReader.vitalData = 1_000_000
         let collector = TimeseriesSessionCollector(
             memoryReader: memoryReader,
             featureScope: featureScope,
             batchSize: 2,
             samplingInterval: 0.05,
-            collectInBackground: true,
             cpuUsageProvider: { nil }
         )
         let contextReader = RUMActiveContextReaderMock()
@@ -651,17 +650,17 @@ class TimeseriesSessionCollectorTests: XCTestCase {
         let countBeforePause = featureScope.eventsWritten(ofType: RUMTimeseriesMemoryEvent.self).count
         XCTAssertGreaterThan(countBeforePause, 0)
 
-        // When — pause should be a no-op
-        let afterPauseExpectation = self.expectation(description: "sampling continues after pause")
+        // When — pause on backgrounding
+        let afterPauseExpectation = self.expectation(description: "sampling stopped after pause")
         afterPauseExpectation.assertForOverFulfill = false
         collector.pause()
         DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { afterPauseExpectation.fulfill() }
         waitForExpectations(timeout: 2)
-        collector.stop()
 
-        // Then — events keep accumulating
+        // Then — no new events accumulate while paused
         let countAfterPause = featureScope.eventsWritten(ofType: RUMTimeseriesMemoryEvent.self).count
-        XCTAssertGreaterThan(countAfterPause, countBeforePause, "Sampling should continue when collectInBackground = true")
+        XCTAssertEqual(countAfterPause, countBeforePause, "Sampling should stop while backgrounded, regardless of trackBackgroundEvents")
+        collector.stop()
     }
 
     func testWhenPauseCalledBeforeStart_itIsNoOp() {