@posthog/core 1.49.2 → 1.50.1

package/src/featureFlagLocalEvaluation.ts

@@ -1,7 +1,7 @@
 import { parsePayload } from './featureFlagUtils'
 import type { FeatureFlagValue, JsonType } from './types'
 
-export type FeatureFlagPropertyValue = string | number | (string | number)[] | boolean
+export type FeatureFlagPropertyValue = JsonType
 
 export type FeatureFlagProperty = {
   key: string
@@ -42,6 +42,172 @@ export class InconclusiveMatchError extends Error {
   }
 }
 
+function isTruthyOrFalsyPropertyValue(value: unknown): boolean {
+  if (typeof value === 'boolean') return true
+  if (typeof value === 'string') {
+    const lowercaseValue = value.toLowerCase()
+    return lowercaseValue === 'true' || lowercaseValue === 'false'
+  }
+  if (!Array.isArray(value)) return false
+  for (let index = 0; index < value.length; index++) {
+    if (!isTruthyOrFalsyPropertyValue(index in value ? value[index] : null)) return false
+  }
+  return true
+}
+
+function isTruthyPropertyValue(value: unknown): boolean {
+  if (typeof value === 'boolean') return value
+  if (typeof value === 'string') return value.toLowerCase() === 'true'
+  if (!Array.isArray(value)) return false
+  for (let index = 0; index < value.length; index++) {
+    if (!isTruthyPropertyValue(index in value ? value[index] : null)) return false
+  }
+  return true
+}
+
+function assertUnicodeScalarString(value: string): void {
+  for (let index = 0; index < value.length; index++) {
+    const unit = value.charCodeAt(index)
+    if (unit >= 0xd800 && unit <= 0xdbff) {
+      const next = value.charCodeAt(index + 1)
+      if (index + 1 >= value.length || next < 0xdc00 || next > 0xdfff) {
+        throw new InconclusiveMatchError('Cannot stringify an unpaired surrogate like the flags service')
+      }
+      index++
+    } else if (unit >= 0xdc00 && unit <= 0xdfff) {
+      throw new InconclusiveMatchError('Cannot stringify an unpaired surrogate like the flags service')
+    }
+  }
+}
+
+function assertJsonRepresentable(value: unknown, seen: Set<object> = new Set()): void {
+  if (value === null || typeof value === 'boolean') return
+  if (typeof value === 'string') {
+    assertUnicodeScalarString(value)
+    return
+  }
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) {
+      throw new InconclusiveMatchError(`Cannot represent non-finite number ${value} like the flags service`)
+    }
+    return
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw new InconclusiveMatchError('Cannot represent a circular array during local evaluation')
+    seen.add(value)
+    try {
+      for (let index = 0; index < value.length; index++) {
+        if (index in value) assertJsonRepresentable(value[index], seen)
+      }
+    } finally {
+      seen.delete(value)
+    }
+    return
+  }
+  if (typeof value === 'object') {
+    const prototype = Object.getPrototypeOf(value)
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new InconclusiveMatchError('Cannot represent a non-JSON object like the flags service')
+    }
+    if (seen.has(value)) throw new InconclusiveMatchError('Cannot represent a circular object during local evaluation')
+    seen.add(value)
+    try {
+      for (const key of Object.keys(value)) {
+        assertUnicodeScalarString(key)
+        assertJsonRepresentable((value as Record<string, unknown>)[key], seen)
+      }
+    } finally {
+      seen.delete(value)
+    }
+    return
+  }
+  throw new InconclusiveMatchError(`Cannot represent ${typeof value} like the flags service`)
+}
+
+function compareJsonObjectKeys(left: string, right: string): number {
+  let leftIndex = 0
+  let rightIndex = 0
+  while (leftIndex < left.length && rightIndex < right.length) {
+    const leftUnit = left.charCodeAt(leftIndex)
+    const rightUnit = right.charCodeAt(rightIndex)
+    const leftIsHighSurrogate = leftUnit >= 0xd800 && leftUnit <= 0xdbff
+    const rightIsHighSurrogate = rightUnit >= 0xd800 && rightUnit <= 0xdbff
+    const leftNext = leftIsHighSurrogate ? left.charCodeAt(leftIndex + 1) : 0
+    const rightNext = rightIsHighSurrogate ? right.charCodeAt(rightIndex + 1) : 0
+
+    const leftCodePoint = leftIsHighSurrogate ? (leftUnit - 0xd800) * 0x400 + leftNext - 0xdc00 + 0x10000 : leftUnit
+    const rightCodePoint = rightIsHighSurrogate
+      ? (rightUnit - 0xd800) * 0x400 + rightNext - 0xdc00 + 0x10000
+      : rightUnit
+    if (leftCodePoint !== rightCodePoint) return leftCodePoint - rightCodePoint
+    leftIndex += leftIsHighSurrogate ? 2 : 1
+    rightIndex += rightIsHighSurrogate ? 2 : 1
+  }
+  return left.length - right.length
+}
+
+// JavaScript collapses JSON integers and integral floats into Number, including inside composites.
+// These values fall back rather than choosing a spelling that can disagree with the flags service.
+function serializeJsonValue(value: unknown, seen: Set<object> = new Set()): string {
+  if (value === null) return 'null'
+  if (typeof value === 'string') {
+    assertUnicodeScalarString(value)
+    return JSON.stringify(value)
+  }
+  if (typeof value === 'boolean') return value ? 'true' : 'false'
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) {
+      throw new InconclusiveMatchError(`Cannot stringify non-finite number ${value} like the flags service`)
+    }
+    if (Number.isInteger(value)) {
+      throw new InconclusiveMatchError(
+        `Cannot distinguish integer ${value} from an integral JSON float during local evaluation`
+      )
+    }
+    return String(value)
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) throw new InconclusiveMatchError('Cannot stringify a circular array during local evaluation')
+    seen.add(value)
+    try {
+      const items: string[] = []
+      for (let index = 0; index < value.length; index++) {
+        items.push(index in value ? serializeJsonValue(value[index], seen) : 'null')
+      }
+      return `[${items.join(',')}]`
+    } finally {
+      seen.delete(value)
+    }
+  }
+  if (typeof value === 'object') {
+    const prototype = Object.getPrototypeOf(value)
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new InconclusiveMatchError('Cannot stringify a non-JSON object like the flags service')
+    }
+    if (seen.has(value)) throw new InconclusiveMatchError('Cannot stringify a circular object during local evaluation')
+    seen.add(value)
+    try {
+      const keys = Object.keys(value)
+      keys.forEach(assertUnicodeScalarString)
+      return `{${keys
+        .sort(compareJsonObjectKeys)
+        .map((key) => `${JSON.stringify(key)}:${serializeJsonValue((value as Record<string, unknown>)[key], seen)}`)
+        .join(',')}}`
+    } finally {
+      seen.delete(value)
+    }
+  }
+  throw new InconclusiveMatchError(`Cannot stringify ${typeof value} like the flags service`)
+}
+
+function exactMatchString(value: unknown): string {
+  if (typeof value === 'string') {
+    assertUnicodeScalarString(value)
+    return value
+  }
+  return serializeJsonValue(value)
+}
+
 function isValidRegex(regex: string): boolean {
   try {
     new RegExp(regex)
@@ -51,6 +217,11 @@ function isValidRegex(regex: string): boolean {
   }
 }
 
+// The flags service deliberately folds only ASCII for substring, prefix, and suffix operators.
+function asciiLowercase(value: unknown): string {
+  return String(value).replace(/[A-Z]/g, (character) => character.toLowerCase())
+}
+
 type SemverTuple = [number, number, number]
 
 function parseSemverNumericIdentifier(
@@ -190,19 +361,35 @@ export function matchFeatureFlagProperty(
     throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`)
   } else if (operator === 'is_not_set') {
     return false
+  } else if (operator === 'is_set') {
+    return true
   }
 
   const overrideValue = propertyValues[key]
-  if (overrideValue == null && !NULL_VALUES_ALLOWED_OPERATORS.includes(operator)) {
-    options.warnFunction?.(`Property ${key} cannot have a value of null/undefined with the ${operator} operator`)
+  if (overrideValue === undefined) {
+    options.warnFunction?.(`Property ${key} cannot have a value of undefined with the ${operator} operator`)
+    return operator === 'is_not'
+  }
+  if (
+    overrideValue === null &&
+    !NULL_VALUES_ALLOWED_OPERATORS.includes(operator) &&
+    operator !== 'exact' &&
+    operator !== 'is_not'
+  ) {
+    options.warnFunction?.(`Property ${key} cannot have a value of null with the ${operator} operator`)
     return false
   }
 
-  const computeExactMatch = (target: any, actual: any): boolean => {
+  const computeExactMatch = (target: unknown, actual: unknown): boolean => {
+    if (isTruthyOrFalsyPropertyValue(target)) {
+      assertJsonRepresentable(actual)
+      return isTruthyPropertyValue(target) === isTruthyPropertyValue(actual)
+    }
     if (Array.isArray(target)) {
-      return target.map((item) => String(item).toLowerCase()).includes(String(actual).toLowerCase())
+      const actualString = exactMatchString(actual).toLowerCase()
+      return target.some((item) => exactMatchString(item).toLowerCase() === actualString)
     }
-    return String(target).toLowerCase() === String(actual).toLowerCase()
+    return exactMatchString(target).toLowerCase() === exactMatchString(actual).toLowerCase()
   }
 
   const compare = (lhs: any, rhs: any, comparisonOperator: string): boolean => {
@@ -221,17 +408,17 @@ export function matchFeatureFlagProperty(
     case 'is_set':
       return true
     case 'icontains':
-      return String(overrideValue).toLowerCase().includes(String(value).toLowerCase())
+      return asciiLowercase(overrideValue).includes(asciiLowercase(value))
     case 'not_icontains':
-      return !String(overrideValue).toLowerCase().includes(String(value).toLowerCase())
+      return !asciiLowercase(overrideValue).includes(asciiLowercase(value))
     case 'starts_with':
-      return String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase())
+      return asciiLowercase(overrideValue).startsWith(asciiLowercase(value))
     case 'not_starts_with':
-      return !String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase())
+      return !asciiLowercase(overrideValue).startsWith(asciiLowercase(value))
     case 'ends_with':
-      return String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase())
+      return asciiLowercase(overrideValue).endsWith(asciiLowercase(value))
     case 'not_ends_with':
-      return !String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase())
+      return !asciiLowercase(overrideValue).endsWith(asciiLowercase(value))
     case 'regex':
       return isValidRegex(String(value)) && String(overrideValue).match(String(value)) !== null
     case 'not_regex':

package/src/index.ts

@@ -42,9 +42,9 @@ export {
   buildResourceAttributes,
   getOtlpSeverityNumber,
   getOtlpSeverityText,
-  toOtlpAnyValue,
-  toOtlpKeyValueList,
 } from './logs/logs-utils'
+export { toOtlpAnyValue, toOtlpKeyValueList } from './utils/otlp-any-value'
+export { osResourceAttributes } from './utils/otlp-resource'
 export { PostHogLogs } from './logs'
 export type {
   BeforeSendLogFn,

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

@@ -1,13 +1,6 @@
-import type { CaptureLogOptions, LogAttributeValue, LogSeverityLevel } from '@posthog/types'
+import type { CaptureLogOptions, LogSeverityLevel } from '@posthog/types'
 import type { LogSdkContext } from './types'
-import {
-  buildOtlpLogRecord,
-  buildOtlpLogsPayload,
-  getOtlpSeverityNumber,
-  getOtlpSeverityText,
-  toOtlpAnyValue,
-  toOtlpKeyValueList,
-} from './logs-utils'
+import { buildOtlpLogRecord, buildOtlpLogsPayload, getOtlpSeverityNumber, getOtlpSeverityText } from './logs-utils'
 
 const browserSdkContext: LogSdkContext = {
   distinctId: 'user-123',
@@ -64,317 +57,6 @@ describe('logs-utils', () => {
     })
   })
 
-  describe('toOtlpAnyValue', () => {
-    it('converts strings', () => {
-      expect(toOtlpAnyValue('hello')).toEqual({ stringValue: 'hello' })
-    })
-
-    it('converts integers to decimal strings', () => {
-      expect(toOtlpAnyValue(42)).toEqual({ intValue: '42' })
-      expect(toOtlpAnyValue(0)).toEqual({ intValue: '0' })
-      expect(toOtlpAnyValue(-7)).toEqual({ intValue: '-7' })
-    })
-
-    // Spec: outside int64 it is a stringValue, never an intValue.
-    it('converts integers outside int64 to stringValue', () => {
-      expect(toOtlpAnyValue(2 ** 63)).toEqual({ stringValue: '9223372036854775808' })
-      expect(toOtlpAnyValue(-(2 ** 64))).toEqual({ stringValue: '-18446744073709551616' })
-      expect(toOtlpAnyValue(1e21)).toEqual({ stringValue: '1000000000000000000000' })
-    })
-
-    it('logs a debug line when an integer falls outside int64', () => {
-      const logger = { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn(), critical: jest.fn() }
-      toOtlpAnyValue(2 ** 63, logger as any)
-      expect(logger.debug).toHaveBeenCalledWith(expect.stringContaining('outside the int64 range'))
-    })
-
-    it('keeps int64 min as intValue', () => {
-      // In range, but `String` renders it 192 below int64 min, so the decimal
-      // has to come from BigInt.
-      expect(toOtlpAnyValue(-(2 ** 63))).toEqual({ intValue: '-9223372036854775808' })
-    })
-
-    it('keeps large in-range integers exact', () => {
-      expect(toOtlpAnyValue(Number.MAX_SAFE_INTEGER)).toEqual({ intValue: '9007199254740991' })
-      // The largest double below 2^63 — no double exists between the two.
-      expect(toOtlpAnyValue(9223372036854774784)).toEqual({ intValue: '9223372036854774784' })
-      expect(toOtlpAnyValue(2 ** 62)).toEqual({ intValue: '4611686018427387904' })
-    })
-
-    it('converts floats to doubleValue', () => {
-      expect(toOtlpAnyValue(3.14)).toEqual({ doubleValue: 3.14 })
-    })
-
-    it('converts booleans', () => {
-      expect(toOtlpAnyValue(true)).toEqual({ boolValue: true })
-      expect(toOtlpAnyValue(false)).toEqual({ boolValue: false })
-    })
-
-    // JSON has no representation for non-finite floats; without explicit
-    // handling, JSON.stringify silently turns them into `null` and the value
-    // is lost server-side.
-    it('converts NaN to stringValue', () => {
-      expect(toOtlpAnyValue(NaN)).toEqual({ stringValue: 'NaN' })
-    })
-
-    it('converts +Infinity to stringValue', () => {
-      expect(toOtlpAnyValue(Infinity)).toEqual({ stringValue: 'Infinity' })
-    })
-
-    it('converts -Infinity to stringValue', () => {
-      expect(toOtlpAnyValue(-Infinity)).toEqual({ stringValue: '-Infinity' })
-    })
-
-    it('converts arrays of strings to arrayValue', () => {
-      expect(toOtlpAnyValue(['a', 'b'])).toEqual({
-        arrayValue: { values: [{ stringValue: 'a' }, { stringValue: 'b' }] },
-      })
-    })
-
-    it('converts mixed primitive arrays recursively', () => {
-      expect(toOtlpAnyValue([1, 'x', true])).toEqual({
-        arrayValue: {
-          values: [{ intValue: '1' }, { stringValue: 'x' }, { boolValue: true }],
-        },
-      })
-    })
-
-    it('converts plain objects to kvlistValue', () => {
-      expect(toOtlpAnyValue({ a: 1, b: 'two' })).toEqual({
-        kvlistValue: {
-          values: [
-            { key: 'a', value: { intValue: '1' } },
-            { key: 'b', value: { stringValue: 'two' } },
-          ],
-        },
-      })
-    })
-
-    it('converts nested objects recursively', () => {
-      expect(toOtlpAnyValue({ outer: { inner: 1 } })).toEqual({
-        kvlistValue: {
-          values: [
-            {
-              key: 'outer',
-              value: { kvlistValue: { values: [{ key: 'inner', value: { intValue: '1' } }] } },
-            },
-          ],
-        },
-      })
-    })
-
-    it('drops null and undefined keys inside objects', () => {
-      expect(toOtlpAnyValue({ kept: 1, gone: null, alsoGone: undefined })).toEqual({
-        kvlistValue: { values: [{ key: 'kept', value: { intValue: '1' } }] },
-      })
-    })
-
-    // Not in LogAttributeValue, but reachable at runtime from untyped callers.
-    it('encodes Dates as ISO strings', () => {
-      expect(toOtlpAnyValue(new Date('2026-08-20T10:00:00.000Z') as unknown as LogAttributeValue)).toEqual({
-        stringValue: '2026-08-20T10:00:00.000Z',
-      })
-    })
-
-    it('marks circular references instead of recursing', () => {
-      const cyclic: Record<string, unknown> = { name: 'root' }
-      cyclic.self = cyclic
-      expect(toOtlpAnyValue(cyclic)).toEqual({
-        kvlistValue: {
-          values: [
-            { key: 'name', value: { stringValue: 'root' } },
-            { key: 'self', value: { stringValue: '[Circular]' } },
-          ],
-        },
-      })
-    })
-
-    // An escaping error would surface in the caller's application code.
-    it('does not throw on an object nested past the depth cap', () => {
-      let deep: Record<string, unknown> = { end: true }
-      for (let i = 0; i < 25000; i++) {
-        deep = { next: deep }
-      }
-      expect(() => toOtlpAnyValue(deep)).not.toThrow()
-    })
-
-    it('truncates at exactly 20 levels instead of recursing', () => {
-      let deep: Record<string, unknown> = { end: true }
-      for (let i = 0; i < 25; i++) {
-        deep = { next: deep }
-      }
-      const encoded = JSON.stringify(toOtlpAnyValue(deep))
-      expect(encoded).toContain('[Truncated]')
-      expect(encoded.split('"next"').length - 1).toBe(20)
-    })
-
-    it('marks a throwing getter without losing the rest of the object', () => {
-      const attrs = {
-        ok: 1,
-        get bad(): number {
-          throw new Error('getter blew up')
-        },
-      }
-      expect(() => toOtlpKeyValueList(attrs)).not.toThrow()
-      expect(toOtlpKeyValueList(attrs)).toEqual([
-        { key: 'ok', value: { intValue: '1' } },
-        { key: 'bad', value: { stringValue: '[Unserializable]' } },
-      ])
-    })
-
-    // for...in walks the prototype chain once own keys are exhausted.
-    it('ignores inherited enumerable properties', () => {
-      const inherited: Record<string, unknown> = Object.create({ fromPrototype: 'leaked' })
-      inherited.own = 1
-      expect(toOtlpAnyValue(inherited)).toEqual({
-        kvlistValue: { values: [{ key: 'own', value: { intValue: '1' } }] },
-      })
-    })
-
-    // `String(fn)` would put the function's source text on the wire.
-    it('marks function and symbol values instead of stringifying them', () => {
-      expect(toOtlpAnyValue({ handler: () => 1, retries: 2 } as unknown as LogAttributeValue)).toEqual({
-        kvlistValue: {
-          values: [
-            { key: 'handler', value: { stringValue: '[Function]' } },
-            { key: 'retries', value: { intValue: '2' } },
-          ],
-        },
-      })
-      expect(toOtlpAnyValue({ sym: Symbol('x') } as unknown as LogAttributeValue)).toEqual({
-        kvlistValue: { values: [{ key: 'sym', value: { stringValue: 'Symbol(x)' } }] },
-      })
-    })
-
-    // dayjs, Decimal, ORM documents.
-    it('honours toJSON', () => {
-      const wrapped = { toJSON: () => ({ amount: 5 }) }
-      expect(toOtlpAnyValue(wrapped as unknown as LogAttributeValue)).toEqual({
-        kvlistValue: { values: [{ key: 'amount', value: { intValue: '5' } }] },
-      })
-    })
-
-    it('falls back to the plain walk when toJSON throws', () => {
-      const wrapped = {
-        kept: 1,
-        toJSON: () => {
-          throw new Error('nope')
-        },
-      }
-      expect(toOtlpAnyValue(wrapped as unknown as LogAttributeValue)).toEqual({
-        kvlistValue: {
-          values: [
-            { key: 'kept', value: { intValue: '1' } },
-            { key: 'toJSON', value: { stringValue: '[Function]' } },
-          ],
-        },
-      })
-    })
-
-    // A toJSON returning its own object is a cycle like any other.
-    it('marks a cycle that runs through toJSON', () => {
-      const cyclic: Record<string, unknown> = {}
-      cyclic.toJSON = () => ({ inner: cyclic })
-      expect(toOtlpAnyValue(cyclic)).toEqual({
-        kvlistValue: { values: [{ key: 'inner', value: { stringValue: '[Circular]' } }] },
-      })
-    })
-
-    // Both `null` and `{}` here are rejected for the whole request; iOS and
-    // Android drop them too.
-    it('drops holes and nullish elements from arrays', () => {
-      // eslint-disable-next-line no-sparse-arrays
-      expect(toOtlpAnyValue([1, , 3])).toEqual({
-        arrayValue: { values: [{ intValue: '1' }, { intValue: '3' }] },
-      })
-      expect(toOtlpAnyValue([1, null, undefined, 3])).toEqual({
-        arrayValue: { values: [{ intValue: '1' }, { intValue: '3' }] },
-      })
-    })
-
-    it('stops encoding array items once the node budget is spent', () => {
-      const row: Record<string, number> = {}
-      for (let i = 0; i < 20; i++) {
-        row[`k${i}`] = i
-      }
-      const wide = Array.from({ length: 1000 }, () => ({ ...row }))
-      const values = toOtlpAnyValue(wide).arrayValue!.values
-      expect(values[values.length - 1]).toEqual({ stringValue: '[Truncated]' })
-      // One marker, not one per unencodable item.
-      expect(values.filter((v) => v.stringValue === '[Truncated]')).toHaveLength(1)
-    })
-
-    it('caps a shared object graph instead of expanding it', () => {
-      let graph: Record<string, unknown> = { leaf: true }
-      for (let i = 0; i < 20; i++) {
-        graph = { a: graph, b: graph }
-      }
-      const encoded = JSON.stringify(toOtlpAnyValue(graph))
-      expect(encoded).toContain('[Truncated]')
-      expect(encoded.length).toBeLessThan(1_000_000)
-    })
-
-    it('caps a very wide object without inventing an attribute key', () => {
-      const wide: Record<string, number> = {}
-      for (let i = 0; i < 5000; i++) {
-        wide[`k${i}`] = i
-      }
-      const logger = { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn(), critical: jest.fn() }
-      const values = toOtlpAnyValue(wide, logger as any).kvlistValue!.values
-      expect(values).toHaveLength(1000)
-      expect(values.every((v) => v.key.startsWith('k'))).toBe(true)
-      expect(logger.debug).toHaveBeenCalledWith(expect.stringContaining('truncated'))
-    })
-
-    // Why the encoder does not delegate to toJsonSafeValue: that maps them to null.
-    it('keeps non-finite floats as strings inside nested objects', () => {
-      expect(toOtlpAnyValue({ nested: { ratio: NaN } })).toEqual({
-        kvlistValue: {
-          values: [
-            {
-              key: 'nested',
-              value: { kvlistValue: { values: [{ key: 'ratio', value: { stringValue: 'NaN' } }] } },
-            },
-          ],
-        },
-      })
-    })
-
-    // A lone surrogate survives JSON.stringify as a \uD800 escape, which the
-    // server rejects for the whole request.
-    it('replaces unpaired surrogates in values and keys', () => {
-      expect(toOtlpAnyValue('ok\ud83d')).toEqual({ stringValue: 'ok\ufffd' })
-      expect(toOtlpAnyValue({ nested: 'ok\ud83d' })).toEqual({
-        kvlistValue: { values: [{ key: 'nested', value: { stringValue: 'ok\ufffd' } }] },
-      })
-      expect(toOtlpKeyValueList({ 'key\ud83d': 1 })).toEqual([{ key: 'key\ufffd', value: { intValue: '1' } }])
-    })
-
-    it('encodes empty containers with an explicit values array', () => {
-      expect(toOtlpAnyValue({})).toEqual({ kvlistValue: { values: [] } })
-      expect(toOtlpAnyValue([])).toEqual({ arrayValue: { values: [] } })
-    })
-
-    it('keeps a Date whose toISOString is overridden out of the wire format', () => {
-      const broken = new Date('2026-08-20T10:00:00.000Z')
-
-      ;(broken as any).toISOString = () => ({})
-      expect(typeof toOtlpAnyValue(broken as unknown as LogAttributeValue).stringValue).toBe('string')
-    })
-
-    it('encodes sibling references to one object twice, not as circular', () => {
-      const shared = { id: 1 }
-      expect(toOtlpAnyValue({ a: shared, b: shared })).toEqual({
-        kvlistValue: {
-          values: [
-            { key: 'a', value: { kvlistValue: { values: [{ key: 'id', value: { intValue: '1' } }] } } },
-            { key: 'b', value: { kvlistValue: { values: [{ key: 'id', value: { intValue: '1' } }] } } },
-          ],
-        },
-      })
-    })
-  })
-
   describe('buildOtlpLogRecord attribute reads', () => {
     // Reading `options.attributes` happens before the encoder's per-key guard.
     it('marks an attribute whose getter throws without dropping the record', () => {
@@ -425,36 +107,6 @@ describe('logs-utils', () => {
     })
   })
 
-  describe('toOtlpKeyValueList', () => {
-    it('converts a record to key-value list', () => {
-      expect(
-        toOtlpKeyValueList({
-          name: 'test',
-          count: 5,
-          active: true,
-        })
-      ).toEqual([
-        { key: 'name', value: { stringValue: 'test' } },
-        { key: 'count', value: { intValue: '5' } },
-        { key: 'active', value: { boolValue: true } },
-      ])
-    })
-
-    it('handles empty record', () => {
-      expect(toOtlpKeyValueList({})).toEqual([])
-    })
-
-    it('skips null and undefined values', () => {
-      expect(
-        toOtlpKeyValueList({
-          kept: 'yes',
-          nullish: null,
-          missing: undefined,
-        })
-      ).toEqual([{ key: 'kept', value: { stringValue: 'yes' } }])
-    })
-  })
-
   describe('buildOtlpLogRecord', () => {
     it('builds a minimal log record', () => {
       const record = buildOtlpLogRecord({ body: 'hello world' }, minimalSdkContext)