@zuplo/cli 7.4.4 → 7.4.6

package/node_modules/@posthog/core/src/logs/logs-utils.ts

@@ -9,8 +9,19 @@ import type {
   OtlpSeverityEntry,
   OtlpSeverityText,
 } from '@posthog/types'
+import type { Logger } from '../types'
 import type { LogSdkContext, ResolvedPostHogLogsConfig } from './types'
 import { isArray, isBoolean, isNull, isNullish, isUndefined } from '../utils'
+import {
+  CIRCULAR_VALUE,
+  FUNCTION_VALUE,
+  MAX_JSON_SAFE_VALUE_DEPTH,
+  MAX_JSON_SAFE_VALUE_ITEMS,
+  MAX_JSON_SAFE_VALUE_NODES,
+  sanitizeString,
+  TRUNCATED_VALUE,
+  UNSERIALIZABLE_VALUE,
+} from '../utils/json-utils'
 
 // ============================================================================
 // Severity mapping
@@ -39,49 +50,192 @@ export function getOtlpSeverityNumber(level: LogSeverityLevel): number {
 // OTLP AnyValue conversion
 // ============================================================================
 
-export function toOtlpAnyValue(value: LogAttributeValue): OtlpAnyValue {
+// 2^63 — one past int64 max.
+const INT64_RANGE_LIMIT = 9223372036854775808
+
+const propertyIsEnumerable = Object.prototype.propertyIsEnumerable
+
+interface EncodeState {
+  /** Containers on the current path, so a back-reference becomes a marker. */
+  ancestors: WeakSet<object>
+  remainingNodes: number
+}
+
+function newState(): EncodeState {
+  return { ancestors: new WeakSet(), remainingNodes: MAX_JSON_SAFE_VALUE_NODES }
+}
+
+export function toOtlpAnyValue(value: LogAttributeValue, logger?: Logger): OtlpAnyValue {
+  try {
+    return encodeAnyValue(value, logger, newState(), 0)
+  } catch {
+    // Runs inside `captureLog` and the metrics flush: an error escaping here
+    // surfaces in the caller's own code.
+    return { stringValue: UNSERIALIZABLE_VALUE }
+  }
+}
+
+export function toOtlpKeyValueList(attrs: Record<string, LogAttributeValue>, logger?: Logger): OtlpKeyValue[] {
+  try {
+    return encodeKeyValueList(attrs, logger, newState(), 0)
+  } catch {
+    return []
+  }
+}
+
+function encodeAnyValue(
+  value: LogAttributeValue,
+  logger: Logger | undefined,
+  state: EncodeState,
+  depth: number
+): OtlpAnyValue {
+  if (state.remainingNodes <= 0) {
+    return { stringValue: TRUNCATED_VALUE }
+  }
+  state.remainingNodes--
+
   if (isBoolean(value)) {
     return { boolValue: value }
   }
-  // NOTE: typeof check (not core's isNumber) so NaN is included. core's
-  // isNumber explicitly excludes NaN via the `x === x` guard, which would
-  // route NaN through the JSON.stringify branch below — JSON has no
-  // representation for non-finite floats and JSON.stringify turns them into
-  // `null`, losing the value server-side. proto3 JSON mapping (which OTLP/HTTP
-  // rides) requires the literal strings; we encode them as stringValue to keep
-  // the human-readable signal regardless of which downstream parser sees them.
+  // typeof, not core's isNumber, which excludes NaN — proto3 JSON distinguishes
+  // a non-finite float from an ordinary string.
   if (typeof value === 'number') {
     if (!Number.isFinite(value)) {
       return { stringValue: String(value) }
     }
     if (Number.isInteger(value)) {
-      return { intValue: value }
+      if (Number.isSafeInteger(value)) {
+        return { intValue: String(value) }
+      }
+      // Past MAX_SAFE_INTEGER only BigInt gives the double's exact decimal:
+      // `String(-(2**63))` lands 192 below int64 min, outside the field it is
+      // about to be parsed into. Without BigInt the value rides as a string,
+      // which is never range-checked.
+      if (typeof BigInt === 'undefined') {
+        return { stringValue: String(value) }
+      }
+      const decimal = BigInt(value).toString()
+      if (value >= INT64_RANGE_LIMIT || value < -INT64_RANGE_LIMIT) {
+        // An out-of-range intValue 400s the whole logs request; on the metrics
+        // path it is swallowed server-side and the metric just disappears.
+        logger?.debug(`Attribute ${decimal} is outside the int64 range; encoding it as a string`)
+        return { stringValue: decimal }
+      }
+      return { intValue: decimal }
     }
     return { doubleValue: value }
   }
   if (typeof value === 'string') {
-    return { stringValue: value }
+    return { stringValue: sanitizeString(value) }
   }
-  if (isArray(value)) {
-    return { arrayValue: { values: value.map((v) => toOtlpAnyValue(v as LogAttributeValue)) } }
+  // `String(value)` would put a function's source text on the wire.
+  if (typeof value === 'function') {
+    return { stringValue: FUNCTION_VALUE }
   }
-  // Objects fall back to JSON. OTLP supports kvlistValue but the encoder
-  // stays flat for simplicity.
-  try {
-    return { stringValue: JSON.stringify(value) }
-  } catch {
+  if (typeof value === 'symbol') {
     return { stringValue: String(value) }
   }
+  if (typeof value === 'object' && value !== null) {
+    if (state.ancestors.has(value)) {
+      return { stringValue: CIRCULAR_VALUE }
+    }
+    if (depth >= MAX_JSON_SAFE_VALUE_DEPTH) {
+      return { stringValue: TRUNCATED_VALUE }
+    }
+    if (value instanceof Date) {
+      const time = value.getTime()
+      const iso = Number.isFinite(time) ? value.toISOString() : String(value)
+      // An overridden toISOString can return a non-string, which the server
+      // refuses for the whole request.
+      return { stringValue: typeof iso === 'string' ? sanitizeString(iso) : String(iso) }
+    }
+    // Registered before the toJSON probe: a toJSON returning a structure that
+    // references its own object is a cycle like any other.
+    state.ancestors.add(value)
+    try {
+      // The representation a value defines for itself — dayjs, Decimal, an ORM
+      // document, and a cross-realm Date that fails the `instanceof` above.
+      try {
+        const toJSON = (value as { toJSON?: unknown }).toJSON
+        if (typeof toJSON === 'function') {
+          return encodeAnyValue(toJSON.call(value) as LogAttributeValue, logger, state, depth + 1)
+        }
+      } catch {
+        // A throwing toJSON falls through to the plain walk.
+      }
+      if (isArray(value)) {
+        return { arrayValue: { values: encodeArrayValues(value, logger, state, depth + 1) } }
+      }
+      return {
+        kvlistValue: {
+          values: encodeKeyValueList(value as Record<string, LogAttributeValue>, logger, state, depth + 1),
+        },
+      }
+    } finally {
+      // Siblings that reference the same object are duplication, not a cycle.
+      state.ancestors.delete(value)
+    }
+  }
+  return { stringValue: sanitizeString(String(value)) }
+}
+
+function encodeArrayValues(
+  values: unknown[],
+  logger: Logger | undefined,
+  state: EncodeState,
+  depth: number
+): OtlpAnyValue[] {
+  const result: OtlpAnyValue[] = []
+  const itemCount = Math.min(values.length, MAX_JSON_SAFE_VALUE_ITEMS)
+  let index = 0
+  for (; index < itemCount && state.remainingNodes > 0; index++) {
+    try {
+      const element = index in values ? values[index] : undefined
+      // Dropped, as iOS and Android do: proto3 JSON has no null AnyValue, and
+      // both `null` and `{}` here are rejected for the whole request.
+      if (isNullish(element)) {
+        continue
+      }
+      result.push(encodeAnyValue(element as LogAttributeValue, logger, state, depth))
+    } catch {
+      result.push({ stringValue: UNSERIALIZABLE_VALUE })
+    }
+  }
+  if (values.length > index) {
+    result.push({ stringValue: TRUNCATED_VALUE })
+  }
+  return result
 }
 
-export function toOtlpKeyValueList(attrs: Record<string, LogAttributeValue>): OtlpKeyValue[] {
+function encodeKeyValueList(
+  attrs: Record<string, LogAttributeValue>,
+  logger: Logger | undefined,
+  state: EncodeState,
+  depth: number
+): OtlpKeyValue[] {
   const result: OtlpKeyValue[] = []
   for (const key in attrs) {
-    const value = attrs[key]
-    if (isNull(value) || isUndefined(value)) {
+    // for...in walks the prototype chain once own keys are exhausted. Skipped
+    // rather than broken out of: a proxy can yield keys in any order.
+    if (!propertyIsEnumerable.call(attrs, key)) {
       continue
     }
-    result.push({ key, value: toOtlpAnyValue(value) })
+    if (result.length >= MAX_JSON_SAFE_VALUE_ITEMS || state.remainingNodes <= 0) {
+      // Reported rather than written into the attributes: a synthetic key would
+      // land in the user's own namespace and could collide with a real one.
+      logger?.debug('Attributes truncated: the value exceeds the OTLP encoder budget')
+      break
+    }
+    try {
+      const value = attrs[key]
+      if (isNull(value) || isUndefined(value)) {
+        continue
+      }
+      result.push({ key: sanitizeString(key), value: encodeAnyValue(value, logger, state, depth) })
+    } catch {
+      // A getter that throws costs its own key, not the whole record.
+      result.push({ key: sanitizeString(key), value: { stringValue: UNSERIALIZABLE_VALUE } })
+    }
   }
   return result
 }
@@ -111,7 +265,22 @@ function timestampToUnixNano(): string {
  *
  * User-provided `options.attributes` always wins on conflicts.
  */
-export function buildOtlpLogRecord(options: CaptureLogOptions, sdkContext: LogSdkContext): OtlpLogRecord {
+// `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
+// `toString` does, or on a null-prototype object.
+function encodeBody(body: string): string {
+  try {
+    return sanitizeString(String(body))
+  } catch {
+    return UNSERIALIZABLE_VALUE
+  }
+}
+
+export function buildOtlpLogRecord(
+  options: CaptureLogOptions,
+  sdkContext: LogSdkContext,
+  logger?: Logger
+): OtlpLogRecord {
   const level: LogSeverityLevel = options.level || 'info'
   const { text: severityText, number: severityNumber } = OTLP_SEVERITY_MAP[level] || DEFAULT_OTLP_SEVERITY
   const now = timestampToUnixNano()
@@ -146,9 +315,28 @@ export function buildOtlpLogRecord(options: CaptureLogOptions, sdkContext: LogSd
     autoAttributes.feature_flags = sdkContext.activeFeatureFlags
   }
 
-  const mergedAttributes = {
-    ...autoAttributes,
-    ...(options.attributes || {}),
+  // Read key by key rather than spreading: a getter over a disposed store or a
+  // revoked proxy throws on the read itself, before the encoder's guards see it.
+  const mergedAttributes: Record<string, LogAttributeValue> = { ...autoAttributes }
+  const userAttributes = options.attributes
+  if (userAttributes) {
+    let keys: string[] = []
+    try {
+      keys = Object.keys(userAttributes)
+    } catch {
+      keys = []
+    }
+    for (const key of keys) {
+      let value: LogAttributeValue
+      try {
+        value = userAttributes[key]
+      } catch {
+        value = UNSERIALIZABLE_VALUE
+      }
+      // defineProperty, not assignment: `attributes['__proto__'] = v` hits the
+      // prototype setter and the attribute vanishes.
+      Object.defineProperty(mergedAttributes, key, { value, enumerable: true, writable: true, configurable: true })
+    }
   }
 
   const record: OtlpLogRecord = {
@@ -156,8 +344,8 @@ export function buildOtlpLogRecord(options: CaptureLogOptions, sdkContext: LogSd
     observedTimeUnixNano: now,
     severityNumber,
     severityText,
-    body: { stringValue: options.body },
-    attributes: toOtlpKeyValueList(mergedAttributes),
+    body: { stringValue: encodeBody(options.body) },
+    attributes: toOtlpKeyValueList(mergedAttributes, logger),
   }
 
   if (options.trace_id) {

package/node_modules/@posthog/core/src/metrics/index.spec.ts

@@ -169,10 +169,24 @@ describe('PostHogMetrics', () => {
 
       const attrs = sentMetrics()[0].sum!.dataPoints[0].attributes
       expect(attrs).toContainEqual({ key: 'route', value: { stringValue: '/home' } })
-      expect(attrs).toContainEqual({ key: 'retries', value: { intValue: 2 } })
+      expect(attrs).toContainEqual({ key: 'retries', value: { intValue: '2' } })
       expect(attrs).toContainEqual({ key: 'cached', value: { boolValue: true } })
     })
 
+    // The encoder is shared with logs, so the debug line it emits on the
+    // out-of-range path only reaches anyone if metrics passes its logger down.
+    it('encodes an out-of-int64 attribute as a string and reports it through the logger', async () => {
+      const metrics = createMetrics()
+      metrics.count('api_calls', 1, { attributes: { huge: 2 ** 63 } as any })
+      await metrics.flush()
+
+      const attrs = sentMetrics()[0].sum!.dataPoints[0].attributes
+      expect(attrs).toContainEqual({ key: 'huge', value: { stringValue: '9223372036854775808' } })
+      expect((logger.debug as jest.Mock).mock.calls.some((c) => String(c[0]).includes('outside the int64 range'))).toBe(
+        true
+      )
+    })
+
     it('stamps delta data points with a window: startTimeUnixNano <= timeUnixNano, both nano strings', async () => {
       const metrics = createMetrics()
       metrics.count('orders_created', 1)

package/node_modules/@posthog/core/src/metrics/index.ts

@@ -374,7 +374,7 @@ export class PostHogMetrics {
         byMetric.set(metricKey, metric)
       }
 
-      const attributes = toOtlpKeyValueList(state.attributes ?? {})
+      const attributes = toOtlpKeyValueList(state.attributes ?? {}, this._logger)
       const startNano = msToUnixNano(state.windowStartMs)
 
       if (state.type === 'count') {

package/node_modules/@posthog/core/src/posthog-core-stateless.ts

@@ -17,6 +17,7 @@ import {
   FeatureFlagDetail,
   SurveyResponse,
   PostHogFetchResponse,
+  PostHogFetchBodyBytes,
   PostHogFetchOptions,
   PostHogPersistedProperty,
   PostHogQueueItem,
@@ -221,13 +222,12 @@ function isPostHogEventProperties(value: JsonType | undefined): value is PostHog
 }
 
 /**
- * Outcome of a logs batch send. Keeps HTTP error classification inside core
- * (single source of truth — same policy events already use in `_flush()`) so
+ * Outcome of a logs batch send. Keeps HTTP error classification inside core so
  * PostHogLogs doesn't need to know about specific error types.
  *
  *   - ok            → records are accepted; drop them from the queue
  *   - too-large     → 413; caller should halve batch size and retry same records
- *   - retry-later   → network error; caller keeps records and retries next cycle
+ *   - retry-later   → retryable network or HTTP error; caller keeps records and retries next cycle
  *   - fatal         → anything else (auth, malformed, etc.); caller drops the
  *                     batch and surfaces the error
  */
@@ -237,6 +237,17 @@ export type SendLogsBatchOutcome =
   | { kind: 'retry-later'; error: unknown }
   | { kind: 'fatal'; error: unknown }
 
+/**
+ * Each signal keeps its own exported outcome type because each belongs to a
+ * separate host contract. The wrappers return this value directly, so one
+ * drifting out of shape fails to compile.
+ */
+type SendOtlpBatchOutcome =
+  | { kind: 'ok' }
+  | { kind: 'too-large' }
+  | { kind: 'retry-later'; error: unknown }
+  | { kind: 'fatal'; error: unknown }
+
 export enum QuotaLimitedFeature {
   FeatureFlags = 'feature_flags',
   Recordings = 'recordings',
@@ -1447,7 +1458,7 @@ export abstract class PostHogCoreStateless {
    * Compresses an outgoing payload. Runtime-specific clients can override this
    * to avoid using the Web Streams compression implementation.
    */
-  protected compressPayload(payload: string): Promise<Blob | null> {
+  protected compressPayload(payload: string): Promise<Blob | PostHogFetchBodyBytes | null> {
     return gzipCompress(payload, this.isDebug)
   }
 
@@ -1632,22 +1643,28 @@ export abstract class PostHogCoreStateless {
   }
 
   /**
-   * Sends a pre-built OTLP logs payload to `/i/v1/logs`. Returns a tagged
-   * outcome instead of throwing so PostHogLogs doesn't have to know about the
-   * core's error class hierarchy. Error classification lives here (single
-   * source of truth, same policy the events `_flush()` uses for its own
-   * 413 / network / fatal handling).
+   * Shared implementation behind the OTLP senders, which differ only in path.
+   * Returns a tagged outcome instead of throwing so the queue owners don't
+   * have to know the core's error class hierarchy.
    *
-   * 413 is passed through as `too-large` (not auto-retried) so the caller can
-   * shrink `maxBatchRecordsPerPost` and retry the same records.
+   * Exhausted 408/429/5xx stay `retry-later`, unlike the events `_flush()`
+   * which drops anything that isn't a network error: every OTLP queue is
+   * bounded and retried with backoff, so holding a batch through an outage can
+   * neither grow without limit nor spin.
    */
-  async _sendLogsBatch(payload: OtlpLogsPayload): Promise<SendLogsBatchOutcome> {
+  private async _sendOtlpBatch({
+    path,
+    payload,
+  }: {
+    path: 'logs' | 'metrics'
+    payload: OtlpLogsPayload | OtlpMetricsPayload
+  }): Promise<SendOtlpBatchOutcome> {
     if (this.disabled) {
       return { kind: 'fatal', error: new Error('The client is disabled') }
     }
 
     const serialized = JSON.stringify(payload)
-    const url = `${this.host}/i/v1/logs?token=${encodeURIComponent(this.apiKey)}`
+    const url = `${this.host}/i/v1/${path}?token=${encodeURIComponent(this.apiKey)}`
 
     const gzippedPayload = !this.disableCompression ? await this.compressPayload(serialized) : null
     const fetchOptions: PostHogFetchOptions = {
@@ -1679,65 +1696,19 @@ export abstract class PostHogCoreStateless {
       if (isPostHogFetchContentTooLargeError(err)) {
         return { kind: 'too-large' }
       }
-      if (err instanceof PostHogFetchNetworkError) {
+      if (isPostHogFetchRetryableError(err)) {
         return { kind: 'retry-later', error: err }
       }
       return { kind: 'fatal', error: err }
     }
   }
 
-  /**
-   * Sends a pre-built OTLP metrics payload to `/i/v1/metrics`. Same tagged
-   * outcome contract and error classification as `_sendLogsBatch` — this is
-   * the `MetricsHost._sendMetricsBatch` implementation, so `PostHogMetrics`
-   * can use any core-based SDK as its host.
-   */
-  async _sendMetricsBatch(payload: OtlpMetricsPayload): Promise<SendMetricsBatchOutcome> {
-    if (this.disabled) {
-      return { kind: 'fatal', error: new Error('The client is disabled') }
-    }
-
-    const serialized = JSON.stringify(payload)
-    const url = `${this.host}/i/v1/metrics?token=${encodeURIComponent(this.apiKey)}`
-
-    const gzippedPayload = !this.disableCompression ? await this.compressPayload(serialized) : null
-    const fetchOptions: PostHogFetchOptions = {
-      method: 'POST',
-      headers: {
-        ...this.getCustomHeaders(),
-        'Content-Type': 'application/json',
-        ...(gzippedPayload !== null && { 'Content-Encoding': 'gzip' }),
-      },
-      body: gzippedPayload || serialized,
-    }
+  async _sendLogsBatch(payload: OtlpLogsPayload): Promise<SendLogsBatchOutcome> {
+    return this._sendOtlpBatch({ path: 'logs', payload })
+  }
 
-    try {
-      await this.fetchWithRetry(
-        url,
-        fetchOptions,
-        { type: 'successful-write' },
-        {
-          retryCheck: (err) => {
-            if (isPostHogFetchContentTooLargeError(err)) {
-              return false
-            }
-            return isPostHogFetchRetryableError(err)
-          },
-        }
-      )
-      return { kind: 'ok' }
-    } catch (err) {
-      if (isPostHogFetchContentTooLargeError(err)) {
-        return { kind: 'too-large' }
-      }
-      // Exhausted retries on a retryable failure (network error, 408/429/5xx)
-      // still classify as retry-later so the window rides the next flush; only
-      // non-retryable HTTP errors (and 413 above) drop the batch.
-      if (isPostHogFetchRetryableError(err)) {
-        return { kind: 'retry-later', error: err }
-      }
-      return { kind: 'fatal', error: err }
-    }
+  async _sendMetricsBatch(payload: OtlpMetricsPayload): Promise<SendMetricsBatchOutcome> {
+    return this._sendOtlpBatch({ path: 'metrics', payload })
   }
 
   private fetchWithRetry<T>(
@@ -1766,12 +1737,16 @@ export abstract class PostHogCoreStateless {
     try {
       if (body instanceof Blob) {
         reqByteLength = body.size
+      } else if (body instanceof Uint8Array) {
+        reqByteLength = body.byteLength
       } else {
         reqByteLength = Buffer.byteLength(body, STRING_FORMAT)
       }
     } catch {
       if (body instanceof Blob) {
         reqByteLength = body.size
+      } else if (body instanceof Uint8Array) {
+        reqByteLength = body.byteLength
       } else {
         const encoded = new TextEncoder().encode(body)
         reqByteLength = encoded.length

package/node_modules/@posthog/core/src/posthog-core.ts

@@ -53,8 +53,11 @@ interface FlagsAsyncOptions {
 }
 
 interface PendingFlagsRequest extends FlagsAsyncOptions {
-  resolve: (value: PostHogFeatureFlagsResponse | undefined) => void
-  reject: (reason?: unknown) => void
+  // every caller displaced from this slot, so none is settled against a request it did not make
+  waiters: {
+    resolve: (value: PostHogFeatureFlagsResponse | undefined) => void
+    reject: (reason?: unknown) => void
+  }[]
 }
 
 export abstract class PostHogCore extends PostHogCoreStateless {
@@ -651,16 +654,20 @@ export abstract class PostHogCore extends PostHogCoreStateless {
       return undefined
     }
     if (this._flagsResponsePromise) {
-      // Queue the reload request instead of dropping it
-      // This ensures that requests with $anon_distinct_id (from identify()) are not lost
+      // Queue rather than drop, so an identity-changing reload still reaches the server. Displaced
+      // callers are carried over rather than settled against the in-flight request: that request
+      // was issued before their context changed, so it cannot reflect it. Options are merged so
+      // the single queued request satisfies every caller behind it — one caller asking for the
+      // remote config or for $anon_distinct_id is enough for the re-issued request to carry it.
       this._logger.info('Feature flags are being loaded already, queuing reload.')
-      // Resolve any existing pending promise with the in-flight request's result to avoid hanging promises
-      if (this._pendingFlagsRequest) {
-        this._flagsResponsePromise.then(this._pendingFlagsRequest.resolve).catch(this._pendingFlagsRequest.reject)
-      }
-      // Return a promise that resolves when the pending request completes
+      const pending = this._pendingFlagsRequest
       return new Promise((resolve, reject) => {
-        this._pendingFlagsRequest = { sendAnonDistinctId, fetchConfig, triggerOnRemoteConfig, resolve, reject }
+        this._pendingFlagsRequest = {
+          sendAnonDistinctId: sendAnonDistinctId || !!pending?.sendAnonDistinctId,
+          fetchConfig: fetchConfig || !!pending?.fetchConfig,
+          triggerOnRemoteConfig: triggerOnRemoteConfig || !!pending?.triggerOnRemoteConfig,
+          waiters: [...(pending?.waiters ?? []), { resolve, reject }],
+        }
       })
     }
     return this._flagsAsync({ sendAnonDistinctId, fetchConfig, triggerOnRemoteConfig })
@@ -911,8 +918,8 @@ export abstract class PostHogCore extends PostHogCoreStateless {
             fetchConfig: pendingRequest.fetchConfig,
             triggerOnRemoteConfig: pendingRequest.triggerOnRemoteConfig,
           })
-            .then(pendingRequest.resolve)
-            .catch(pendingRequest.reject)
+            .then((res) => pendingRequest.waiters.forEach((w) => w.resolve(res)))
+            .catch((e) => pendingRequest.waiters.forEach((w) => w.reject(e)))
         }
       })
     return this._flagsResponsePromise

package/node_modules/@posthog/core/src/types.ts

@@ -299,12 +299,14 @@ export enum PostHogPersistedProperty {
   DeviceId = 'device_id', // only used by posthog-react-native
 }
 
+export type PostHogFetchBodyBytes = Uint8Array & { buffer: ArrayBuffer }
+
 export type PostHogFetchOptions = {
   method: 'GET' | 'POST' | 'PUT' | 'PATCH'
   mode?: 'no-cors'
   credentials?: 'omit'
   headers: { [key: string]: string }
-  body?: string | Blob
+  body?: string | Blob | PostHogFetchBodyBytes
   signal?: AbortSignal
 }
 

package/node_modules/@posthog/core/src/utils/index.ts

@@ -3,7 +3,9 @@ import { FetchLike } from '../types'
 export * from './bot-detection'
 export * from './browser-utils'
 export * from './bucketed-rate-limiter'
-export * from './json-utils'
+// Named rather than `export *`: the budgets, markers and `sanitizeString` are
+// shared with the OTLP encoder but are not public API.
+export { toJsonSafeValue } from './json-utils'
 export * from './number-utils'
 export * from './string-utils'
 export * from './type-utils'

package/node_modules/@posthog/core/src/utils/json-utils.ts

@@ -1,10 +1,12 @@
-const MAX_JSON_SAFE_VALUE_DEPTH = 20
-const MAX_JSON_SAFE_VALUE_ITEMS = 1_000
-const MAX_JSON_SAFE_VALUE_NODES = 10_000
-const CIRCULAR_VALUE = '[Circular]'
-const TRUNCATED_VALUE = '[Truncated]'
-const UNSERIALIZABLE_VALUE = '[Unserializable]'
-const FUNCTION_VALUE = '[Function]'
+/** Traversal budgets and markers, shared with the OTLP attribute encoder. Not
+ * public API — `utils/index.ts` re-exports `toJsonSafeValue` only. */
+export const MAX_JSON_SAFE_VALUE_DEPTH = 20
+export const MAX_JSON_SAFE_VALUE_ITEMS = 1_000
+export const MAX_JSON_SAFE_VALUE_NODES = 10_000
+export const CIRCULAR_VALUE = '[Circular]'
+export const TRUNCATED_VALUE = '[Truncated]'
+export const UNSERIALIZABLE_VALUE = '[Unserializable]'
+export const FUNCTION_VALUE = '[Function]'
 
 const dateGetTime = Date.prototype.getTime
 const dateToISOString = Date.prototype.toISOString
@@ -15,7 +17,12 @@ interface JsonSafeValueConversionState {
   remainingNodes: number
 }
 
-function sanitizeString(value: string): string {
+/**
+ * Replaces unpaired surrogates with U+FFFD. A lone surrogate survives
+ * `JSON.stringify` as a `\uD800`-style escape, which strict JSON parsers
+ * reject — for OTLP that means the whole request is refused.
+ */
+export function sanitizeString(value: string): string {
   let output = ''
   for (let index = 0; index < value.length; index++) {
     const codeUnit = value.charCodeAt(index)

package/node_modules/@posthog/types/dist/capture-log.d.ts

@@ -66,12 +66,21 @@ export interface Logger {
 }
 export interface OtlpAnyValue {
     stringValue?: string;
-    intValue?: number;
+    /**
+     * proto3 JSON maps int64 to a string, which is the form the SDK emits.
+     * `number` stays valid because encoded records persist in the logs queue:
+     * one written by an earlier version rehydrates in the numeric form and is
+     * re-sent unchanged. The wire format accepts both.
+     */
+    intValue?: string | number;
     doubleValue?: number;
     boolValue?: boolean;
     arrayValue?: {
         values: OtlpAnyValue[];
     };
+    kvlistValue?: {
+        values: OtlpKeyValue[];
+    };
 }
 export interface OtlpKeyValue {
     key: string;

package/node_modules/@posthog/types/dist/capture-log.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capture-log.d.ts","sourceRoot":"","sources":["../src/capture-log.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"capture-log.d.ts","sourceRoot":"","sources":["../src/capture-log.ts"],"names":[],"mappings":"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"}