@posthog/core 1.48.11 → 1.49.0

package/dist/utils/index.mjs

@@ -16,6 +16,18 @@ function isValidUUID(value) {
 function getEventUuid(uuid, generateUuid) {
     return isValidUUID(uuid) ? uuid : generateUuid();
 }
+function createNamedError(name, message) {
+    const error = new Error(message);
+    try {
+        Object.defineProperty(error, 'name', {
+            value: name,
+            writable: true,
+            enumerable: true,
+            configurable: true
+        });
+    } catch  {}
+    return error;
+}
 function assert(truthyValue, message) {
     if (!truthyValue || 'string' != typeof truthyValue || isEmpty(truthyValue)) throw new Error(message);
 }
@@ -88,4 +100,4 @@ function allSettled(promises) {
                 reason
             }))));
 }
-export { STRING_FORMAT, UUID_REGEX, allSettled, assert, currentISOTime, currentTimestamp, getEventUuid, getFetch, isPromise, isValidUUID, raceWithTimeout, removeTrailingSlash, retriable, safeSetTimeout, stripUrlHash, toJsonSafeValue };
+export { STRING_FORMAT, UUID_REGEX, allSettled, assert, createNamedError, currentISOTime, currentTimestamp, getEventUuid, getFetch, isPromise, isValidUUID, raceWithTimeout, removeTrailingSlash, retriable, safeSetTimeout, stripUrlHash, toJsonSafeValue };

package/dist/vendor/uuidv7.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uuidv7.d.ts","sourceRoot":"","sources":["../../src/vendor/uuidv7.ts"],"names":[],"mappings":"AAaA,iDAAiD;AACjD,qBAAa,IAAI;IAEK,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC;IADxD,4DAA4D;IAC5D,OAAO;IAEP;;;;;;;;OAQG;IACH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,IAAI;IAQjD;;;;;;;;OAQG;IACH,MAAM,CAAC,YAAY,CACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,IAAI;IAsCP;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IA8ChC;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAYlB;;;OAGG;IACH,KAAK,IAAI,MAAM;IASf,2EAA2E;IAC3E,MAAM,IAAI,MAAM;IAIhB;;;;;;;OAOG;IACH,UAAU,IACN,OAAO,GACP,QAAQ,GACR,SAAS,GACT,cAAc,GACd,KAAK,GACL,KAAK;IAiBT;;;OAGG;IACH,UAAU,IAAI,MAAM,GAAG,SAAS;IAIhC,qCAAqC;IACrC,KAAK,IAAI,IAAI;IAIb,uDAAuD;IACvD,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO;IAI5B;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM;CAS/B;AAED;;;;;;;;GAQG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,OAAO,CAAK;IAEpB,yDAAyD;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAElD;;;;OAIG;gBACS,qBAAqB,CAAC,EAAE;QAClC,gDAAgD;QAChD,UAAU,IAAI,MAAM,CAAC;KACtB;IAID;;;;;;;;;;;;;OAaG;IACH,QAAQ,IAAI,IAAI;IAIhB;;;;;;;;;;;;OAYG;IACH,eAAe,IAAI,IAAI,GAAG,SAAS;IAInC;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,IAAI;IAUtE;;;;;;;;;;OAUG;IACH,mBAAmB,CACjB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,MAAM,GACxB,IAAI,GAAG,SAAS;IAqCnB,0DAA0D;IAC1D,OAAO,CAAC,YAAY;IAKpB;;;;OAIG;IACH,UAAU,IAAI,IAAI;CAanB;AAoDD;;;;;GAKG;AACH,eAAO,MAAM,MAAM,QAAO,MAAgC,CAAC;AAE3D,iCAAiC;AACjC,eAAO,MAAM,SAAS,QAAO,IAC4C,CAAC;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,MAAM,QAAO,MAAgC,CAAC;AAE3D,iCAAiC;AACjC,eAAO,MAAM,SAAS,QAAO,IAC8C,CAAC"}
+{"version":3,"file":"uuidv7.d.ts","sourceRoot":"","sources":["../../src/vendor/uuidv7.ts"],"names":[],"mappings":"AAaA,iDAAiD;AACjD,qBAAa,IAAI;IAEK,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC;IADxD,4DAA4D;IAC5D,OAAO;IAEP;;;;;;;;OAQG;IACH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,IAAI;IAQjD;;;;;;;;OAQG;IACH,MAAM,CAAC,YAAY,CACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,IAAI;IAsCP;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IA8ChC;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAYlB;;;OAGG;IACH,KAAK,IAAI,MAAM;IASf,2EAA2E;IAC3E,MAAM,IAAI,MAAM;IAIhB;;;;;;;OAOG;IACH,UAAU,IACN,OAAO,GACP,QAAQ,GACR,SAAS,GACT,cAAc,GACd,KAAK,GACL,KAAK;IAiBT;;;OAGG;IACH,UAAU,IAAI,MAAM,GAAG,SAAS;IAIhC,qCAAqC;IACrC,KAAK,IAAI,IAAI;IAIb,uDAAuD;IACvD,MAAM,CAAC,KAAK,EAAE,IAAI,GAAG,OAAO;IAI5B;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM;CAS/B;AAED;;;;;;;;GAQG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,OAAO,CAAK;IAEpB,yDAAyD;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAElD;;;;OAIG;gBACS,qBAAqB,CAAC,EAAE;QAClC,gDAAgD;QAChD,UAAU,IAAI,MAAM,CAAC;KACtB;IAID;;;;;;;;;;;;;OAaG;IACH,QAAQ,IAAI,IAAI;IAIhB;;;;;;;;;;;;OAYG;IACH,eAAe,IAAI,IAAI,GAAG,SAAS;IAInC;;;;;;;;;;OAUG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,IAAI;IAUtE;;;;;;;;;;OAUG;IACH,mBAAmB,CACjB,QAAQ,EAAE,MAAM,EAChB,iBAAiB,EAAE,MAAM,GACxB,IAAI,GAAG,SAAS;IAqCnB,0DAA0D;IAC1D,OAAO,CAAC,YAAY;IAKpB;;;;OAIG;IACH,UAAU,IAAI,IAAI;CAanB;AA0DD;;;;;GAKG;AACH,eAAO,MAAM,MAAM,QAAO,MAAgC,CAAC;AAE3D,iCAAiC;AACjC,eAAO,MAAM,SAAS,QAAO,IAC4C,CAAC;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,MAAM,QAAO,MAAgC,CAAC;AAE3D,iCAAiC;AACjC,eAAO,MAAM,SAAS,QAAO,IAC8C,CAAC"}

