Jakob Wennberg
d4f82cafc4
Recapt shuts down in four days, taking product analytics and session replay with it. This adds PostHog Cloud EU alongside it; the Recapt removal follows separately so events can be confirmed landing first. Wiring choices that are not the tutorial defaults: - Same-origin reverse proxy (/rl -> eu.i.posthog.com) instead of adding PostHog hosts to the CSP. connect-src 'self' and script-src 'self' already cover it, tracking blockers have no third-party host to match, and the Recapt allowlist entries in next.config.ts get replaced by nothing at all when they go. Needs skipTrailingSlashRedirect, since PostHog sends trailing-slash API requests; verified that trailing-slash URLs on normal routes still resolve 200 rather than 404. - /rl is excluded from the proxy.ts matcher. Middleware runs BEFORE next.config rewrites, so without this updateSession() treats an ingestion POST as an unknown protected path and 307s it to /login. Verified with a control: /zz/flags/ -> 307 /login, /rl/flags/ -> 200 from PostHog. This fails silently otherwise, because asset loads keep working through the rewrite while no events arrive. - persistence: 'memory' so nothing is written to the device and no cookie-consent banner is required. Everything post-login is unaffected: AnalyticsIdentify re-identifies on each dashboard load. - session_recording.maskTextSelector: '*'. PostHog masks inputs but not text by default, and this app renders org numbers (which for an enskild firma ARE the owner's personnummer), customer names and balances as ordinary text. Replays show where a user gets stuck, never what their books say. buildGroupProperties() also refuses to send org_number at all, with a test pinning it. - Error tracking registers through the existing lib/observability sink rather than bypassing it, so every error-level createLogger() line is captured already redacted. instrumentation.ts onRequestError covers what escapes uncaught. Analytics is hosted-only: isAnalyticsEnabled() short-circuits on NEXT_PUBLIC_SELF_HOSTED and no Docker sentinel is added, so self-hosted runs with zero third-party runtime code. Recapt got that outcome only by accident, via a missing sentinel; here it is explicit and tested. vitest.config.ts aliases 'server-only' to a stub: it is a build-time guard whose real entry point always throws, which broke 48 test files the moment a server-only module entered the graph. request-context.ts was already carrying the same latent trap. Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
88 lines
3.1 KiB
TypeScript
88 lines
3.1 KiB
TypeScript
import type { ObservabilityContext, ObservabilityLevel, ObservabilitySink } from '@/lib/observability'
|
|
import { getPostHogServer, flushAnalytics } from './posthog-server'
|
|
|
|
/**
|
|
* PostHog adapter for the provider-agnostic observability sink.
|
|
*
|
|
* Registering this is what makes `lib/observability` stop being a no-op: from
|
|
* then on every `error`-level line written through `createLogger()`, plus
|
|
* anything flagged `alert: true`, lands in PostHog Error Tracking already
|
|
* correlated with the log line's request context. That is far broader
|
|
* coverage than the `onRequestError` hook in instrumentation.ts, which only
|
|
* sees errors that escape uncaught.
|
|
*
|
|
* Redaction: `lib/observability/sink.ts` redacts both the error and the
|
|
* context before calling an adapter (and the logger has already redacted
|
|
* once; redaction is idempotent). This adapter therefore forwards what it is
|
|
* given and must never re-widen it by reaching for un-redacted sources.
|
|
*
|
|
* The interface requires captureException/captureMessage to be SYNCHRONOUS
|
|
* and to never throw. posthog-node's capture enqueues synchronously and
|
|
* sends afterwards, which fits: `flush()` is the drain the interface asks
|
|
* for, and callers on serverless paths await it.
|
|
*/
|
|
|
|
/** PostHog Error Tracking has no severity axis, so level rides as a property. */
|
|
function toProperties(
|
|
context: ObservabilityContext,
|
|
extra?: Record<string, unknown>
|
|
): Record<string, unknown> {
|
|
return { ...context, ...extra }
|
|
}
|
|
|
|
/**
|
|
* `distinct_id` is a reserved context key set by the logger when a request
|
|
* has an identified user. Without it PostHog would attribute the event to a
|
|
* generated id per event, which fragments the error's person view.
|
|
*/
|
|
function distinctIdFrom(context: ObservabilityContext): string | undefined {
|
|
const raw = context.distinct_id ?? context.user_id ?? context.userId
|
|
return typeof raw === 'string' && raw.length > 0 ? raw : undefined
|
|
}
|
|
|
|
export const postHogSink: ObservabilitySink = {
|
|
name: 'posthog',
|
|
|
|
captureException(error: unknown, context: ObservabilityContext): void {
|
|
try {
|
|
const posthog = getPostHogServer()
|
|
if (!posthog) return
|
|
posthog.captureException(
|
|
error instanceof Error ? error : new Error(String(error)),
|
|
distinctIdFrom(context),
|
|
toProperties(context)
|
|
)
|
|
} catch {
|
|
// Contract: must not throw.
|
|
}
|
|
},
|
|
|
|
captureMessage(message: string, level: ObservabilityLevel, context: ObservabilityContext): void {
|
|
try {
|
|
const posthog = getPostHogServer()
|
|
if (!posthog) return
|
|
const distinctId = distinctIdFrom(context)
|
|
posthog.capture({
|
|
// PostHog requires a distinct id; fall back to a stable server marker
|
|
// rather than inventing a per-event id, which would create a new
|
|
// person for every log line.
|
|
distinctId: distinctId ?? 'server',
|
|
event: '$log',
|
|
properties: toProperties(context, { message, level }),
|
|
})
|
|
} catch {
|
|
// Contract: must not throw.
|
|
}
|
|
},
|
|
|
|
async flush(): Promise<boolean> {
|
|
try {
|
|
await flushAnalytics()
|
|
return true
|
|
} catch {
|
|
// Contract: must never reject.
|
|
return false
|
|
}
|
|
},
|
|
}
|