Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@1f0708185b62148df446e0bd5c5f67905afeac2b

Author: github-actions[bot]

bun.lock

@@ -26,6 +26,46 @@ describe('serializeLogData', () => {
     expect(row.error.cause.code).toBe('57014')
   })
 
+  // The 2026-10-02 ad-revenue rollup failure: a bulk insert's DrizzleQueryError
+  // was 522 KB of SQL and params, the row was cut at the data cap, and the
+  // Postgres reason on `cause` never reached Axiom.
+  test('a huge failed query keeps its cause and drops the payload', () => {
+    const cause = Object.assign(
+      new Error('insert or update violates foreign key constraint'),
+      { code: '23503', constraint_name: 'ad_revenue_user_daily_user_id_fk' },
+    )
+    const placeholders = Array.from({ length: 25_000 }, (_, i) => `$${i + 1}`)
+    const query = `insert into "ad_revenue_user_daily" values (${placeholders.join(', ')})`
+    const params = Array.from({ length: 25_000 }, (_, i) => `user-${i}`)
+    const error = Object.assign(
+      new Error(`Failed query: ${query}\nparams: ${params.join(',')}`, {
+        cause,
+      }),
+      { query, params },
+    )
+    const serialized = serializeLogData({ error })!
+    expect(serialized.length).toBeLessThan(10_000)
+    const row = JSON.parse(serialized)
+    expect(row._truncated).toBeUndefined()
+    expect(row.error.cause.code).toBe('23503')
+    expect(row.error.cause.constraint_name).toBe(
+      'ad_revenue_user_daily_user_id_fk',
+    )
+    expect(
+      row.error.query.startsWith('insert into "ad_revenue_user_daily"'),
+    ).toBe(true)
+    expect(row.error.params).toBe('[25000 params omitted]')
+    expect(row.error.message.length).toBeLessThan(2_100)
+  })
+
+  test('a short failed query keeps its params', () => {
+    const error = Object.assign(new Error('Failed query: select $1'), {
+      query: 'select $1',
+      params: ['x'],
+    })
+    expect(parse({ error }).error.params).toEqual(['x'])
+  })
+
   test('trims a long stack', () => {
     const error = new Error('deep')
     error.stack = `Error: deep\n${'    at frame (file.ts:1:1)\n'.repeat(500)}`

common/src/util/__tests__/log-data.test.ts

@@ -23,6 +23,23 @@ export const LOG_LEVEL_ORDER: Record<LogLevel, number> = {
 
 /** Stack traces cost ingest on every error row; the top frames carry it. */
 const MAX_ERROR_STACK_CHARS = 2_000
+/** An error message or SQL statement longer than this is a payload, not a reason. */
+const MAX_ERROR_MESSAGE_CHARS = 2_000
+const MAX_ERROR_QUERY_CHARS = 500
+
+function safeLength(value: unknown): number {
+  try {
+    return JSON.stringify(value)?.length ?? 0
+  } catch {
+    return Number.POSITIVE_INFINITY
+  }
+}
+
+function clip(text: string, max: number): string {
+  return text.length > max
+    ? `${text.slice(0, max)}… [${text.length - max} chars omitted]`
+    : text
+}
 
 /**
  * An Error as plain JSON. `name`, `message` and `stack` are non-enumerable, so
@@ -34,10 +51,27 @@ const MAX_ERROR_STACK_CHARS = 2_000
  * same replacer.
  */
 function errorToJson(error: Error): Record<string, unknown> {
+  const fields: Record<string, unknown> = { ...error }
+  // A drizzle `DrizzleQueryError` carries the whole statement as `query`, every
+  // bound value as `params`, and both again in `message`. For a bulk insert
+  // that is hundreds of KB: the ad-revenue rollup's 2026-10-02 failure logged
+  // 522 KB, the row was cut at MAX_LOG_DATA_BYTES, and the `cause` holding the
+  // Postgres reason came after the cut, so it never reached Axiom. Keep the
+  // head of the statement, replace a long param list with its count, and keep
+  // the cause.
+  if (typeof fields.query === 'string') {
+    fields.query = clip(fields.query, MAX_ERROR_QUERY_CHARS)
+  }
+  if (
+    Array.isArray(fields.params) &&
+    safeLength(fields.params) > MAX_ERROR_QUERY_CHARS
+  ) {
+    fields.params = `[${fields.params.length} params omitted]`
+  }
   return {
-    ...error,
+    ...fields,
     name: error.name,
-    message: error.message,
+    message: clip(error.message, MAX_ERROR_MESSAGE_CHARS),
     ...(error.stack
       ? { stack: error.stack.slice(0, MAX_ERROR_STACK_CHARS) }
       : {}),