@posthog/core 1.48.9 → 1.48.11

package/src/featureFlagLocalEvaluation.ts

@@ -0,0 +1,375 @@
+import { parsePayload } from './featureFlagUtils'
+import type { FeatureFlagValue, JsonType } from './types'
+
+export type FeatureFlagPropertyValue = string | number | (string | number)[] | boolean
+
+export type FeatureFlagProperty = {
+  key: string
+  value: FeatureFlagPropertyValue
+  operator?: string
+}
+
+export type FeatureFlagSemverParsingPolicy = 'strict' | 'legacy-permissive'
+
+export type MatchFeatureFlagPropertyOptions = {
+  warnFunction?: (message: string) => void
+  semverParsingPolicy?: FeatureFlagSemverParsingPolicy
+}
+
+export type FeatureFlagVariant = {
+  key: string
+  rollout_percentage: number
+}
+
+export type FeatureFlagVariantLookupEntry = {
+  valueMin: number
+  valueMax: number
+  key: string
+}
+
+const NULL_VALUES_ALLOWED_OPERATORS = ['is_not', 'is_set']
+
+// This value is intentionally larger than Number.MAX_SAFE_INTEGER. Changing its rounding changes
+// existing rollout and variant assignments.
+// eslint-disable-next-line no-loss-of-precision
+const LONG_SCALE = 0xfffffffffffffff
+
+export class InconclusiveMatchError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = this.constructor.name
+    Object.setPrototypeOf(this, InconclusiveMatchError.prototype)
+  }
+}
+
+function isValidRegex(regex: string): boolean {
+  try {
+    new RegExp(regex)
+    return true
+  } catch {
+    return false
+  }
+}
+
+type SemverTuple = [number, number, number]
+
+function parseSemverNumericIdentifier(
+  part: string,
+  raw: string,
+  parsingPolicy: FeatureFlagSemverParsingPolicy
+): number {
+  if (!/^\d+$/.test(part) || (parsingPolicy === 'strict' && part.length > 1 && part[0] === '0')) {
+    throw new InconclusiveMatchError(`Invalid semver: ${raw}`)
+  }
+  return parseInt(part, 10)
+}
+
+export function parseFeatureFlagSemver(
+  value: string,
+  parsingPolicy: FeatureFlagSemverParsingPolicy = 'strict'
+): SemverTuple {
+  const text = String(value).trim().replace(/^[vV]/, '')
+  const baseVersion = text.split('-')[0].split('+')[0]
+
+  if (!baseVersion || baseVersion.startsWith('.')) {
+    throw new InconclusiveMatchError(`Invalid semver: ${value}`)
+  }
+
+  const parts = baseVersion.split('.')
+  const parsePart = (part: string | undefined): number => {
+    if (part === undefined || part === '') return 0
+    return parseSemverNumericIdentifier(part, value, parsingPolicy)
+  }
+
+  return [parsePart(parts[0]), parsePart(parts[1]), parsePart(parts[2])]
+}
+
+function compareSemverTuples(a: SemverTuple, b: SemverTuple): number {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] < b[i]) return -1
+    if (a[i] > b[i]) return 1
+  }
+  return 0
+}
+
+function computeTildeBounds(
+  value: string,
+  parsingPolicy: FeatureFlagSemverParsingPolicy
+): { lower: SemverTuple; upper: SemverTuple } {
+  const parsed = parseFeatureFlagSemver(value, parsingPolicy)
+  return { lower: [parsed[0], parsed[1], parsed[2]], upper: [parsed[0], parsed[1] + 1, 0] }
+}
+
+function computeCaretBounds(
+  value: string,
+  parsingPolicy: FeatureFlagSemverParsingPolicy
+): { lower: SemverTuple; upper: SemverTuple } {
+  const [major, minor, patch] = parseFeatureFlagSemver(value, parsingPolicy)
+  const lower: SemverTuple = [major, minor, patch]
+  let upper: SemverTuple
+  if (major > 0) upper = [major + 1, 0, 0]
+  else if (minor > 0) upper = [0, minor + 1, 0]
+  else upper = [0, 0, patch + 1]
+  return { lower, upper }
+}
+
+function computeWildcardBounds(
+  value: string,
+  parsingPolicy: FeatureFlagSemverParsingPolicy
+): { lower: SemverTuple; upper: SemverTuple } {
+  const text = String(value).trim().replace(/^[vV]/, '')
+  const cleanedText = text.replace(/\.\*$/, '').replace(/\*$/, '')
+  if (!cleanedText) throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`)
+
+  const parts = cleanedText.split('.')
+  const parseWildcardPart = (part: string): number => {
+    if (parsingPolicy === 'legacy-permissive') {
+      const parsed = parseInt(part, 10)
+      if (!isNaN(parsed)) return parsed
+    } else {
+      try {
+        return parseSemverNumericIdentifier(part, value, parsingPolicy)
+      } catch {
+        // Normalize wildcard parsing failures to the historical wildcard-specific error.
+      }
+    }
+    throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`)
+  }
+
+  const major = parseWildcardPart(parts[0])
+  if (parts.length === 1) {
+    return { lower: [major, 0, 0], upper: [major + 1, 0, 0] }
+  }
+  const minor = parseWildcardPart(parts[1])
+  return { lower: [major, minor, 0], upper: [major, minor + 1, 0] }
+}
+
+function convertToDateTime(value: FeatureFlagPropertyValue | Date): Date {
+  if (value instanceof Date) return value
+  if (typeof value === 'string' || typeof value === 'number') {
+    const date = new Date(value)
+    if (!isNaN(date.valueOf())) return date
+    throw new InconclusiveMatchError(`${value} is in an invalid date format`)
+  }
+  throw new InconclusiveMatchError(`The date provided ${value} must be a string, number, or date object`)
+}
+
+export function relativeDateParseForFeatureFlagMatching(value: string): Date | null {
+  const regex = /^-?(?<number>[0-9]+)(?<interval>[a-z])$/
+  const match = value.match(regex)
+  const parsedDt = new Date(new Date().toISOString())
+
+  if (!match || !match.groups) return null
+
+  const number = parseInt(match.groups['number'])
+  if (number >= 10000) return null
+
+  const interval = match.groups['interval']
+  if (interval === 'h') parsedDt.setUTCHours(parsedDt.getUTCHours() - number)
+  else if (interval === 'd') parsedDt.setUTCDate(parsedDt.getUTCDate() - number)
+  else if (interval === 'w') parsedDt.setUTCDate(parsedDt.getUTCDate() - number * 7)
+  else if (interval === 'm') parsedDt.setUTCMonth(parsedDt.getUTCMonth() - number)
+  else if (interval === 'y') parsedDt.setUTCFullYear(parsedDt.getUTCFullYear() - number)
+  else return null
+
+  return parsedDt
+}
+
+export function matchFeatureFlagProperty(
+  property: FeatureFlagProperty,
+  propertyValues: Record<string, any>,
+  options: MatchFeatureFlagPropertyOptions = {}
+): boolean {
+  const key = property.key
+  const value = property.value
+  const operator = property.operator || 'exact'
+  const parsingPolicy = options.semverParsingPolicy ?? 'strict'
+
+  if (!(key in propertyValues)) {
+    if (operator === 'is_not_set') return true
+    throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`)
+  } else if (operator === 'is_not_set') {
+    return false
+  }
+
+  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`)
+    return false
+  }
+
+  const computeExactMatch = (target: any, actual: any): boolean => {
+    if (Array.isArray(target)) {
+      return target.map((item) => String(item).toLowerCase()).includes(String(actual).toLowerCase())
+    }
+    return String(target).toLowerCase() === String(actual).toLowerCase()
+  }
+
+  const compare = (lhs: any, rhs: any, comparisonOperator: string): boolean => {
+    if (comparisonOperator === 'gt') return lhs > rhs
+    if (comparisonOperator === 'gte') return lhs >= rhs
+    if (comparisonOperator === 'lt') return lhs < rhs
+    if (comparisonOperator === 'lte') return lhs <= rhs
+    throw new Error(`Invalid operator: ${comparisonOperator}`)
+  }
+
+  switch (operator) {
+    case 'exact':
+      return computeExactMatch(value, overrideValue)
+    case 'is_not':
+      return !computeExactMatch(value, overrideValue)
+    case 'is_set':
+      return key in propertyValues
+    case 'icontains':
+      return String(overrideValue).toLowerCase().includes(String(value).toLowerCase())
+    case 'not_icontains':
+      return !String(overrideValue).toLowerCase().includes(String(value).toLowerCase())
+    case 'starts_with':
+      return String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase())
+    case 'not_starts_with':
+      return !String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase())
+    case 'ends_with':
+      return String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase())
+    case 'not_ends_with':
+      return !String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase())
+    case 'regex':
+      return isValidRegex(String(value)) && String(overrideValue).match(String(value)) !== null
+    case 'not_regex':
+      return isValidRegex(String(value)) && String(overrideValue).match(String(value)) === null
+    case 'gt':
+    case 'gte':
+    case 'lt':
+    case 'lte': {
+      const parsedValue = typeof value === 'number' ? value : parseFloat(String(value))
+      const parsedOverride =
+        typeof overrideValue === 'number'
+          ? overrideValue
+          : overrideValue != null
+            ? parseFloat(String(overrideValue))
+            : NaN
+      if (Number.isFinite(parsedValue) && Number.isFinite(parsedOverride)) {
+        return compare(parsedOverride, parsedValue, operator)
+      }
+      return compare(String(overrideValue), String(value), operator)
+    }
+    case 'is_date_after':
+    case 'is_date_before': {
+      if (typeof value === 'boolean') {
+        throw new InconclusiveMatchError('Date operations cannot be performed on boolean values')
+      }
+      let parsedDate = relativeDateParseForFeatureFlagMatching(String(value))
+      if (parsedDate == null) parsedDate = convertToDateTime(value)
+      const overrideDate = convertToDateTime(overrideValue)
+      return operator === 'is_date_before' ? overrideDate < parsedDate : overrideDate > parsedDate
+    }
+    case 'semver_eq':
+      return (
+        compareSemverTuples(
+          parseFeatureFlagSemver(String(overrideValue), parsingPolicy),
+          parseFeatureFlagSemver(String(value), parsingPolicy)
+        ) === 0
+      )
+    case 'semver_neq':
+      return (
+        compareSemverTuples(
+          parseFeatureFlagSemver(String(overrideValue), parsingPolicy),
+          parseFeatureFlagSemver(String(value), parsingPolicy)
+        ) !== 0
+      )
+    case 'semver_gt':
+      return (
+        compareSemverTuples(
+          parseFeatureFlagSemver(String(overrideValue), parsingPolicy),
+          parseFeatureFlagSemver(String(value), parsingPolicy)
+        ) > 0
+      )
+    case 'semver_gte':
+      return (
+        compareSemverTuples(
+          parseFeatureFlagSemver(String(overrideValue), parsingPolicy),
+          parseFeatureFlagSemver(String(value), parsingPolicy)
+        ) >= 0
+      )
+    case 'semver_lt':
+      return (
+        compareSemverTuples(
+          parseFeatureFlagSemver(String(overrideValue), parsingPolicy),
+          parseFeatureFlagSemver(String(value), parsingPolicy)
+        ) < 0
+      )
+    case 'semver_lte':
+      return (
+        compareSemverTuples(
+          parseFeatureFlagSemver(String(overrideValue), parsingPolicy),
+          parseFeatureFlagSemver(String(value), parsingPolicy)
+        ) <= 0
+      )
+    case 'semver_tilde': {
+      const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy)
+      const { lower, upper } = computeTildeBounds(String(value), parsingPolicy)
+      return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0
+    }
+    case 'semver_caret': {
+      const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy)
+      const { lower, upper } = computeCaretBounds(String(value), parsingPolicy)
+      return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0
+    }
+    case 'semver_wildcard': {
+      const overrideParsed = parseFeatureFlagSemver(String(overrideValue), parsingPolicy)
+      const { lower, upper } = computeWildcardBounds(String(value), parsingPolicy)
+      return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0
+    }
+    default:
+      throw new InconclusiveMatchError(`Unknown operator: ${operator}`)
+  }
+}
+
+export async function hashSHA1(text: string): Promise<string> {
+  const subtle = globalThis.crypto?.subtle
+  if (!subtle) throw new Error('SubtleCrypto API not available')
+
+  const hashBuffer = await subtle.digest('SHA-1', new TextEncoder().encode(text))
+  return Array.from(new Uint8Array(hashBuffer))
+    .map((byte) => byte.toString(16).padStart(2, '0'))
+    .join('')
+}
+
+export async function getFeatureFlagHash(key: string, bucketingValue: string, salt: string = ''): Promise<number> {
+  const hashString = await hashSHA1(`${key}.${bucketingValue}${salt}`)
+  return parseInt(hashString.slice(0, 15), 16) / LONG_SCALE
+}
+
+export function getFeatureFlagVariantLookupTable(
+  variants: readonly FeatureFlagVariant[]
+): FeatureFlagVariantLookupEntry[] {
+  const table: FeatureFlagVariantLookupEntry[] = []
+  let valueMin = 0
+  for (const variant of variants) {
+    const valueMax = valueMin + variant.rollout_percentage / 100.0
+    table.push({ valueMin, valueMax, key: variant.key })
+    valueMin = valueMax
+  }
+  return table
+}
+
+export async function getFeatureFlagVariant(
+  key: string,
+  bucketingValue: string,
+  variants: readonly FeatureFlagVariant[]
+): Promise<string | undefined> {
+  const hashValue = await getFeatureFlagHash(key, bucketingValue, 'variant')
+  return getFeatureFlagVariantLookupTable(variants).find(
+    (variant) => hashValue >= variant.valueMin && hashValue < variant.valueMax
+  )?.key
+}
+
+export function resolveFeatureFlagPayload(
+  payloads: Readonly<Record<string, JsonType | undefined>> | null | undefined,
+  flagValue: FeatureFlagValue | null | undefined
+): JsonType | null {
+  if (flagValue === false || flagValue === null || flagValue === undefined || !payloads) return null
+
+  const payloadKey = typeof flagValue === 'boolean' ? flagValue.toString() : flagValue
+  const payload = payloads[payloadKey] || null
+  return payload == null ? null : (parsePayload(payload) as JsonType)
+}

