fix(node18): make telemetry fail-safe + openAsBlob fallback + scope fake timers

CI's Node 18.20 job (supported per engines: node >=18.20.0; wdio v9 supports 18.20) surfaced three Node-18-only failures that Node 20/22 tolerate:

1. PerformanceTester.start/end/measure called performance.mark/measure directly. Under vitest's full fake timers (7 test files) performance.now() goes negative, and Node 18's perf_hooks rejects negative timestamps (ERR_PERFORMANCE_INVALID_TIMESTAMP), throwing out of callers' before() hooks. Routed all mark/measure through safeMark/safeMeasure wrappers — instrumentation must never throw into business logic (no-op on the happy path; transparent on Node 20+).

2. uploadLogs used fs.openAsBlob (Node >=20 only). Added a Node-18 fallback to new Blob([readFileSync]) for the small log archive.

3. util.test.ts faked  via bare useFakeTimers(); scoped to toFake:['Date'] (it never advances timers), matching reporter.test.ts.

Verified locally on Node 18.20.5 AND Node 22: npm ci + build + 980/980 tests pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: AakashHotchandani

packages/browserstack-service/src/instrumentation/performance/performance-tester.ts

@@ -18,6 +18,18 @@ import type { CsvWriter } from 'csv-writer/src/lib/csv-writer.js'
 import type { ObjectMap } from 'csv-writer/src/lib/lang/object.js'
 import type { Browser } from 'webdriverio'
 
+// Telemetry must never throw into business logic. Node 18's perf_hooks rejects
+// negative timestamps (e.g. performance.now() under faked timers, or any other
+// edge) with ERR_PERFORMANCE_INVALID_TIMESTAMP; Node 20+ tolerates them. Wrapping
+// mark/measure keeps an instrumentation failure from breaking a caller's hook
+// (e.g. a service before()), and is a no-op on the happy path.
+function safeMark(markName: string) {
+    try { performance.mark(markName) } catch { /* instrumentation must not throw */ }
+}
+function safeMeasure(measureName: string, start: string, end: string) {
+    try { performance.measure(measureName, start, end) } catch { /* instrumentation must not throw */ }
+}
+
 type PerformanceDetails = {
     success?: true,
     failure?: string,
@@ -224,7 +236,7 @@ export default class PerformanceTester {
         const endMark = `${label}-end-${uniqueId}`
 
         // Create the start mark with unique ID
-        performance.mark(startMark)
+        safeMark(startMark)
 
         // Store details with measurement context
         const detailsWithContext = {
@@ -240,8 +252,8 @@ export default class PerformanceTester {
                     returnVal
                         .then(v => {
                             // Use specific marks for this call
-                            performance.mark(endMark)
-                            performance.measure(label, startMark, endMark)
+                            safeMark(endMark)
+                            safeMeasure(label, startMark, endMark)
 
                             this.details[label] = Object.assign({
                                 success: true,
@@ -255,8 +267,8 @@ export default class PerformanceTester {
 
                             resolve(v)
                         }).catch(e => {
-                            performance.mark(endMark)
-                            performance.measure(label, startMark, endMark)
+                            safeMark(endMark)
+                            safeMeasure(label, startMark, endMark)
 
                             this.details[label] = Object.assign({
                                 success: false,
@@ -274,8 +286,8 @@ export default class PerformanceTester {
             }
 
             // Synchronous execution
-            performance.mark(endMark)
-            performance.measure(label, startMark, endMark)
+            safeMark(endMark)
+            safeMeasure(label, startMark, endMark)
 
             this.details[label] = Object.assign({
                 success: true,
@@ -289,8 +301,8 @@ export default class PerformanceTester {
 
             return returnVal
         } catch (er) {
-            performance.mark(endMark)
-            performance.measure(label, startMark, endMark)
+            safeMark(endMark)
+            safeMeasure(label, startMark, endMark)
 
             this.details[label] = Object.assign({
                 success: false,
@@ -309,13 +321,13 @@ export default class PerformanceTester {
     static start(event: string) {
         const finalEvent = event + '-start'
         if (this.eventsMap[finalEvent]) {return}
-        performance.mark(finalEvent)
+        safeMark(finalEvent)
         this.eventsMap[finalEvent] = 1
     }
 
     static end(event: string, success = true, failure?: string | unknown, details = {}) {
-        performance.mark(event + '-end')
-        performance.measure(event, event + '-start', event + '-end')
+        safeMark(event + '-end')
+        safeMeasure(event, event + '-start', event + '-end')
         // Clear the start-mark guard so a subsequent start(event) for the same
         // event actually marks a new start. Without this, start() short-circuits
         // and the next end() measures from the original start mark — inflated

packages/browserstack-service/src/util.ts

@@ -1454,10 +1454,14 @@ export async function uploadLogs(user: string | undefined, key: string | undefin
         })
 
         const formData = new FormData()
-        // openAsBlob returns a Blob backed by a file descriptor — undici streams
-        // from disk during the upload instead of materialising the full archive
+        // openAsBlob (Node >=20) returns a Blob backed by a file descriptor — undici
+        // streams from disk during the upload instead of materialising the full archive
         // in V8 heap (which readFileSync + new Blob([Buffer]) would do twice).
-        const file = await fs.openAsBlob(tarGzPath, { type: 'application/x-gzip' })
+        // Node 18.20 (still supported per `engines`) lacks fs.openAsBlob, so fall back
+        // to reading the (small) log archive into a Blob there.
+        const file = typeof fs.openAsBlob === 'function'
+            ? await fs.openAsBlob(tarGzPath, { type: 'application/x-gzip' })
+            : new Blob([fs.readFileSync(tarGzPath)], { type: 'application/x-gzip' })
         formData.append('data', file, 'logs.tar.gz')
         formData.append('clientBuildUuid', clientBuildUuid)
 

packages/browserstack-service/tests/util.test.ts

@@ -68,7 +68,11 @@ const log = logger('test')
 
 vi.mock('fetch')
 vi.mock('git-repo-info')
-vi.useFakeTimers().setSystemTime(new Date('2020-01-01'))
+// Fake only Date (not `performance`): these tests need a deterministic system
+// clock but never advance timers. Faking `performance` too makes performance.now()
+// negative under the 2020 system time, which Node 18's perf_hooks rejects with
+// ERR_PERFORMANCE_INVALID_TIMESTAMP (Node 20+ tolerates it). Mirrors reporter.test.ts.
+vi.useFakeTimers({ toFake: ['Date'] }).setSystemTime(new Date('2020-01-01'))
 vi.mock('@wdio/logger', () => import(path.join(process.cwd(), '__mocks__', '@wdio/logger')))
 
 // Mock testHub utilities