Add nanoseconds to instant protocol

**Motivation:**

we have nanoseconds precision on most platforms so lets expose it.

Author: ktoso

Sources/Tracing/TracingTime.swift

@@ -21,26 +21,17 @@ import Darwin
 @_exported import Instrumentation
 @_exported import InstrumentationBaggage
 
-public protocol SwiftDistributedTracingDurationProtocol: Comparable, AdditiveArithmetic, Sendable {
-    static func / (_ lhs: Self, _ rhs: Int) -> Self
-    static func /= (_ lhs: inout Self, _ rhs: Int)
-    static func * (_ lhs: Self, _ rhs: Int) -> Self
-    static func *= (_ lhs: inout Self, _ rhs: Int)
-
-    static func / (_ lhs: Self, _ rhs: Self) -> Double
-}
-
-extension SwiftDistributedTracingDurationProtocol {
-    public static func /= (_ lhs: inout Self, _ rhs: Int) {
-        lhs = lhs / rhs
-    }
+public protocol TracerInstantProtocol: Comparable, Hashable, Sendable {
+    /// Representation of this instant as the number of nanoseconds since UNIX Epoch (January 1st 1970)
+    var nanosecondsSinceEpoch: UInt64 { get }
 }
 
-public protocol SwiftDistributedTracingInstantProtocol: Comparable, Hashable, Sendable {}
-
-public protocol TracerInstantProtocol: SwiftDistributedTracingInstantProtocol {
+extension TracerInstantProtocol {
     /// Representation of this instant as the number of milliseconds since UNIX Epoch (January 1st 1970)
-    var millisecondsSinceEpoch: UInt64 { get }
+    @inlinable
+    public var millisecondsSinceEpoch: UInt64 {
+        self.nanosecondsSinceEpoch / 1_000_000
+    }
 }
 
 /// A specialized clock protocol for purposes of tracing.
@@ -69,23 +60,22 @@ public struct DefaultTracerClock: TracerClock {
     }
 
     public struct Timestamp: TracerInstantProtocol {
-        /// Milliseconds since January 1st, 1970, also known as "unix epoch".
-        public var millisecondsSinceEpoch: UInt64
+        public let nanosecondsSinceEpoch: UInt64
 
-        internal init(millisecondsSinceEpoch: UInt64) {
-            self.millisecondsSinceEpoch = millisecondsSinceEpoch
+        public init(nanosecondsSinceEpoch: UInt64) {
+            self.nanosecondsSinceEpoch = nanosecondsSinceEpoch
         }
 
         public static func < (lhs: Instant, rhs: Instant) -> Bool {
-            lhs.millisecondsSinceEpoch < rhs.millisecondsSinceEpoch
+            lhs.nanosecondsSinceEpoch < rhs.nanosecondsSinceEpoch
         }
 
         public static func == (lhs: Instant, rhs: Instant) -> Bool {
-            lhs.millisecondsSinceEpoch == rhs.millisecondsSinceEpoch
+            lhs.nanosecondsSinceEpoch == rhs.nanosecondsSinceEpoch
         }
 
         public func hash(into hasher: inout Hasher) {
-            self.millisecondsSinceEpoch.hash(into: &hasher)
+            self.nanosecondsSinceEpoch.hash(into: &hasher)
         }
     }
 
@@ -100,8 +90,7 @@ public struct DefaultTracerClock: TracerClock {
         /// and the odds that this code will still be running 530 years from now is very, very low,
         /// so as a practical matter this will never overflow.
         let nowNanos = UInt64(ts.tv_sec) &* 1_000_000_000 &+ UInt64(ts.tv_nsec)
-        let nowMillis = UInt64(nowNanos / 1_000_000) // nanos to millis
 
-        return Instant(millisecondsSinceEpoch: nowMillis)
+        return Instant(nanosecondsSinceEpoch: nowNanos)
     }
 }

Tests/TracingTests/DynamicTracepointTracerTests.swift

@@ -258,8 +258,8 @@ extension DynamicTracepointTestTracer {
 
         private var status: SpanStatus?
 
-        private let startTime: UInt64
-        private(set) var endTime: UInt64?
+        private let startTimestampNanosSinceEpoch: UInt64
+        private(set) var endTimestampNanosSinceEpoch: UInt64?
 
         public var operationName: String
         private(set) var baggage: Baggage
@@ -290,7 +290,7 @@ extension DynamicTracepointTestTracer {
                                              onEnd: @escaping (TracepointSpan) -> Void)
         {
             self.operationName = operationName
-            self.startTime = startTime.millisecondsSinceEpoch
+            self.startTimestampNanosSinceEpoch = startTime.nanosecondsSinceEpoch
             self.baggage = baggage
             self.onEnd = onEnd
             self.kind = kind
@@ -323,7 +323,7 @@ extension DynamicTracepointTestTracer {
         }
 
         func end<Clock: TracerClock>(clock: Clock) {
-            self.endTime = clock.now.millisecondsSinceEpoch
+            self.endTimestampNanosSinceEpoch = clock.now.nanosecondsSinceEpoch
             self.onEnd(self)
         }
     }

Tests/TracingTests/TestTracer.swift

@@ -124,8 +124,8 @@ final class TestSpan: Span {
 
     private var status: SpanStatus?
 
-    public let startTime: UInt64
-    public private(set) var endTime: UInt64?
+    public let startTimestampNanosSinceEpoch: UInt64
+    public private(set) var endTimestampNanosSinceEpoch: UInt64?
 
     private(set) var recordedErrors: [(Error, SpanAttributes)] = []
 
@@ -158,7 +158,7 @@ final class TestSpan: Span {
         onEnd: @escaping (TestSpan) -> Void
     ) {
         self.operationName = operationName
-        self.startTime = startTime.millisecondsSinceEpoch
+        self.startTimestampNanosSinceEpoch = startTime.nanosecondsSinceEpoch
         self.baggage = baggage
         self.onEnd = onEnd
         self.kind = kind
@@ -182,7 +182,7 @@ final class TestSpan: Span {
     }
 
     func end<Clock: TracerClock>(clock: Clock) {
-        self.endTime = clock.now.millisecondsSinceEpoch
+        self.endTimestampNanosSinceEpoch = clock.now.nanosecondsSinceEpoch
         self.onEnd(self)
     }
 }

Tests/TracingTests/TracerTimeTests.swift

@@ -44,7 +44,7 @@ final class TracerTimeTests: XCTestCase {
         mockClock.setTime(13)
         #if swift(>=5.7.0)
         let span: TestSpan = tracer.startSpan("start", clock: mockClock)
-        XCTAssertEqual(span.startTime, 13)
+        XCTAssertEqual(span.startTimestampNanosSinceEpoch, 13)
         #else
         let span: TestSpan = tracer.startAnySpan("start", clock: mockClock) as! TestSpan
         XCTAssertEqual(span.startTime, 13)
@@ -62,13 +62,13 @@ final class MockClock: TracerClock {
     }
 
     struct Instant: TracerInstantProtocol {
-        var millisecondsSinceEpoch: UInt64
+        var nanosecondsSinceEpoch: UInt64
         static func < (lhs: MockClock.Instant, rhs: MockClock.Instant) -> Bool {
-            lhs.millisecondsSinceEpoch < rhs.millisecondsSinceEpoch
+            lhs.nanosecondsSinceEpoch < rhs.nanosecondsSinceEpoch
         }
     }
 
     var now: Instant {
-        Instant(millisecondsSinceEpoch: self._now)
+        Instant(nanosecondsSinceEpoch: self._now)
     }
 }