Merge branch 'main' into enable-logging-grpc-calloptions

Author: BennettSmith

Sources/Instrumentation/URLSession/URLSessionInstrumentation.swift

@@ -388,7 +388,6 @@ public class URLSessionInstrumentation {
         let block: @convention(block) (Any, URLSession, URLSessionDataTask, URLResponse, @escaping (URLSession.ResponseDisposition) -> Void) -> Void = { object, session, dataTask, response, completion in
             if objc_getAssociatedObject(session, &idKey) == nil {
                 self.urlSession(session, dataTask: dataTask, didReceive: response, completionHandler: completion)
-                completion(.allow)
             }
             let key = String(selector.hashValue)
             objc_setAssociatedObject(session, key, true, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

Tests/ExportersTests/PersistenceExporter/Storage/OrchestratedFileWriterTests.swift

@@ -83,59 +83,60 @@ class OrchestratedFileWriterTests: XCTestCase {
     }
 
     /// NOTE: Test added after incident-4797
-    func testWhenIOExceptionsHappenRandomly_theFileIsNeverMalformed() throws {
-        let expectation = self.expectation(description: "write completed")
-        let writer = OrchestratedFileWriter(
-            orchestrator: FilesOrchestrator(
-                directory: temporaryDirectory,
-                performance: StoragePerformanceMock(
-                    maxFileSize: .max,
-                    maxDirectorySize: .max,
-                    maxFileAgeForWrite: .distantFuture, // write to single file
-                    minFileAgeForRead: .distantFuture,
-                    maxFileAgeForRead: .distantFuture,
-                    maxObjectsInFile: .max, // write to single file
-                    maxObjectSize: .max
-                ),
-                dateProvider: SystemDateProvider()
-            )
-        )
-
-        let ioInterruptionQueue = DispatchQueue(label: "com.otel.persistence.file-writer-random-io")
-
-        func randomlyInterruptIO(for file: File?) {
-            ioInterruptionQueue.async { try? file?.makeReadonly() }
-            ioInterruptionQueue.async { try? file?.makeReadWrite() }
-        }
-        
-        struct Foo: Codable {
-            var foo = "bar"
-        }
-
-        let jsonEncoder = JSONEncoder()
-        
-        // Write 300 of `Foo`s and interrupt writes randomly
-        try (0..<300).forEach { _ in
-            var fooData = try jsonEncoder.encode(Foo())
-            fooData.append(",".utf8Data)
-            writer.write(data: fooData)
-            randomlyInterruptIO(for: try? temporaryDirectory.files().first)
-        }
-
-        ioInterruptionQueue.sync {}
-        waitForWritesCompletion(on: writer.queue, thenFulfill: expectation)
-        waitForExpectations(timeout: 7, handler: nil)
-        XCTAssertEqual(try temporaryDirectory.files().count, 1)
-
-        let fileData = try temporaryDirectory.files()[0].read()
-        let jsonDecoder = JSONDecoder()
-
-        // Assert that data written is not malformed
-        let writtenData = try jsonDecoder.decode([Foo].self, from: "[".utf8Data + fileData + "]".utf8Data)
-        // Assert that some (including all) `Foo`s were written
-        XCTAssertGreaterThan(writtenData.count, 0)
-        XCTAssertLessThanOrEqual(writtenData.count, 300)
-    }
+    /// NOTE 2: Test disabled after random failures/successes
+//    func testWhenIOExceptionsHappenRandomly_theFileIsNeverMalformed() throws {
+//        let expectation = self.expectation(description: "write completed")
+//        let writer = OrchestratedFileWriter(
+//            orchestrator: FilesOrchestrator(
+//                directory: temporaryDirectory,
+//                performance: StoragePerformanceMock(
+//                    maxFileSize: .max,
+//                    maxDirectorySize: .max,
+//                    maxFileAgeForWrite: .distantFuture, // write to single file
+//                    minFileAgeForRead: .distantFuture,
+//                    maxFileAgeForRead: .distantFuture,
+//                    maxObjectsInFile: .max, // write to single file
+//                    maxObjectSize: .max
+//                ),
+//                dateProvider: SystemDateProvider()
+//            )
+//        )
+//
+//        let ioInterruptionQueue = DispatchQueue(label: "com.otel.persistence.file-writer-random-io")
+//
+//        func randomlyInterruptIO(for file: File?) {
+//            ioInterruptionQueue.async { try? file?.makeReadonly() }
+//            ioInterruptionQueue.async { try? file?.makeReadWrite() }
+//        }
+//
+//        struct Foo: Codable {
+//            var foo = "bar"
+//        }
+//
+//        let jsonEncoder = JSONEncoder()
+//
+//        // Write 300 of `Foo`s and interrupt writes randomly
+//        try (0..<300).forEach { _ in
+//            var fooData = try jsonEncoder.encode(Foo())
+//            fooData.append(",".utf8Data)
+//            writer.write(data: fooData)
+//            randomlyInterruptIO(for: try? temporaryDirectory.files().first)
+//        }
+//
+//        ioInterruptionQueue.sync {}
+//        waitForWritesCompletion(on: writer.queue, thenFulfill: expectation)
+//        waitForExpectations(timeout: 7, handler: nil)
+//        XCTAssertEqual(try temporaryDirectory.files().count, 1)
+//
+//        let fileData = try temporaryDirectory.files()[0].read()
+//        let jsonDecoder = JSONDecoder()
+//
+//        // Assert that data written is not malformed
+//        let writtenData = try jsonDecoder.decode([Foo].self, from: "[".utf8Data + fileData + "]".utf8Data)
+//        // Assert that some (including all) `Foo`s were written
+//        XCTAssertGreaterThan(writtenData.count, 0)
+//        XCTAssertLessThanOrEqual(writtenData.count, 300)
+//    }
 
     private func waitForWritesCompletion(on queue: DispatchQueue, thenFulfill expectation: XCTestExpectation) {
         queue.async { expectation.fulfill() }