fix(react-native): added Clock.fromUnixNanosecondsTimestamp so that all JS/ReactNative timestamps can be sent as strings

Author: lemnik

packages/core/lib/clock.ts

@@ -21,12 +21,9 @@ export interface Clock {
   // a function to convert a Date object into the format returned by 'now'
   convert: (date: Date) => number
 
-  // convert the format returned by 'now' to a unix time in nanoseconds
-  toUnixNanoseconds: (time: number) => number
-
-  // convert a unix time in nanoseconds to the format returned by 'now'
-  fromUnixNanoseconds: (time: number) => number
-
   // convert the format returned by 'now' into a unix timestamp in nanoseconds
   toUnixTimestampNanoseconds: (time: number) => string
+
+  // convert a unix timestamp in nanoseconds into the format returned by 'now'
+  fromUnixNanosecondsTimestamp: (timestamp: string) => number
 }

packages/platforms/browser/lib/clock.ts

@@ -45,17 +45,16 @@ function createClock (performance: PerformanceWithOptionalTimeOrigin, background
   })
 
   const toUnixNanoseconds = (time: number) => millisecondsToNanoseconds(calculatedTimeOrigin + time)
+  const fromUnixNanoseconds = (time: number) => nanosecondsToMilliseconds(time) - calculatedTimeOrigin
 
   return {
     now: () => performance.now(),
     date: () => new Date(calculatedTimeOrigin + performance.now()),
     convert: (date) => date.getTime() - calculatedTimeOrigin,
-    // convert milliseconds since timeOrigin to unix time in nanoseconds
-    toUnixNanoseconds,
     // convert milliseconds since timeOrigin to full timestamp
     toUnixTimestampNanoseconds: (time: number) => toUnixNanoseconds(time).toString(),
-    // convert unix time in nanoseconds back to milliseconds since timeOrigin
-    fromUnixNanoseconds: (time: number) => nanosecondsToMilliseconds(time) - calculatedTimeOrigin
+    // convert a unix timestamp in nanoseconds back to milliseconds since timeOrigin
+    fromUnixNanosecondsTimestamp: (timestamp: string) => fromUnixNanoseconds(parseInt(timestamp))
   }
 }
 

packages/platforms/browser/tests/clock.test.ts

@@ -164,53 +164,4 @@ describe('Browser Clock', () => {
       expect(clock.convert(new Date())).toEqual(0)
     })
   })
-
-  describe('clock.toUnixNanoseconds()', () => {
-    it('converts performance time to unix nanoseconds', () => {
-      const timeOrigin = new Date('2023-01-02T00:00:00.000Z')
-      jest.setSystemTime(timeOrigin)
-
-      const clock = createClock(new PerformanceFake(), new ControllableBackgroundingListener())
-
-      jest.advanceTimersByTime(250)
-
-      const performanceTime = clock.now()
-      const unixNanoseconds = clock.toUnixNanoseconds(performanceTime)
-
-      // Expected: timeOrigin + 250ms in nanoseconds
-      const expectedNanoseconds = (timeOrigin.getTime() + 250) * 1000000
-      expect(unixNanoseconds).toBe(expectedNanoseconds)
-    })
-  })
-
-  describe('clock.fromUnixNanoseconds()', () => {
-    it('converts unix nanoseconds back to performance time', () => {
-      const timeOrigin = new Date('2023-01-02T00:00:00.000Z')
-      jest.setSystemTime(timeOrigin)
-
-      const clock = createClock(new PerformanceFake(), new ControllableBackgroundingListener())
-
-      // Test with a specific unix nanoseconds value 123ms after timeOrigin
-      const unixNanoseconds = 1672617600123000000 // 2023-01-02T00:00:00.123Z in nanoseconds
-      const performanceTime = clock.fromUnixNanoseconds(unixNanoseconds)
-
-      expect(typeof performanceTime).toBe('number')
-      expect(performanceTime).toEqual(123) // 123ms after timeOrigin
-    })
-
-    it('is the inverse of toUnixNanoseconds', () => {
-      const timeOrigin = new Date('2023-01-02T00:00:00.000Z')
-      jest.setSystemTime(timeOrigin)
-
-      const clock = createClock(new PerformanceFake(), new ControllableBackgroundingListener())
-
-      jest.advanceTimersByTime(123)
-
-      const originalTime = clock.now()
-      const unixNanoseconds = clock.toUnixNanoseconds(originalTime)
-      const roundTripTime = clock.fromUnixNanoseconds(unixNanoseconds)
-
-      expect(roundTripTime).toBe(originalTime)
-    })
-  })
 })