package/src/index.ts

@@ -7,6 +7,25 @@ export {
   MINIMAL_FLAG_CALLED_EVENT_CAMPAIGN_PROPERTIES,
   minimizeFlagCalledEventProperties,
 } from './featureFlagUtils'
+export {
+  getFeatureFlagHash,
+  getFeatureFlagVariant,
+  getFeatureFlagVariantLookupTable,
+  hashSHA1,
+  InconclusiveMatchError,
+  matchFeatureFlagProperty,
+  parseFeatureFlagSemver,
+  relativeDateParseForFeatureFlagMatching,
+  resolveFeatureFlagPayload,
+} from './featureFlagLocalEvaluation'
+export type {
+  FeatureFlagProperty,
+  FeatureFlagPropertyValue,
+  FeatureFlagSemverParsingPolicy,
+  FeatureFlagVariant,
+  FeatureFlagVariantLookupEntry,
+  MatchFeatureFlagPropertyOptions,
+} from './featureFlagLocalEvaluation'
 export {
   gzipCompress,
   isGzipData,

package/src/logs/index.spec.ts

@@ -1,4 +1,5 @@
 import { PostHogPersistedProperty } from '../types'
+import { createTestClient, PostHogCoreTestClient } from '../testing'
 import type { Logger } from '../types'
 import { PostHogLogs } from './index'
 import type { BufferedLogEntry, ResolvedPostHogLogsConfig } from './types'
@@ -80,6 +81,82 @@ const getContextFor = (instance: any) => (): { distinctId?: string; sessionId?:
   sessionId: instance.getSessionId() || undefined,
 })
 