package/dist/vendor/uuidv7.js

@@ -193,7 +193,7 @@ class V7Generator {
     }
 }
 const getDefaultRandom = ()=>({
-        nextUint32: ()=>0x10000 * Math.trunc(0x10000 * Math.random()) + Math.trunc(0x10000 * Math.random())
+        nextUint32: ()=>0x10000 * Math.trunc(0x10000 * Math.random()) + Math.trunc(0x10000 * Math.random()) >>> 0
     });
 let defaultGenerator;
 const uuidv7 = ()=>uuidv7obj().toString();

package/dist/vendor/uuidv7.mjs

@@ -160,7 +160,7 @@ class V7Generator {
     }
 }
 const getDefaultRandom = ()=>({
-        nextUint32: ()=>0x10000 * Math.trunc(0x10000 * Math.random()) + Math.trunc(0x10000 * Math.random())
+        nextUint32: ()=>0x10000 * Math.trunc(0x10000 * Math.random()) + Math.trunc(0x10000 * Math.random()) >>> 0
     });
 let defaultGenerator;
 const uuidv7 = ()=>uuidv7obj().toString();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/core",
-  "version": "1.48.11",
+  "version": "1.49.0",
   "bugs": {
     "url": "https://github.com/PostHog/posthog-js/issues"
   },