packages/platforms/react-native/lib/clock.ts

@@ -1,5 +1,4 @@
 import type { Clock } from '@bugsnag/core-performance'
-import { millisecondsToNanoseconds, nanosecondsToMilliseconds } from '@bugsnag/core-performance'
 
 interface Performance {
   now: () => number
@@ -27,22 +26,106 @@ const addStrings = (num1: string, num2: string): string => {
   return result
 }
 
+// Helper function to subtract two numbers represented as strings (num1 - num2)
+const subtractStrings = (num1: string, num2: string): string => {
+  // Ensure num1 >= num2 for simplicity
+  if (num1.length < num2.length || (num1.length === num2.length && num1 < num2)) {
+    throw new Error('Cannot subtract larger number from smaller number')
+  }
+
+  let result = ''
+  let borrow = 0
+  let i = num1.length - 1
+  let j = num2.length - 1
+
+  while (i >= 0) {
+    const digit1 = parseInt(num1[i], 10) - borrow
+    const digit2 = j >= 0 ? parseInt(num2[j], 10) : 0
+
+    if (digit1 >= digit2) {
+      result = (digit1 - digit2) + result
+      borrow = 0
+    } else {
+      result = (digit1 + 10 - digit2) + result
+      borrow = 1
+    }
+
+    i--
+    j--
+  }
+
+  // Remove leading zeros
+  return result.replace(/^0+/, '') || '0'
+}
+
+// Helper function to handle decimal arithmetic with strings
+const subtractDecimalStrings = (num1Str: string, num2Str: string): string => {
+  // Parse decimal numbers
+  const [int1, frac1 = ''] = num1Str.split('.')
+  const [int2, frac2 = ''] = num2Str.split('.')
+
+  // Pad fractional parts to same length
+  const maxFracLen = Math.max(frac1.length, frac2.length)
+  const padded1 = frac1.padEnd(maxFracLen, '0')
+  const padded2 = frac2.padEnd(maxFracLen, '0')
+
+  // Combine integer and fractional parts
+  const combined1 = int1 + padded1
+  const combined2 = int2 + padded2
+
+  // Subtract
+  const resultCombined = subtractStrings(combined1, combined2)
+
+  // Split back into integer and fractional parts
+  if (maxFracLen === 0) {
+    return resultCombined
+  }
+
+  const resultInt = resultCombined.slice(0, -maxFracLen) || '0'
+  const resultFrac = resultCombined.slice(-maxFracLen).replace(/0+$/, '')
+
+  return resultFrac ? `${resultInt}.${resultFrac}` : resultInt
+}
+
+const addDecimalStrings = (num1Str: string, num2Str: string): string => {
+  // Parse decimal numbers
+  const [int1, frac1 = ''] = num1Str.split('.')
+  const [int2, frac2 = ''] = num2Str.split('.')
+
+  // Pad fractional parts to same length
+  const maxFracLen = Math.max(frac1.length, frac2.length)
+  const padded1 = frac1.padEnd(maxFracLen, '0')
+  const padded2 = frac2.padEnd(maxFracLen, '0')
+
+  // Combine integer and fractional parts
+  const combined1 = int1 + padded1
+  const combined2 = int2 + padded2
+
+  // Add
+  const resultCombined = addStrings(combined1, combined2)
+
+  // Split back into integer and fractional parts
+  if (maxFracLen === 0) {
+    return resultCombined
+  }
+
+  const resultInt = resultCombined.slice(0, -maxFracLen) || '0'
+  const resultFrac = resultCombined.slice(-maxFracLen).replace(/0+$/, '')
+
+  return resultFrac ? `${resultInt}.${resultFrac}` : resultInt
+}
+
 const createClock = (performance: Performance): Clock => {
   // Measurable "monotonic" time
   // In React Native, `performance.now` often returns some very high values, but does not expose the `timeOrigin` it uses to calculate what "now" is.
   // by storing the value of `performance.now` when the app starts, we can remove that value from any further `.now` calculations, and add it to the current "wall time" to get a useful timestamp.
   const startPerfTime = performance.now()
   const startWallTime = Date.now()
 
-  const toUnixNanoseconds = (time: number) => millisecondsToNanoseconds(time - startPerfTime + startWallTime)
-
   return {
     now: () => performance.now(),
     date: () => new Date(performance.now() - startPerfTime + startWallTime),
     convert: (date: Date) => date.getTime() - startWallTime + startPerfTime,
-    toUnixNanoseconds,
-    // convert unix time in nanoseconds back to milliseconds since timeOrigin
-    fromUnixNanoseconds: (time: number) => nanosecondsToMilliseconds(time) - startWallTime + startPerfTime,
     // convert milliseconds since timeOrigin to full timestamp
     toUnixTimestampNanoseconds: (time: number) => {
       // Calculate the unix timestamp in milliseconds with high precision
@@ -85,6 +168,44 @@ const createClock = (performance: Performance): Clock => {
       }
 
       return result
+    },
+    // convert unix timestamp in nanoseconds (string) back to milliseconds since timeOrigin
+    fromUnixNanosecondsTimestamp: (nanosStr: string) => {
+      // Convert nanoseconds string to milliseconds string with full precision
+      let millisecondsStr: string
+
+      if (nanosStr.length <= 6) {
+        // Less than 1 millisecond - create fractional milliseconds
+        const paddedNanos = nanosStr.padStart(6, '0')
+        millisecondsStr = '0.' + paddedNanos
+      } else {
+        // Split nanoseconds into milliseconds and fractional nanoseconds
+        const msLength = nanosStr.length - 6
+        const integerMs = nanosStr.substring(0, msLength)
+        const fractionalNs = nanosStr.substring(msLength)
+
+        if (fractionalNs === '000000') {
+          millisecondsStr = integerMs
+        } else {
+          // Remove trailing zeros from fractional part
+          const trimmedFractional = fractionalNs.replace(/0+$/, '')
+          millisecondsStr = integerMs + '.' + trimmedFractional
+        }
+      }
+
+      // Perform calculation using string arithmetic to maintain precision
+      // unixMilliseconds - startWallTime + startPerfTime
+      const startWallTimeStr = startWallTime.toString()
+      const startPerfTimeStr = startPerfTime.toString()
+
+      // Step 1: unixMilliseconds - startWallTime
+      const afterSubtraction = subtractDecimalStrings(millisecondsStr, startWallTimeStr)
+
+      // Step 2: result + startPerfTime
+      const finalResult = addDecimalStrings(afterSubtraction, startPerfTimeStr)
+
+      // Convert to number only at the very end
+      return parseFloat(finalResult)
     }
   }
 }

packages/platforms/react-native/tests/clock.test.ts

@@ -113,52 +113,42 @@ describe('React Native Clock', () => {
     })
   })
 