+// Drives a real core host rather than a stubbed `_sendLogsBatch`, so the sender's
+// error classification and the queue bookkeeping are exercised together.
+describe('PostHogLogs over the core sender', () => {
+  const createLogsOverCore = (status: number): { logs: PostHogLogs; client: PostHogCoreTestClient } => {
+    const [client, mocks] = createTestClient('TEST_API_KEY', {
+      fetchRetryCount: 0,
+      preloadFeatureFlags: false,
+    })
+    mocks.fetch.mockResolvedValue({
+      status,
+      text: () => Promise.resolve('err'),
+      json: () => Promise.resolve({ status: 'err' }),
+    })
+    const logs = new PostHogLogs(
+      client,
+      resolveForTest(),
+      createMockLogger(),
+      () => ({ distinctId: 'user-123' }),
+      immediateOnReady
+    )
+    return { logs, client }
+  }
+
+  const queueOf = (client: PostHogCoreTestClient): BufferedLogEntry[] =>
+    client.getPersistedProperty<BufferedLogEntry[]>(PostHogPersistedProperty.LogsQueue) ?? []
+
+  it.each([408, 429, 500, 503])('keeps records queued when the endpoint answers %i', async (status) => {
+    const { logs, client } = createLogsOverCore(status)
+    logs.captureLog({ body: 'keep me' })
+
+    await expect(logs.flush()).rejects.toHaveProperty('name', 'PostHogFetchHttpError')
+
+    expect(queueOf(client)).toHaveLength(1)
+  })
+
+  it('retains and resends records after transport retries are exhausted', async () => {
+    jest.useRealTimers()
+    const [client, mocks] = createTestClient('TEST_API_KEY', {
+      fetchRetryCount: 2,
+      fetchRetryDelay: 1,
+      preloadFeatureFlags: false,
+    })
+    const unavailableResponse = { status: 503, text: async () => 'unavailable', json: async () => ({}) }
+    mocks.fetch
+      .mockResolvedValueOnce(unavailableResponse)
+      .mockResolvedValueOnce(unavailableResponse)
+      .mockResolvedValueOnce(unavailableResponse)
+      .mockResolvedValueOnce({ status: 200, text: async () => 'ok', json: async () => ({}) })
+    const logs = new PostHogLogs(
+      client,
+      resolveForTest(),
+      createMockLogger(),
+      () => ({ distinctId: 'user-123' }),
+      immediateOnReady
+    )
+
+    logs.captureLog({ body: 'retry me' })
+    await expect(logs.flush()).rejects.toHaveProperty('name', 'PostHogFetchHttpError')
+    expect(mocks.fetch).toHaveBeenCalledTimes(3)
+    expect(queueOf(client)).toHaveLength(1)
+
+    await expect(logs.flush()).resolves.toBeUndefined()
+    expect(mocks.fetch).toHaveBeenCalledTimes(4)
+    expect(queueOf(client)).toHaveLength(0)
+  })
+
+  it('drops the batch when the endpoint answers 401', async () => {
+    const { logs, client } = createLogsOverCore(401)
+    logs.captureLog({ body: 'unauthorized' })
+
+    await expect(logs.flush()).rejects.toHaveProperty('name', 'PostHogFetchHttpError')
+
+    expect(queueOf(client)).toHaveLength(0)
+  })
+})
+
 describe('PostHogLogs', () => {
   let mockInstance: any
   let logger: Logger

package/src/logs/index.ts

@@ -262,7 +262,7 @@ export class PostHogLogs {
       }
 
       if (outcome.kind === 'retry-later') {
-        // Network error: keep records in the queue for the next flush cycle
+        // Transient failure: keep records in the queue for the next flush cycle
         // and surface the error so the caller can log/react.
         throw outcome.error
       }

package/src/posthog-core-stateless.ts

@@ -222,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
  */
@@ -238,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',
@@ -1633,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 = {
@@ -1680,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>(

package/src/surveys/index.ts

@@ -18,3 +18,4 @@ export {
 } from './translations'
 export { canSurveyActivateRepeatedly, doesSurveyActivateByEvent, isSurveyIterationBased } from './activation'
 export { getSurveyIterationKey, isSurveyKeyForSurvey, type SurveyWithIteration } from './keys'
+export { isMatchingRegex, isValidRegex, matchPropertyFilters, propertyComparisons } from './property-matching'