Add timing and interface information to data transfer snapshots

Sources/SwiftNetwork/Connection/DataTransferSnapshot.swift

@@ -14,8 +14,11 @@
 
 @_spi(ProtocolProvider)
 @available(Network 0.1.0, *)
-public struct DataTransferSnapshot: Equatable {
+public struct DataTransferSnapshot: Equatable, Sendable {
+    public var snapshotTimestamp: NetworkClock.Instant = .zero
     public var interfaceIndex: UInt64?
+    public var interfaceType: InterfaceType?
+    public var pathIdentifier: UInt64?
 
     public var receivedIPPacketCount: UInt64 = 0
     public var receivedIPEct1PacketCount: UInt64 = 0

Sources/SwiftNetwork/QUIC/QUICConnection.swift

@@ -2766,13 +2766,16 @@ public final class QUICConnection: ManyToManyApplicationStreamProtocol,
     #endif
 
     public func updateDataTransferSnapshot(flow: MultiplexedFlowIdentifier, _ snapshot: inout DataTransferSnapshot) {
+        snapshot.snapshotTimestamp = self.now
         snapshot.receivedTransportOutOfOrderByteCount = UInt64(clamping: self.stats[.rxOutOfOrderBytes])
         snapshot.sentTransportRetransmittedByteCount = UInt64(clamping: self.stats[.txRetransmittedBytes])
         snapshot.sentTransportECNCapablePacketCount = UInt64(clamping: self.stats[.ecnCapablePacketsSent])
         snapshot.sentTransportECNCapableAckedPacketCount = UInt64(clamping: self.stats[.ecnCapablePacketsAcknowledged])
         snapshot.sentTransportECNCapableMarkedPacketCount = UInt64(clamping: self.stats[.ecnCapablePacketsMarked])
         snapshot.sentTransportECNCapableLostPacketCount = UInt64(clamping: self.stats[.ecnCapablePacketsLost])
         if let path = currentPath {
+            snapshot.pathIdentifier = path.pathIdentifier
+            snapshot.interfaceType = path.interface?.interfaceType
             snapshot.transportMinimumRTT = path.rtt.minRTT
             snapshot.transportSmoothedRTT = path.rtt.smoothedRTT
             snapshot.transportCurrentRTT = path.rtt.adjustedRTT

Tests/QUICTests/QUICConnectionTests.swift

@@ -514,6 +514,43 @@ final class QUICConnectionTests: XCTestCase {
             )
         }
     }
+
+    func testSnapshotTimestampDuration() {
+        // Verify that two snapshots with different timestamps can compute a duration
+        var first = DataTransferSnapshot()
+        first.snapshotTimestamp = NetworkClock.Instant(nanoseconds: 1_000_000_000) // 1s
+
+        var second = DataTransferSnapshot()
+        second.snapshotTimestamp = NetworkClock.Instant(nanoseconds: 3_500_000_000) // 3.5s
+
+        let duration = first.snapshotTimestamp.duration(to: second.snapshotTimestamp)
+        XCTAssertEqual(duration, .milliseconds(2500), "Duration between snapshots should be 2.5 seconds")
+
+        // Verify snapshots remain independently equal to themselves
+        XCTAssertEqual(first, first)
+        XCTAssertEqual(second, second)
+        XCTAssertNotEqual(first, second)
+    }
+
+    func testSnapshotPreservesInterfaceType() {
+        // Verify that path and interface information round-trips through a snapshot
+        var snapshot = DataTransferSnapshot()
+        snapshot.pathIdentifier = 42
+        snapshot.interfaceType = .wifi
+        snapshot.snapshotTimestamp = NetworkClock.Instant(nanoseconds: 500_000_000)
+
+        XCTAssertEqual(snapshot.pathIdentifier, 42)
+        XCTAssertEqual(snapshot.interfaceType, .wifi)
+
+        // Verify different interface types are distinguishable
+        var cellularSnapshot = DataTransferSnapshot()
+        cellularSnapshot.pathIdentifier = 43
+        cellularSnapshot.interfaceType = .cellular
+        cellularSnapshot.snapshotTimestamp = NetworkClock.Instant(nanoseconds: 600_000_000)
+
+        XCTAssertNotEqual(snapshot.interfaceType, cellularSnapshot.interfaceType)
+        XCTAssertNotEqual(snapshot, cellularSnapshot)
+    }
 }
 
 #endif