-  describe('clock.toUnixNanoseconds()', () => {
-    it('converts performance time to unix nanoseconds', () => {
-      const timeOrigin = new Date('2023-01-02T00:00:00.000Z')
+  describe('clock.fromUnixNanosecondsTimestamp()', () => {
+    it('converts a timestamp to a valid time', () => {
+      const timeOrigin = new Date('1970-01-01T00:00:00.000Z')
       jest.setSystemTime(timeOrigin)
 
       const clock = createClock(performance)
 
-      jest.advanceTimersByTime(250)
-
-      const performanceTime = clock.now()
-      const unixNanoseconds = clock.toUnixNanoseconds(performanceTime)
-
-      // Expected: timeOrigin + 250ms in nanoseconds
-      const expectedNanoseconds = (timeOrigin.getTime() + 250) * 1000000
-      expect(unixNanoseconds).toBe(expectedNanoseconds)
-    })
-  })
-
-  describe('clock.fromUnixNanoseconds()', () => {
-    it('converts unix nanoseconds back to performance time', () => {
-      const timeOrigin = new Date('2023-01-02T00:00:00.000Z')
-      jest.setSystemTime(timeOrigin)
-
-      const clock = createClock(performance)
+      // Set up initial time
+      jest.advanceTimersByTime(69)
 
-      // Test with a specific unix nanoseconds value 123ms after timeOrigin
-      const unixNanoseconds = 1672617600123000000 // 2023-01-02T00:00:00.123Z in nanoseconds
-      const performanceTime = clock.fromUnixNanoseconds(unixNanoseconds)
+      // Convert to nanosecond timestamp string and back
+      const startTime = clock.now()
+      const unixTimeStamp = clock.toUnixTimestampNanoseconds(startTime)
+      const convertedTime = clock.fromUnixNanosecondsTimestamp(unixTimeStamp)
 
-      expect(typeof performanceTime).toBe('number')
-      expect(performanceTime).toEqual(123) // 123ms after timeOrigin
+      // The converted time should match the original time
+      expect(convertedTime).toBe(startTime)
     })
 
-    it('is the inverse of toUnixNanoseconds', () => {
-      const timeOrigin = new Date('2023-01-02T00:00:00.000Z')
+    it('converts extreme timestamps into valid time values', () => {
+      // Use a large timestamp value
+      const timeOrigin = new Date(18446744073709)
       jest.setSystemTime(timeOrigin)
 
       const clock = createClock(performance)
 
-      jest.advanceTimersByTime(123)
+      // Add a fractional time value
+      jest.advanceTimersByTime(0.55)
 
-      const originalTime = clock.now()
-      const unixNanoseconds = clock.toUnixNanoseconds(originalTime)
-      const roundTripTime = clock.fromUnixNanoseconds(unixNanoseconds)
+      // Convert to nanosecond timestamp string and back
+      const startTime = clock.now()
+      const unixTimeStamp = clock.toUnixTimestampNanoseconds(startTime)
+      const convertedTime = clock.fromUnixNanosecondsTimestamp(unixTimeStamp)
 
-      expect(roundTripTime).toBe(originalTime)
+      // The converted time should match the original time
+      expect(convertedTime).toBe(startTime)
     })
   })
 })

packages/plugin-named-spans/tests/named-span-access.test.ts

@@ -13,7 +13,7 @@ describe('BugsnagNamedSpansPlugin', () => {
     plugin = new BugsnagNamedSpansPlugin()
     context = new PluginContext<Configuration>(
       createConfiguration<Configuration>(),
-      { now: jest.fn(() => 1000), toUnixNanoseconds: jest.fn(() => 1000000000) } as unknown as IncrementingClock
+      { now: jest.fn(() => 1000), toUnixTimestampNanoseconds: jest.fn(() => '1000000000') } as unknown as IncrementingClock
     )
 
     // Install the plugin to the context

packages/plugin-react-native-span-access/android/src/main/java/com/bugsnag/reactnative/performance/nativespans/JavascriptSpanTransactionImpl.java

@@ -129,7 +129,7 @@ public void commit(OnRemoteSpanUpdatedCallback callback) {
     updateTransaction.putArray(ATTRIBUTES, attributesArray);
 
     if (isEnded) {
-      updateTransaction.putDouble(END_TIME, endTime);
+      updateTransaction.putString(END_TIME, Long.toString(endTime));
       updateTransaction.putBoolean(IS_ENDED, true);
     }