@@ -70,7 +70,7 @@
     }
   },
   "dependencies": {
-    "@posthog/types": "^1.405.3"
+    "@posthog/types": "^1.407.0"
   },
   "devDependencies": {
     "@rslib/core": "0.10.6",

package/src/featureFlagLocalEvaluation.ts

@@ -185,8 +185,8 @@ export function matchFeatureFlagProperty(
   const operator = property.operator || 'exact'
   const parsingPolicy = options.semverParsingPolicy ?? 'strict'
 
-  if (!(key in propertyValues)) {
-    if (operator === 'is_not_set') return true
+  const hasProperty = Object.prototype.hasOwnProperty.call(propertyValues, key)
+  if (!hasProperty) {
     throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`)
   } else if (operator === 'is_not_set') {
     return false
@@ -219,7 +219,7 @@ export function matchFeatureFlagProperty(
     case 'is_not':
       return !computeExactMatch(value, overrideValue)
     case 'is_set':
-      return key in propertyValues
+      return true
     case 'icontains':
       return String(overrideValue).toLowerCase().includes(String(value).toLowerCase())
     case 'not_icontains':

package/src/gzip.ts

@@ -1,4 +1,5 @@
 import { Compression } from './types'
+import { createNamedError } from './utils'
 
 /**
  * Older browsers and some runtimes don't support this yet
@@ -88,9 +89,7 @@ const crc32 = (bytes: Uint8Array): number => {
 }
 
 const throwNativeGzipValidationError = (reason: NativeGzipValidationReason): never => {
-  const error = new Error(`Native gzip produced invalid output: ${reason}`)
-  error.name = NATIVE_GZIP_VALIDATION_ERROR
-  throw error
+  throw createNamedError(NATIVE_GZIP_VALIDATION_ERROR, `Native gzip produced invalid output: ${reason}`)
 }
 
 const validateNativeGzip = async (compressed: Blob, inputBytes: Uint8Array): Promise<void> => {

package/src/logs/index.spec.ts

@@ -171,6 +171,167 @@ describe('PostHogLogs', () => {
     expect(logs).toBeDefined()
   })
 
+  describe('clearQueue', () => {
+    it('does not let an in-flight batch drop records captured after the clear', async () => {
+      let releaseSend: (v: any) => void = () => {}
+      const mockInstance = createMockInstance({
+        _sendLogsBatch: jest.fn(() => new Promise((resolve) => (releaseSend = resolve))),
+      })
+      const logs = new PostHogLogs(
+        mockInstance,
+        resolveForTest(),
+        logger,
+        getContextFor(mockInstance),
+        immediateOnReady
+      )
+      logs.captureLog({ body: 'before the clear' })
+
+      const flushing = logs.flush()
+      logs.clearQueue()
+      logs.captureLog({ body: 'captured after the clear' })
+
+      releaseSend({ kind: 'ok' })
+      await flushing
+
+      expect(readQueue(mockInstance).map((e) => e.record.body)).toEqual([{ stringValue: 'captured after the clear' }])
+    })
+  })
+
+  describe('a 413 retry that lands after the queue is cleared', () => {
+    it('does not re-send records the clear purged', async () => {
+      const sentBodies: string[][] = []
+      let releaseSend: (v: any) => void = () => {}
+      const mockInstance = createMockInstance({
+        _sendLogsBatch: jest.fn((payload: any) => {
+          sentBodies.push(payload.resourceLogs[0].scopeLogs[0].logRecords.map((r: any) => r.body.stringValue))
+          // Only the first send is held open; any retry resolves at once so a
+          // regression fails on the assertion rather than by hanging the test.
+          return sentBodies.length === 1
+            ? new Promise((resolve) => (releaseSend = resolve))
+            : Promise.resolve({ kind: 'ok' })
+        }),
+      })
+      const logs = new PostHogLogs(
+        mockInstance,
+        resolveForTest(),
+        logger,
+        getContextFor(mockInstance),
+        immediateOnReady
+      )
+      logs.captureLog({ body: 'purged one' })
+      logs.captureLog({ body: 'purged two' })
+
+      const flushing = logs.flush()
+      logs.clearQueue()
+      // A 413 makes `_flushInner` retry the same records with a smaller batch cap.
+      releaseSend({ kind: 'too-large' })
+      await flushing
+
+      expect(sentBodies).toEqual([['purged one', 'purged two']])
+    })
+  })
+
+  describe('a clear that lands between two batches of one flush', () => {
+    it('still advances the batch assembled after the clear', async () => {
+      const sent: string[][] = []
+      let releasePersist: (() => void) | null = null
+      const mockInstance = createMockInstance({
+        _sendLogsBatch: jest.fn((payload: any) => {
+          sent.push(payload.resourceLogs[0].scopeLogs[0].logRecords.map((r: any) => r.body.stringValue))
+          return Promise.resolve({ kind: 'ok' })
+        }),
+      })
+      const logs = new PostHogLogs(
+        mockInstance,
+        resolveForTest({ maxBatchRecordsPerPost: 1 }),
+        logger,
+        getContextFor(mockInstance),
+        immediateOnReady,
+        () => new Promise<void>((resolve) => (releasePersist = resolve))
+      )
+      logs.captureLog({ body: 'a' })
+      logs.captureLog({ body: 'b' })
+
+      const flushing = logs.flush()
+      // Let batch ['a'] send and park inside the persist await between batches.
+      for (let i = 0; i < 10; i++) {
+        await Promise.resolve()
+      }
+      logs.clearQueue()
+      logs.captureLog({ body: 'c' })
+      // Each batch installs a fresh persist gate; release whichever is pending until
+      // the flush drains.
+      for (let i = 0; i < 20; i++) {
+        const pending = releasePersist
+        releasePersist = null
+        pending?.()
+        await Promise.resolve()
+      }
+      await flushing
+
+      expect({ sent, queue: readQueue(mockInstance).map((e) => e.record.body.stringValue) }).toEqual({
+        sent: [['a'], ['c']],
+        queue: [],
+      })
+    })
+  })
+
+  describe('reset during an in-flight flush', () => {
+    it('does not let an in-flight batch drop records captured after the reset', async () => {
+      let releaseSend: (v: any) => void = () => {}
+      const mockInstance = createMockInstance({
+        _sendLogsBatch: jest.fn(() => new Promise((resolve) => (releaseSend = resolve))),
+      })
+      const logs = new PostHogLogs(
+        mockInstance,
+        resolveForTest(),
+        logger,
+        getContextFor(mockInstance),
+        immediateOnReady
+      )
+      logs.captureLog({ body: 'before the reset' })
+
+      const flushing = logs.flush()
+      logs.clearQueue()
+      logs.reset()
+      logs.captureLog({ body: 'captured after the reset' })
+
+      releaseSend({ kind: 'ok' })
+      await flushing
+
+      expect(readQueue(mockInstance).map((e) => e.record.body)).toEqual([{ stringValue: 'captured after the reset' }])
+    })
+
+    it('does not let a flush started after the reset run alongside the in-flight one', async () => {
+      let releaseSend: (v: any) => void = () => {}
+      const mockInstance = createMockInstance({
+        _sendLogsBatch: jest.fn(() => new Promise((resolve) => (releaseSend = resolve))),
+      })
+      const logs = new PostHogLogs(
+        mockInstance,
+        resolveForTest(),
+        logger,
+        getContextFor(mockInstance),
+        immediateOnReady
+      )
+      logs.captureLog({ body: 'before the reset' })
+
+      const flushing = logs.flush()
+      logs.clearQueue()
+      logs.reset()
+      logs.captureLog({ body: 'captured after the reset' })
+      const second = logs.flush()
+
+      expect(mockInstance._sendLogsBatch).toHaveBeenCalledTimes(1)
+
+      releaseSend({ kind: 'ok' })
+      await flushing
+      await second
+
+      expect(readQueue(mockInstance).map((e) => e.record.body)).toEqual([{ stringValue: 'captured after the reset' }])
+    })
+  })
+
   describe('captureLog', () => {
     it('writes a record to the logs queue via setPersistedProperty', () => {
       const logs = new PostHogLogs(
@@ -191,6 +352,29 @@ describe('PostHogLogs', () => {
       )
     })
 
+    it('stamps a record from `capturedAt` rather than live state', () => {
+      const logs = new PostHogLogs(
+        mockInstance,
+        resolveForTest(),
+        logger,
+        getContextFor(mockInstance),
+        immediateOnReady
+      )
+      const occurredAtMs = Date.now() - 5000
+
+      logs.captureLog(
+        { body: 'buffered before identify' },
+        { context: { distinctId: 'anon-1', sessionId: 'session-1' }, occurredAtMs }
+      )
+
+      const [{ record }] = readQueue(mockInstance)
+      const attributes = Object.fromEntries(record.attributes.map((a: any) => [a.key, a.value.stringValue]))
+      expect(attributes.posthogDistinctId).toBe('anon-1')
+      expect(attributes.sessionId).toBe('session-1')
+      expect(record.timeUnixNano).toBe(String(occurredAtMs) + '000000')
+      expect(record.observedTimeUnixNano).toBe(record.timeUnixNano)
+    })
+
     it('maps severity levels correctly', () => {
       const logs = new PostHogLogs(
         mockInstance,

package/src/logs/index.ts

@@ -24,6 +24,9 @@ export class PostHogLogs {
   // Head records evicted (FIFO) while a batch is in flight; the queue-advance
   // subtracts these so it drops the sent records, not ones captured mid-send.
   private _evictedSinceAdvance = 0
+  // A batch captures this when it is assembled, so it can tell that the records it is
+  // holding no longer correspond to anything queued.
+  private _queueGeneration = 0
   // Consecutive failed flushes; drives exponential backoff on the retry timer.
   // A successful flush resets it to 0.
   private _consecutiveFlushFailures = 0
@@ -65,17 +68,28 @@ export class PostHogLogs {
     this._maxLogsPerInterval = _config.maxLogsPerInterval
   }
 
+  /**
+   * Drops every queued record. A batch this instance has in flight is retired with
+   * them, so it can neither re-send what was just purged nor advance past records
+   * captured after this call.
+   */
+  clearQueue(): void {
+    this._queueGeneration++
+    this._instance.setPersistedProperty(PostHogPersistedProperty.LogsQueue, [])
+  }
+
   /**
    * Clears the flush timer and rate-cap state. The host owns the record queue
    * and clears it separately (the browser empties its in-memory store).
    */
   reset(): void {
     this._clearFlushTimer()
-    this._flushPromise = null
+    // `_flushPromise` is deliberately left alone: clearing it would let a second flush
+    // run alongside the in-flight one. Retiring that flush is `clearQueue`'s job,
+    // because the queue it holds belongs to the host, not to this state.
     this._intervalWindowStart = 0
     this._intervalLogCount = 0
     this._droppedWarned = false
-    this._evictedSinceAdvance = 0
     this._consecutiveFlushFailures = 0
     this._maxBatchRecordsPerPost = this._config.maxBatchRecordsPerPost
   }
@@ -88,7 +102,14 @@ export class PostHogLogs {
     this._flushInBackground()
   }
 
-  captureLog(options: CaptureLogOptions): void {
+  /**
+   * Captures one log record.
+   *
+   * @param capturedAt State snapshotted when the event occurred, for a caller that
+   * observes an event earlier than it can build the record. Defaults to the identity,
+   * session and flags as of now.
+   */
+  captureLog(options: CaptureLogOptions, capturedAt?: { context?: LogSdkContext; occurredAtMs?: number }): void {
     if (this._instance.isDisabled) {
       return
     }
@@ -119,7 +140,12 @@ export class PostHogLogs {
     // Build before deferring so attributes reflect state at capture time, not
     // at drain time (identity/session changes between capture and drain must
     // not corrupt recorded attributes).
-    const record = buildOtlpLogRecord(filtered, this._getContext(), this._logger)
+    const record = buildOtlpLogRecord(
+      filtered,
+      capturedAt?.context ?? this._getContext(),
+      this._logger,
+      capturedAt?.occurredAtMs
+    )
     const entry: BufferedLogEntry = { record }
 
     this._onReady(() => this._enqueue(entry))
@@ -233,6 +259,10 @@ export class PostHogLogs {
     let sentCount = 0
 
     while (queue.length > 0 && sentCount < originalQueueLength) {
+      // Captured per batch, not per flush: a clear that lands between batches leaves
+      // the next one assembled from an already-fresh queue, so that batch advances
+      // normally instead of being retired for a purge it never held.
+      const generation = this._queueGeneration
       // Reset per batch so the advance below counts only evictions during THIS
       // batch's send. Evictions during the persist await or between iterations
       // are already reflected in the next iteration's queue read, so they must
@@ -252,6 +282,13 @@ export class PostHogLogs {
 
       const outcome = await this._instance._sendLogsBatch(payload)
 
+      if (this._queueGeneration !== generation) {
+        // The queue was cleared while this batch was in flight. `queue` is a stale local
+        // copy, so retrying it would re-send purged records and advancing it would slice
+        // records captured since. Retire the batch instead.
+        return
+      }
+
       if (outcome.kind === 'too-large' && batch.length > 1) {
         this._maxBatchRecordsPerPost = Math.max(1, Math.floor(batch.length / 2))
         this._logger.warn(

package/src/logs/logs-utils.spec.ts

@@ -467,6 +467,30 @@ describe('logs-utils', () => {
       expect(record.observedTimeUnixNano).toBe(record.timeUnixNano)
     })
 
+    it('stamps both timestamps from the event time when the record is built late', () => {
+      const occurredAtMs = Date.now() - 5000
+      const record = buildOtlpLogRecord({ body: 'buffered' }, minimalSdkContext, undefined, occurredAtMs)
+
+      expect(record.timeUnixNano).toBe(String(occurredAtMs) + '000000')
+      // The logs spec requires the client to keep the two equal.
+      expect(record.observedTimeUnixNano).toBe(record.timeUnixNano)
+    })
+
+    it.each([undefined, NaN, 'nope' as unknown as number])(
+      'falls back to now when the event time is %p',
+      (occurredAtMs) => {
+        const before = Date.now()
+        const record = buildOtlpLogRecord({ body: 'x' }, minimalSdkContext, undefined, occurredAtMs)
+        // Divide and the 19-digit nanosecond value loses its last digits to float.
+        const stampedMs = Number(record.timeUnixNano.slice(0, -6))
+
+        expect(record.timeUnixNano).toMatch(/^\d+000000$/)
+        expect(stampedMs).toBeGreaterThanOrEqual(before)
+        expect(stampedMs).toBeLessThanOrEqual(Date.now())
+        expect(record.observedTimeUnixNano).toBe(record.timeUnixNano)
+      }
+    )
+
     it('maps severity levels correctly', () => {
       const record = buildOtlpLogRecord({ body: 'test', level: 'error' }, minimalSdkContext)
       expect(record.severityText).toBe('ERROR')

package/src/logs/logs-utils.ts

@@ -11,7 +11,7 @@ import type {
 } from '@posthog/types'
 import type { Logger } from '../types'
 import type { LogSdkContext, ResolvedPostHogLogsConfig } from './types'
-import { isArray, isBoolean, isNull, isNullish, isUndefined } from '../utils'
+import { isArray, isBoolean, isNull, isNullish, isNumber, isUndefined } from '../utils'
 import {
   CIRCULAR_VALUE,
   FUNCTION_VALUE,
@@ -245,14 +245,14 @@ function encodeKeyValueList(
 // ============================================================================
 
 /**
- * Returns the current wall-clock time as a unix-nanos string.
+ * Returns `timestampMs` (default: now) as a unix-nanos string.
  *
  * OTLP requires nanoseconds as a string (uint64 doesn't fit in JS Number).
  * `Date.now() * 1_000_000` would exceed Number.MAX_SAFE_INTEGER, so we
  * concatenate instead of multiplying.
  */
-function timestampToUnixNano(): string {
-  return String(Date.now()) + '000000'
+function timestampToUnixNano(timestampMs: number = Date.now()): string {
+  return String(timestampMs) + '000000'
 }
 
 /**
@@ -264,6 +264,10 @@ function timestampToUnixNano(): string {
  * `screenName` / `appState`), so a missing field never adds a stray attribute.
  *
  * User-provided `options.attributes` always wins on conflicts.
+ *
+ * `occurredAtMs` is when the event happened, for a host that records an event earlier
+ * than it can build the record; it stamps both OTLP timestamps, which the logs spec
+ * requires to be equal.
  */
 // `body` is only typed as a string. An untyped caller — or a `beforeSend` that
 // rewrites it — can pass anything, and `String()` throws on a value whose
@@ -279,11 +283,12 @@ function encodeBody(body: string): string {
 export function buildOtlpLogRecord(
   options: CaptureLogOptions,
   sdkContext: LogSdkContext,
-  logger?: Logger
+  logger?: Logger,
+  occurredAtMs?: number
 ): OtlpLogRecord {
   const level: LogSeverityLevel = options.level || 'info'
   const { text: severityText, number: severityNumber } = OTLP_SEVERITY_MAP[level] || DEFAULT_OTLP_SEVERITY
-  const now = timestampToUnixNano()
+  const eventTimeNano = timestampToUnixNano(isNumber(occurredAtMs) ? occurredAtMs : undefined)
 
   const autoAttributes: Record<string, LogAttributeValue> = {}
 
@@ -340,8 +345,8 @@ export function buildOtlpLogRecord(
   }
 
   const record: OtlpLogRecord = {
-    timeUnixNano: now,
-    observedTimeUnixNano: now,
+    timeUnixNano: eventTimeNano,
+    observedTimeUnixNano: eventTimeNano,
     severityNumber,
     severityText,
     body: { stringValue: encodeBody(options.body) },

package/src/posthog-core-stateless.ts

@@ -27,6 +27,7 @@ import {
 } from './types'
 import {
   allSettled,
+  createNamedError,
   currentISOTime,
   PromiseQueue,
   removeTrailingSlash,
@@ -76,16 +77,14 @@ class PostHogFetchHttpError extends Error {
     if (!this.responseBodyTextPromise) {
       if (Date.now() >= this.responseBodyDeadline) {
         this._bodyReadTimedOut = true
-        const timeoutError = new Error('Response body read timed out')
-        timeoutError.name = 'AbortError'
+        const timeoutError = createNamedError('AbortError', 'Response body read timed out')
         this.cancelResponseBody(timeoutError)
         this.responseBodyTextPromise = Promise.reject(timeoutError)
       } else {
         const responseBodyTimeout = new Promise<never>((_resolve, reject) => {
           this.responseBodyTimer = safeSetTimeout(() => {
             this._bodyReadTimedOut = true
-            const timeoutError = new Error('Response body read timed out')
-            timeoutError.name = 'AbortError'
+            const timeoutError = createNamedError('AbortError', 'Response body read timed out')
             // Reject first so the timeout remains the diagnostic if abort rejects the body read synchronously.
             reject(timeoutError)
             this.cancelResponseBody(timeoutError)
@@ -1768,8 +1767,7 @@ export abstract class PostHogCoreStateless {
         // relying only on standards-compliant AbortSignal behavior.
         const deadline = new Promise<never>((_resolve, reject) => {
           timer = safeSetTimeout(() => {
-            const timeoutError = new Error(`Request timed out after ${timeoutMs}ms`)
-            timeoutError.name = 'AbortError'
+            const timeoutError = createNamedError('AbortError', `Request timed out after ${timeoutMs}ms`)
             // Reject first so this error wins if an abort-aware injected fetch rejects synchronously.
             reject(timeoutError)
             ctrl.abort(timeoutError)

package/src/utils/index.ts

@@ -25,6 +25,27 @@ export function getEventUuid(uuid: unknown, generateUuid: () => string): string
   return isValidUUID(uuid) ? uuid : generateUuid()
 }
 
+/**
+ * Creates an `Error` with the given `name`, in a way that also holds on pages where a browser
+ * extension has made `Error.prototype.name` non-writable. A plain `error.name = ...` throws
+ * there in strict mode, and swallowing that throw leaves the name as `Error`. Defining an own
+ * property on the instance shadows the prototype property instead. The descriptor matches what
+ * a plain assignment produces, so the resulting error is unchanged everywhere else.
+ *
+ * @param name the value for `error.name`, e.g. `'AbortError'`
+ * @param message the error message
+ * @internal Exposed for cross-package use within this SDK; not part of the stable public API.
+ */
+export function createNamedError(name: string, message?: string): Error {
+  const error = new Error(message)
+  try {
+    Object.defineProperty(error, 'name', { value: name, writable: true, enumerable: true, configurable: true })
+  } catch {
+    // a page hostile enough to harden `Error.prototype` can also patch `Object.defineProperty`
+  }
+  return error
+}
+
 export function assert(truthyValue: any, message: string): void {
   if (!truthyValue || typeof truthyValue !== 'string' || isEmpty(truthyValue)) {
     throw new Error(message)

package/src/utils/named-error.spec.ts

@@ -0,0 +1,36 @@
+import { createNamedError } from './index'
+
+describe('createNamedError', () => {
+  it('sets the name and message', () => {
+    const error = createNamedError('AbortError', 'timed out')
+    expect(error.name).toBe('AbortError')
+    expect(error.message).toBe('timed out')
+  })
+
+  it('defines name with the same descriptor a plain assignment would produce', () => {
+    const error = createNamedError('AbortError', 'timed out')
+    expect(Object.getOwnPropertyDescriptor(error, 'name')).toEqual({
+      value: 'AbortError',
+      writable: true,
+      enumerable: true,
+      configurable: true,
+    })
+  })
+
+  it('preserves the name when Error.prototype.name is non-writable', () => {
+    const descriptor = Object.getOwnPropertyDescriptor(Error.prototype, 'name') ?? {
+      value: 'Error',
+      writable: true,
+      enumerable: false,
+      configurable: true,
+    }
+    Object.defineProperty(Error.prototype, 'name', { value: 'Error', writable: false, configurable: true })
+    try {
+      const error = createNamedError('AbortError', 'timed out')
+      expect(error.name).toBe('AbortError')
+      expect(error.message).toBe('timed out')
+    } finally {
+      Object.defineProperty(Error.prototype, 'name', descriptor)
+    }
+  })
+})

package/src/vendor/uuidv7.spec.ts

@@ -0,0 +1,26 @@
+import { V7Generator } from './uuidv7'
+
+describe('uuidv7 default RNG', () => {
+  const realRandom = Math.random
+
+  afterEach(() => {
+    Math.random = realRandom
+  })
+
+  it.each([
+    ['exactly 1.0', 1.0],
+    ['greater than 1', 1.5],
+    ['NaN', NaN],
+  ])('does not throw when Math.random() returns %s', (_label, value) => {
+    Math.random = () => value
+    const generator = new V7Generator()
+    const uuid = generator.generate().toString()
+    expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/)
+  })
+
+  it('still generates well-formed v7 UUIDs with the real Math.random', () => {
+    const generator = new V7Generator()
+    const uuid = generator.generate().toString()
+    expect(uuid).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/)
+  })
+})

package/src/vendor/uuidv7.ts

@@ -429,9 +429,15 @@ const getDefaultRandom = (): { nextUint32(): number } => {
 //     };
 //   }
   return {
+    // Clamp to a valid uint32: a nonconformant Math.random() that returns >= 1 or NaN
+    // (e.g. Hermes on Android implements Math.random with C++ std::uniform_real_distribution,
+    // which is documented to occasionally return its upper bound) would otherwise overflow the
+    // field ranges and make fromFieldsV7 throw `RangeError: invalid field value` on every
+    // generate call, crashing React Native apps during the internal event-queue flush.
     nextUint32: (): number =>
-      Math.trunc(Math.random() * 0x1_0000) * 0x1_0000 +
-      Math.trunc(Math.random() * 0x1_0000),
+      (Math.trunc(Math.random() * 0x1_0000) * 0x1_0000 +
+        Math.trunc(Math.random() * 0x1_0000)) >>>
+      0,
   };
 };