@interfere/next 12.0.1 → 12.0.3

package/README.md

@@ -94,6 +94,54 @@ export default function RootLayout({
 
 Upgrade all `@interfere/*` SDK packages together. Keep the env var names, but replace old `int_pub_*` / `interfere_pk_*` values with the dashboard's regional public key, and replace old `ak_*` / `interfere_ak_*` build keys with the regional Interfere secret key.
 
+## Server tracing and Vercel drains
+
+The standard instrumentation export works on Vercel and other Next.js hosts. In `full` mode, Interfere exports application spans directly. When the build config selects `drain`, the Node SDK initializes `@vercel/otel` with its default processors so Vercel can forward application spans through the configured Trace Drain. Platform spans and application spans remain separate observations.
+
+For local development or a deployment that needs direct export despite baked drain configuration, override the mode explicitly:
+
+```ts
+import { register as registerInterfere } from "@interfere/next/instrumentation";
+
+export const register = () => registerInterfere({ serverTracing: "full" });
+export { onRequestError } from "@interfere/next/instrumentation";
+```
+
+The explicit option takes precedence over build-injected and environment settings. Edge always exports directly because Vercel does not forward custom Edge spans through Trace Drains. Edge reads the build-injected release identity, falling back to the configured commit SHA.
+
+### Composing with an existing Vercel OTel setup
+
+Use the kit instead of calling Interfere's standalone `register()` alongside `registerOTel()`. For a Vercel deployment with a configured Trace Drain:
+
+```ts
+import { registerOTel } from "@vercel/otel";
+import { buildInterfereOtelKit } from "@interfere/next/instrumentation";
+
+export function register() {
+  const kit = buildInterfereOtelKit({ serverTracing: "drain" });
+
+  if (!kit) return;
+
+  registerOTel({
+    serviceName: "my-app",
+    attributes: kit.resourceAttributes,
+    idGenerator: kit.idGenerator,
+    spanProcessors: ["auto", ...kit.spanProcessors],
+    logRecordProcessors: kit.logRecordProcessors,
+    propagators: ["auto", kit.traceContextPropagator, ...kit.propagators],
+    instrumentations: ["auto", ...kit.instrumentations],
+  });
+
+  kit.enableConsoleBridge();
+}
+
+export { onRequestError } from "@interfere/next/instrumentation";
+```
+
+Keep `"auto"` in `spanProcessors` for Vercel drain delivery. For direct Interfere export through a customer-owned provider, use `serverTracing: "full"` and `spanProcessors: kit.spanProcessors` to choose a single export path. The host owns flushing and shutdown in composed setups.
+
+`@vercel/otel@2.1.3` supports OTel API `>=1.9.0 <2`, stable SDK peers `>=2 <3`, and experimental peers `>=0.200.0 <0.300.0`. The SDK declares all required peers as dependencies, including `sdk-metrics`. Custom compositions must use compatible versions too.
+
 ## Ingest Endpoint
 
 By default the SDK posts telemetry to Interfere's endpoint. Ingest requests never carry cookies. Set `apiHost` to a subdomain of your own site that resolves to Interfere via a DNS record — this survives ad-blockers with no server-side component:
@@ -160,7 +208,7 @@ Identity is automatically cleared when the SDK is closed. Call `identity.clear()
 
 ## Consent Management
 
-By default, all SDK features are active. To gate features behind user consent, pass a `consent` prop to the provider:
+Omitting consent preserves the SDK defaults. To deny analytics and replay from startup, pass `consent: false` to `init()` before mounting the provider. Use the provider’s `consent` prop to keep the current decision synchronized:
 
 ```tsx
 // app/layout.tsx
@@ -191,7 +239,7 @@ export default function RootLayout({
 | `analytics` | Page events, rage clicks, fingerprint | Yes       |
 | `replay`    | Session replay                        | Yes       |
 
-Omitting the `consent` prop preserves consent supplied to `init()`, including later updates through `consent.set()`. If no initial consent was supplied, omitting the prop allows all features. Passing the prop enables only `necessary` plugins and explicitly consented categories.
+Omitting the `consent` prop preserves consent supplied to `init()`, including later updates through `consent.set()`. If no initial consent was supplied, omitting the prop allows all features. Consent controls analytics and replay permission; it does not enable plugins disabled in configuration. Objects replace the current decision, and omitted categories remain allowed. Errors, logs, tracing, and session storage are not disabled by this setting.
 
 ### Imperative API
 
@@ -200,9 +248,10 @@ Use `consent.set()` and `consent.get()` from the `useInterfere` hook:
 ```tsx
 const { consent } = useInterfere();
 
-consent.set({ analytics: true, replay: true }); // selective
-consent.set(); // grant all
-consent.get(); // current state, or null if no gating
+consent.set(false);
+consent.set(true);
+consent.set({ analytics: true, replay: false });
+consent.get();
 ```
 
 ### Integration with consent libraries
@@ -233,7 +282,7 @@ To set consent before React renders (avoiding any window where non-consented plu
 // instrumentation-client.ts
 import { init } from "@interfere/next/instrument-client";
 
-init({ consent: { analytics: false, replay: false } });
+await init({ consent: false });
 ```
 
 The provider's `consent` prop will then keep it in sync as the user updates their preferences.

package/dist/instrument-client.d.mts

@@ -1,10 +1,10 @@
 import { capture, span } from "@interfere/react/api";
 import { Kernel, KernelInternalOptions, KernelOptions, KernelOptions as KernelOptions$1 } from "@interfere/react/internal/kernel";
-import { ConsentCategory, ConsentState, GateableCategory } from "@interfere/types/sdk/plugins/manifest";
+import { ConsentCategory, ConsentInput, ConsentState, GateableCategory } from "@interfere/types/sdk/plugins/manifest";
 //#region src/instrument-client.d.ts
 export declare const close: () => Promise<void>, consent: {
   get: () => import("@interfere/types/sdk/plugins/manifest").ConsentState | null;
-  set: (value?: import("@interfere/types/sdk/plugins/manifest").ConsentState) => void;
+  set: (value?: import("@interfere/types/sdk/plugins/manifest").ConsentInput) => void;
 }, getKernel: () => import("@interfere/react/internal/kernel").Kernel, getKernelOrNull: () => import("@interfere/react/internal/kernel").Kernel | null, identity: {
   clear: () => void;
   get: () => import("@interfere/types/sdk/identify").IdentifyParams | null;
@@ -12,4 +12,4 @@ export declare const close: () => Promise<void>, consent: {
 }, subscribeToKernel: (listener: () => void) => () => void;
 export declare function init(opts?: KernelOptions$1): Promise<import("@interfere/react/internal/kernel").Kernel | null>;
 //#endregion
-export { type ConsentCategory, type ConsentState, type GateableCategory, type Kernel, type KernelInternalOptions, type KernelOptions, capture, span };
+export { type ConsentCategory, type ConsentInput, type ConsentState, type GateableCategory, type Kernel, type KernelInternalOptions, type KernelOptions, capture, span };

package/dist/instrumentation.d.mts

@@ -1,124 +1,37 @@
+import { PrerenderSafeIdGenerator } from "./internal/server/id-generator.mjs";
 import { ServerInstrumentationOptions } from "./internal/server/instrumentation-options.mjs";
 import { onRequestError } from "./internal/server/capture.mjs";
-import { PrerenderSafeIdGenerator } from "./internal/server/id-generator.mjs";
 import { AttributeValue, TextMapPropagator } from "@opentelemetry/api";
 import { SpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { Instrumentation } from "@opentelemetry/instrumentation";
 import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
 //#region src/instrumentation.d.ts
 export declare function flush(): Promise<void>;
-/**
- * Composable building blocks the Interfere SDK contributes to OTel —
- * span / log / metric processors, baggage propagator, plus the
- * resource attributes and side-effect installers (console bridge +
- * remote-config fetch).
- *
- * Use this when you want to plug Interfere into an existing OTel
- * bootstrap (e.g. `@vercel/otel`'s `registerOTel({...})`, DataDog's
- * `dd-trace-js`, or any custom `NodeTracerProvider` setup) instead of
- * the standalone `register()` path. The kit holds no global state and
- * touches no global slots — composition is the consumer's job.
- *
- * The standalone `register()` builds the kit internally and wires it
- * into private providers, so customer DX stays a one-liner export.
- *
- * Returns `null` when `INTERFERE_PUBLIC_KEY` is unset — callers can spread
- * `kit?.spanProcessors ?? []` without a no-op guard.
- */
+/** OTel components for a customer-owned provider. The kit does not register global providers. */
 export interface InterfereOtelKit {
-  /**
-   * Patches `console.{debug,log,info,warn,error}` to also emit OTel
-   * `LogRecord`s via the global `LoggerProvider`. Caller is responsible
-   * for ensuring a `LoggerProvider` is registered globally before
-   * calling — `register()` handles this; for composed setups, call
-   * after your bootstrap (`registerOTel({...})` etc.) has run. Returns
-   * a disposer that restores the original `console.*` methods.
-   */
+  /** Call after registering a global logger provider; returns a disposer that restores console methods. */
   enableConsoleBridge: () => () => void;
-  /**
-   * Fetches the SDK's remote plugin config and caches it for the
-   * runtime. Customer code's `isPluginEnabled(...)` checks read from
-   * the cache. Safe to call repeatedly.
-   */
+  /** Fetches and caches remote plugin configuration. Safe to call repeatedly. */
   fetchRemoteConfig: () => Promise<void>;
-  /**
-   * Instrumentations the SDK ships. Currently empty — outbound HTTP
-   * spans come from Next.js's own `patchFetch` (App Router) or
-   * `@vercel/otel`'s fetch wrap, so we don't layer a redundant undici
-   * instrumentation and stay off the request hot path. Kept in the
-   * kit shape for forward-compatibility with composed setups that
-   * spread `[...kit.instrumentations, ...]` into `registerOTel({...})`.
-   */
+  idGenerator: PrerenderSafeIdGenerator;
+  /** Currently empty: Next.js or the host provider supplies outbound HTTP instrumentation. */
   instrumentations: Instrumentation[];
+  traceContextPropagator: TextMapPropagator;
   logRecordProcessors: LogRecordProcessor[];
   /**
-   * W3C baggage propagator plus the SDK's `tracestate` freshness
-   * stamper (guards browsers against stitching onto ISR/CDN-cached
-   * trace context). Trace context itself is intentionally *not*
-   * included — `@vercel/otel`'s `propagators: ["auto"]` already
-   * registers it, and standalone `register()` adds it itself when
-   * the global slot is empty. Spread these *after* your trace-context
-   * propagator (e.g. `propagators: ["auto", ...kit.propagators]`) so
-   * the freshness stamp wins the `tracestate` write.
+   * Baggage and freshness propagators. Compose in this order:
+   * `propagators: ["auto", kit.traceContextPropagator, ...kit.propagators]`.
+   * The cache-safe trace-context propagator suppresses cached render metadata;
+   * the freshness propagator must run last to stamp dynamic renders.
    */
   propagators: TextMapPropagator[];
-  /**
-   * Pre-built resource attribute set. Pass into your provider's
-   * `Resource` directly, or into `@vercel/otel`'s `attributes` field
-   * (which merges with Vercel's own auto-detected `vercel.*` attrs).
-   */
+  /** Pass to the provider's resource or Vercel's `attributes` option. */
   resourceAttributes: Record<string, AttributeValue>;
   spanProcessors: SpanProcessor[];
 }
-/**
- * Pure factory — no global registration, no provider construction. Returns
- * the OTel primitives the SDK contributes so a host bootstrap (Vercel,
- * DataDog, custom) can compose them in.
- *
- * Returns `null` when `INTERFERE_PUBLIC_KEY` isn't set, so callers can
- * unconditionally spread `kit?.spanProcessors ?? []` in dev where the
- * SDK isn't configured.
- */
+/** Builds components without registering providers. Returns null when INTERFERE_PUBLIC_KEY is unset. */
 export declare function buildInterfereOtelKit(opts?: ServerInstrumentationOptions): InterfereOtelKit | null;
-/**
- * One-line server-side bootstrap for Next.js. Customers' `instrumentation.ts`
- * becomes:
- *
- * ```ts
- * export { register } from "@interfere/next/instrumentation";
- * ```
- *
- * Or, with overrides:
- *
- * ```ts
- * import { register as base } from "@interfere/next/instrumentation";
- * export const register = () => base({ serviceName: "@my-org/api" });
- * ```
- *
- * Customers who already run another OTel bootstrap (`@vercel/otel`,
- * DataDog `dd-trace-js`, custom `NodeTracerProvider`) should use
- * `buildInterfereOtelKit({...})` instead and compose the returned
- * processors / readers / propagators into their existing setup —
- * see the kit's JSDoc for examples.
- *
- * Constructs private `NodeTracerProvider` / `LoggerProvider` /
- * `MeterProvider` and registers them on the global slots. Last writer
- * wins on the globals, so customers running another OTel bootstrap
- * alongside this one will end up with whichever booted last; the kit
- * path avoids that fight entirely.
- *
- * Wired against the Node OTel SDK (`NodeTracerProvider`,
- * `AsyncLocalStorageContextManager`) — so this entry only ships into the
- * `nodejs` runtime bundle. The Edge runtime gets the no-op stub at
- * `instrumentation.edge.ts` via `package.json`'s `edge-light` /
- * `workerd` export conditions.
- *
- * Idempotent — repeat calls (e.g. HMR) short-circuit on the
- * module-scoped `registered` flag.
- *
- * Bails silently when `INTERFERE_PUBLIC_KEY` is unset so dev runs without
- * the SDK configured don't crash.
- */
+/** Registers standalone tracing, using Vercel's runtime export path in drain mode. Use the kit when another bootstrap owns the provider. */
 export declare function register(opts?: ServerInstrumentationOptions): Promise<void>;
 //#endregion
 export { PrerenderSafeIdGenerator, type ServerInstrumentationOptions, onRequestError };

package/dist/instrumentation.edge.d.mts

@@ -11,12 +11,7 @@ import { InterfereOtelKit } from "./instrumentation.mjs";
  * console bridge) can't run on edge, so this builds an edge-safe pipeline
  * instead: a
  * `BasicTracerProvider` + `SimpleSpanProcessor` exporting via {@link FetchTraceExporter}.
- * Under `serverTracing: "drain"` the exporter is omitted and traces come from
- * the platform trace drain instead — the provider is still registered so
- * `onRequestError` can record exception events on the active span.
- *
- * Release slug is `LOCAL_DEV_RELEASE_SLUG` under force-enable (dev); a
- * build-baked slug for production edge is a follow-up.
+ * Edge always exports directly because Vercel Trace Drains do not forward custom Edge spans.
  */
 export declare function register(opts?: ServerInstrumentationOptions): Promise<void>;
 /**

package/dist/instrumentation.edge.mjs

@@ -1 +1 @@
-import{readInterfereEnv}from"./internal/env.mjs";import{PRODUCER_VERSION}from"./internal/version.mjs";import{FetchTraceExporter}from"./internal/server/edge-exporter.mjs";import{setServerFlush}from"./internal/server/server-flush.mjs";import{onRequestError}from"./internal/server/capture.mjs";import{omitUndefined}from"@interfere/helpers/omit-undefined";import{LOCAL_DEV_RELEASE_SLUG}from"@interfere/types/releases/slug";import{readServerTracingMode}from"@interfere/types/sdk/server-tracing";import{trace}from"@opentelemetry/api";import{resourceFromAttributes}from"@opentelemetry/resources";import{BasicTracerProvider,SimpleSpanProcessor}from"@opentelemetry/sdk-trace-base";let registered=!1;async function register(opts={}){if(registered)return Promise.resolve();let env=readInterfereEnv();if(!env.publicKey)return Promise.resolve();let releaseSlug=process.env.NEXT_PUBLIC_INTERFERE_FORCE_ENABLE?LOCAL_DEV_RELEASE_SLUG:null;releaseSlug||console.warn(`[interfere] edge runtime has no build-baked release.slug; the collector will reject edge spans until one is wired (production follow-up).`);let isDrainMode=readServerTracingMode()===`drain`;isDrainMode&&console.info(`[interfere] edge server tracing in drain mode; SDK trace exporter disabled — server traces come from the platform trace drain.`);let provider=new BasicTracerProvider({resource:resourceFromAttributes(omitUndefined({"deployment.environment.name":env.nodeEnvironment,"interfere.sdk.name":`@interfere/next`,"interfere.sdk.version":PRODUCER_VERSION,"service.name":opts.serviceName??`interfere-sdk-next-edge`,"service.namespace":`interfere`,"telemetry.sdk.language":`nodejs`,"release.slug":releaseSlug||void 0})),spanProcessors:isDrainMode?[]:[new SimpleSpanProcessor(new FetchTraceExporter({baseUrl:env.apiUrl,publicKeyHeader:{apiKey:env.publicKey},headers:{"x-interfere-producer-version":PRODUCER_VERSION}}))]});return trace.setGlobalTracerProvider(provider),setServerFlush(async()=>provider.forceFlush()),registered=!0,Promise.resolve()}function buildInterfereOtelKit(_opts={}){return null}export{buildInterfereOtelKit,onRequestError,register};
+import{readInterfereEnv}from"./internal/env.mjs";import{resolveReleaseSlug}from"./internal/release-slug.mjs";import{PRODUCER_VERSION}from"./internal/version.mjs";import{FetchTraceExporter}from"./internal/server/edge-exporter.mjs";import{setServerFlush}from"./internal/server/server-flush.mjs";import{onRequestError}from"./internal/server/capture.mjs";import{omitUndefined}from"@interfere/helpers/omit-undefined";import{LOCAL_DEV_RELEASE_SLUG}from"@interfere/types/releases/slug";import{getStringFromEnv}from"@opentelemetry/core";import{trace}from"@opentelemetry/api";import{defaultServiceName,resourceFromAttributes}from"@opentelemetry/resources";import{BasicTracerProvider,SimpleSpanProcessor}from"@opentelemetry/sdk-trace-base";let registered=!1;async function register(opts={}){if(registered)return Promise.resolve();let env=readInterfereEnv();if(!env.publicKey)return Promise.resolve();let releaseSlug=process.env.NEXT_PUBLIC_INTERFERE_FORCE_ENABLE?LOCAL_DEV_RELEASE_SLUG:resolveReleaseSlug().slug;releaseSlug||console.warn(`[interfere] edge runtime has no release.slug; configure a build release or INTERFERE_SOURCE_ID.`);let provider=new BasicTracerProvider({resource:resourceFromAttributes(omitUndefined({"deployment.environment.name":env.nodeEnvironment,"interfere.sdk.name":`@interfere/next`,"interfere.sdk.version":PRODUCER_VERSION,"service.name":opts.serviceName||getStringFromEnv(`OTEL_SERVICE_NAME`)||defaultServiceName(),"service.namespace":opts.serviceNamespace,"telemetry.sdk.language":`nodejs`,"release.slug":releaseSlug||void 0})),spanProcessors:[new SimpleSpanProcessor(new FetchTraceExporter({baseUrl:env.apiUrl,publicKeyHeader:{apiKey:env.publicKey},headers:{"x-interfere-producer-version":PRODUCER_VERSION}}))]});return trace.setGlobalTracerProvider(provider),setServerFlush(async()=>provider.forceFlush()),registered=!0,Promise.resolve()}function buildInterfereOtelKit(_opts={}){return null}export{buildInterfereOtelKit,onRequestError,register};

package/dist/instrumentation.mjs

@@ -1 +1 @@
-import{readInterfereEnv}from"./internal/env.mjs";import{resolveReleaseSlug}from"./internal/release-slug.mjs";import{PRODUCER_VERSION}from"./internal/version.mjs";import{setServerFlush}from"./internal/server/server-flush.mjs";import{fetchAndCacheRemoteConfig}from"./internal/server/remote-config.mjs";import{onRequestError}from"./internal/server/capture.mjs";import{CacheSafeTraceContextPropagator}from"./internal/server/cache-safe-trace-context.mjs";import{bridgeConsoleToOtel}from"./internal/server/console-bridge.mjs";import{FreshnessStampingPropagator}from"./internal/server/freshness-propagator.mjs";import{installGlobalHandlers}from"./internal/server/global-handlers.mjs";import{PrerenderSafeIdGenerator}from"./internal/server/id-generator.mjs";import{drainUrl}from"@interfere/constants/api";import{omitUndefined}from"@interfere/helpers/omit-undefined";import{readServerTracingMode}from"@interfere/types/sdk/server-tracing";import{propagation}from"@opentelemetry/api";import{resourceFromAttributes}from"@opentelemetry/resources";import{BatchSpanProcessor}from"@opentelemetry/sdk-trace-base";import{CompositePropagator,W3CBaggagePropagator}from"@opentelemetry/core";import{readLogSourcingMode}from"@interfere/types/sdk/log-sourcing";import{BaggageSpanProcessor}from"@opentelemetry/baggage-span-processor";import{AsyncLocalStorageContextManager}from"@opentelemetry/context-async-hooks";import{OTLPLogExporter}from"@opentelemetry/exporter-logs-otlp-http";import{OTLPTraceExporter}from"@opentelemetry/exporter-trace-otlp-http";import{registerInstrumentations}from"@opentelemetry/instrumentation";import{CompressionAlgorithm}from"@opentelemetry/otlp-exporter-base";import{BatchLogRecordProcessor,LoggerProvider}from"@opentelemetry/sdk-logs";import{NodeTracerProvider}from"@opentelemetry/sdk-trace-node";const EXPORT_TIMEOUT_MS=2e3;let registered=!1,tracerProvider=null,loggerProvider=null;async function flush(){await Promise.all([tracerProvider?.forceFlush(),loggerProvider?.forceFlush()])}function buildInterfereOtelKit(opts={}){let env=readInterfereEnv();if(!env.publicKey)return null;let{slug:releaseSlug}=resolveReleaseSlug();releaseSlug||console.warn("[interfere] No commit SHA available; server spans will ship without `release.slug`. Set `INTERFERE_SOURCE_ID` (or any of `VERCEL_GIT_COMMIT_SHA`, `GITHUB_SHA`) on the runtime env.");let tracesUrl=drainUrl(env.apiUrl,`traces`,env.publicKey),logsUrl=drainUrl(env.apiUrl,`logs`,env.publicKey),exporterHeaders={"x-interfere-producer-version":PRODUCER_VERSION},resourceAttributes=omitUndefined({"deployment.environment.name":env.nodeEnvironment,"interfere.sdk.name":`@interfere/next`,"interfere.sdk.version":PRODUCER_VERSION,"service.name":opts.serviceName??`interfere-sdk-next-server`,"service.namespace":`interfere`,"telemetry.sdk.language":`nodejs`,"release.slug":releaseSlug||void 0}),compression=opts.compression===`gzip`?CompressionAlgorithm.GZIP:CompressionAlgorithm.NONE,isDrainMode=readServerTracingMode()===`drain`,spanProcessors=[new BaggageSpanProcessor(()=>!0),...isDrainMode?[]:[new BatchSpanProcessor(new OTLPTraceExporter({compression,headers:exporterHeaders,timeoutMillis:EXPORT_TIMEOUT_MS,url:tracesUrl}))],...opts._internalAdditionalSpanProcessors??[]],isLogDrainMode=readLogSourcingMode()===`drain`;return{enableConsoleBridge:()=>isLogDrainMode?()=>{}:bridgeConsoleToOtel(),fetchRemoteConfig:async()=>fetchAndCacheRemoteConfig(),instrumentations:[],logRecordProcessors:[...isLogDrainMode?[]:[new BatchLogRecordProcessor({exporter:new OTLPLogExporter({compression,headers:exporterHeaders,timeoutMillis:EXPORT_TIMEOUT_MS,url:logsUrl})})],...opts._internalAdditionalLogRecordProcessors??[]],propagators:[new FreshnessStampingPropagator,new W3CBaggagePropagator],resourceAttributes,spanProcessors}}async function register(opts={}){if(registered)return;let kit=buildInterfereOtelKit(opts);if(!kit)return;readServerTracingMode()===`drain`&&console.info(`[interfere] server tracing in drain mode; SDK trace exporter disabled — server traces come from the platform trace drain.`);let resource=resourceFromAttributes(kit.resourceAttributes);tracerProvider=new NodeTracerProvider({idGenerator:new PrerenderSafeIdGenerator,resource,spanProcessors:kit.spanProcessors}),propagation.fields().length===0&&propagation.setGlobalPropagator(new CompositePropagator({propagators:[new CacheSafeTraceContextPropagator,...kit.propagators]})),tracerProvider.register({contextManager:new AsyncLocalStorageContextManager().enable()}),loggerProvider=new LoggerProvider({processors:kit.logRecordProcessors,resource});let{logs:logsApi}=await import(`@opentelemetry/api-logs`);logsApi.setGlobalLoggerProvider(loggerProvider),registerInstrumentations({instrumentations:kit.instrumentations,tracerProvider}),opts.consoleBridge!==!1&&kit.enableConsoleBridge(),installGlobalHandlers({captureUncaughtException:opts.captureUncaughtException??!0,captureUnhandledRejection:opts.captureUnhandledRejection??!0,exitOnUncaughtException:process.env.NODE_ENV===`production`,flush}),setServerFlush(flush),registered=!0}export{PrerenderSafeIdGenerator,buildInterfereOtelKit,flush,onRequestError,register};
+import{readInterfereEnv}from"./internal/env.mjs";import{resolveReleaseSlug}from"./internal/release-slug.mjs";import{PRODUCER_VERSION}from"./internal/version.mjs";import{setServerFlush}from"./internal/server/server-flush.mjs";import{fetchAndCacheRemoteConfig}from"./internal/server/remote-config.mjs";import{onRequestError}from"./internal/server/capture.mjs";import{CacheSafeTraceContextPropagator}from"./internal/server/cache-safe-trace-context.mjs";import{bridgeConsoleToOtel}from"./internal/server/console-bridge.mjs";import{FreshnessStampingPropagator}from"./internal/server/freshness-propagator.mjs";import{installGlobalHandlers}from"./internal/server/global-handlers.mjs";import{PrerenderSafeIdGenerator}from"./internal/server/id-generator.mjs";import{drainUrl}from"@interfere/constants/api";import{omitUndefined}from"@interfere/helpers/omit-undefined";import{CompositePropagator,W3CBaggagePropagator,getStringFromEnv}from"@opentelemetry/core";import{ProxyTracerProvider,propagation,trace}from"@opentelemetry/api";import{defaultServiceName,resourceFromAttributes}from"@opentelemetry/resources";import{BatchSpanProcessor}from"@opentelemetry/sdk-trace-base";import{readLogSourcingMode}from"@interfere/types/sdk/log-sourcing";import{readServerTracingMode}from"@interfere/types/sdk/server-tracing";import{BaggageSpanProcessor}from"@opentelemetry/baggage-span-processor";import{AsyncLocalStorageContextManager}from"@opentelemetry/context-async-hooks";import{OTLPLogExporter}from"@opentelemetry/exporter-logs-otlp-http";import{OTLPTraceExporter}from"@opentelemetry/exporter-trace-otlp-http";import{registerInstrumentations}from"@opentelemetry/instrumentation";import{CompressionAlgorithm}from"@opentelemetry/otlp-exporter-base";import{BatchLogRecordProcessor,LoggerProvider}from"@opentelemetry/sdk-logs";import{NodeTracerProvider}from"@opentelemetry/sdk-trace-node";const EXPORT_TIMEOUT_MS=2e3;function canFlush(provider){return`forceFlush`in provider&&typeof provider.forceFlush==`function`}let registered=!1,tracerProvider=null,loggerProvider=null;async function flush(){await Promise.all([tracerProvider?.forceFlush(),loggerProvider?.forceFlush()])}function buildInterfereOtelKit(opts={}){let env=readInterfereEnv();if(!env.publicKey)return null;let{slug:releaseSlug}=resolveReleaseSlug();releaseSlug||console.warn("[interfere] No commit SHA available; server spans will ship without `release.slug`. Set `INTERFERE_SOURCE_ID` (or any of `VERCEL_GIT_COMMIT_SHA`, `GITHUB_SHA`) on the runtime env.");let tracesUrl=drainUrl(env.apiUrl,`traces`,env.publicKey),logsUrl=drainUrl(env.apiUrl,`logs`,env.publicKey),exporterHeaders={"x-interfere-producer-version":PRODUCER_VERSION},resourceAttributes=omitUndefined({"deployment.environment.name":env.nodeEnvironment,"interfere.sdk.name":`@interfere/next`,"interfere.sdk.version":PRODUCER_VERSION,"service.name":opts.serviceName||getStringFromEnv(`OTEL_SERVICE_NAME`)||defaultServiceName(),"service.namespace":opts.serviceNamespace,"telemetry.sdk.language":`nodejs`,"release.slug":releaseSlug||void 0}),compression=opts.compression===`gzip`?CompressionAlgorithm.GZIP:CompressionAlgorithm.NONE,isDrainMode=(opts.serverTracing??readServerTracingMode())===`drain`,spanProcessors=[new BaggageSpanProcessor(()=>!0),...isDrainMode?[]:[new BatchSpanProcessor(new OTLPTraceExporter({compression,headers:exporterHeaders,timeoutMillis:EXPORT_TIMEOUT_MS,url:tracesUrl}))],...opts._internalAdditionalSpanProcessors??[]],isLogDrainMode=readLogSourcingMode()===`drain`,logRecordProcessors=[...isLogDrainMode?[]:[new BatchLogRecordProcessor({exporter:new OTLPLogExporter({compression,headers:exporterHeaders,timeoutMillis:EXPORT_TIMEOUT_MS,url:logsUrl})})],...opts._internalAdditionalLogRecordProcessors??[]];return{enableConsoleBridge:()=>isLogDrainMode?()=>{}:bridgeConsoleToOtel(),fetchRemoteConfig:async()=>fetchAndCacheRemoteConfig(),idGenerator:new PrerenderSafeIdGenerator,instrumentations:[],traceContextPropagator:new CacheSafeTraceContextPropagator,logRecordProcessors,propagators:[new FreshnessStampingPropagator,new W3CBaggagePropagator],resourceAttributes,spanProcessors}}async function register(opts={}){if(registered)return;let drainMode=(opts.serverTracing??readServerTracingMode())===`drain`;if(drainMode&&process.env.OTEL_SDK_DISABLED?.trim())return;let kit=buildInterfereOtelKit(opts);if(!kit)return;let resource=resourceFromAttributes(kit.resourceAttributes);if(drainMode){let{registerOTel}=await import(`@vercel/otel`);registerOTel({serviceName:String(kit.resourceAttributes[`service.name`]),attributes:kit.resourceAttributes,idGenerator:kit.idGenerator,instrumentations:kit.instrumentations,propagators:[`auto`,kit.traceContextPropagator,...kit.propagators],spanProcessors:[`auto`,...kit.spanProcessors]});let provider=trace.getTracerProvider(),delegate=provider instanceof ProxyTracerProvider?provider.getDelegate():provider;if(!canFlush(delegate))throw Error(`Interfere could not register the Vercel tracer provider. Use buildInterfereOtelKit with an existing OpenTelemetry bootstrap.`);tracerProvider=delegate}else{let provider=new NodeTracerProvider({idGenerator:kit.idGenerator,resource,spanProcessors:kit.spanProcessors});propagation.fields().length===0&&propagation.setGlobalPropagator(new CompositePropagator({propagators:[kit.traceContextPropagator,...kit.propagators]})),provider.register({contextManager:new AsyncLocalStorageContextManager().enable()}),tracerProvider=provider}loggerProvider=new LoggerProvider({processors:kit.logRecordProcessors,resource});let{logs:logsApi}=await import(`@opentelemetry/api-logs`);logsApi.setGlobalLoggerProvider(loggerProvider),registerInstrumentations({instrumentations:kit.instrumentations,tracerProvider:trace.getTracerProvider()}),opts.consoleBridge!==!1&&kit.enableConsoleBridge(),installGlobalHandlers({captureUncaughtException:opts.captureUncaughtException??!0,captureUnhandledRejection:opts.captureUnhandledRejection??!0,exitOnUncaughtException:process.env.NODE_ENV===`production`,flush}),setServerFlush(flush),registered=!0}export{PrerenderSafeIdGenerator,buildInterfereOtelKit,flush,onRequestError,register};

package/dist/internal/build/value-injection-loader.mjs

@@ -1,2 +1,2 @@
-import{omitUndefined}from"@interfere/helpers/omit-undefined";import{INGEST_URL_GLOBAL}from"@interfere/types/sdk/injected-globals";import{SERVER_TRACING_GLOBAL}from"@interfere/types/sdk/server-tracing";import{PLUGINS_GLOBAL}from"@interfere/types/sdk/remote-config";import{LOG_SOURCING_GLOBAL}from"@interfere/types/sdk/log-sourcing";import{callbackify}from"node:util";import{createBuildConfigResolver}from"@interfere/build/config";const resolveBuildConfig=createBuildConfigResolver();function valueInjectionLoader(userCode){let options=this.getOptions(),callback=this.async(),values=resolveValues(options);callbackify(async()=>{let globals=await resolveRemoteConfig(resolveFetch(options)).catch(()=>({}));return render({...values,...globals},userCode)})(callback)}function remoteGlobals(config){return omitUndefined({[SERVER_TRACING_GLOBAL]:config.serverTracing,[LOG_SOURCING_GLOBAL]:config.logSourcing,[INGEST_URL_GLOBAL]:config.ingestUrl,[PLUGINS_GLOBAL]:config.plugins})}function render(values,userCode){let lines=Object.entries(values).map(([key,value])=>`globalThis[${JSON.stringify(key)}] = ${JSON.stringify(value)};`);return lines.length===0?userCode:`${lines.join(`
+import{omitUndefined}from"@interfere/helpers/omit-undefined";import{INGEST_URL_GLOBAL}from"@interfere/types/sdk/injected-globals";import{PLUGINS_GLOBAL}from"@interfere/types/sdk/remote-config";import{LOG_SOURCING_GLOBAL}from"@interfere/types/sdk/log-sourcing";import{SERVER_TRACING_GLOBAL}from"@interfere/types/sdk/server-tracing";import{callbackify}from"node:util";import{createBuildConfigResolver}from"@interfere/build/config";const resolveBuildConfig=createBuildConfigResolver();function valueInjectionLoader(userCode){let options=this.getOptions(),callback=this.async(),values=resolveValues(options);callbackify(async()=>{let globals=await resolveRemoteConfig(resolveFetch(options)).catch(()=>({}));return render({...values,...globals},userCode)})(callback)}function remoteGlobals(config){return omitUndefined({[SERVER_TRACING_GLOBAL]:config.serverTracing,[LOG_SOURCING_GLOBAL]:config.logSourcing,[INGEST_URL_GLOBAL]:config.ingestUrl,[PLUGINS_GLOBAL]:config.plugins})}function render(values,userCode){let lines=Object.entries(values).map(([key,value])=>`globalThis[${JSON.stringify(key)}] = ${JSON.stringify(value)};`);return lines.length===0?userCode:`${lines.join(`
 `)}\n${userCode}`}async function resolveRemoteConfig(fetchOptions){return fetchOptions?resolveBuildConfig(fetchOptions.apiUrl,fetchOptions.publicKey,fetchOptions.cacheScope).then(remoteGlobals):{}}function parseJson(text){if(typeof text==`string`)try{return JSON.parse(text)}catch{return}}function resolveFetch(options){let parsed=parseJson(options.serializedFetch);return isRemoteConfigFetch(parsed)?parsed:null}function isRemoteConfigFetch(value){return isRecord(value)&&typeof value.apiUrl==`string`&&typeof value.publicKey==`string`&&(value.cacheScope===void 0||typeof value.cacheScope==`string`)}function resolveValues(options){let parsed=parseJson(options.serializedValues);return isRecord(parsed)?parsed:{}}function isRecord(value){return typeof value==`object`&&!!value&&!Array.isArray(value)}export{valueInjectionLoader as default};

package/dist/internal/server/cache-safe-trace-context.d.mts

@@ -1,5 +1,5 @@
-import { Context, TextMapSetter } from "@opentelemetry/api";
 import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { Context, TextMapSetter } from "@opentelemetry/api";
 //#region src/internal/server/cache-safe-trace-context.d.ts
 export interface CacheSafeTraceContextPropagatorOptions {
   isStaticRender?: () => boolean;

package/dist/internal/server/cache-safe-trace-context.mjs

@@ -1 +1 @@
-import{isStaticGenerationRender}from"./static-generation.mjs";import{W3CTraceContextPropagator}from"@opentelemetry/core";var CacheSafeTraceContextPropagator=class extends W3CTraceContextPropagator{isStaticRender;constructor(options={}){super(),this.isStaticRender=options.isStaticRender??isStaticGenerationRender}inject(context,carrier,setter){Array.isArray(carrier)&&this.isStaticRender()||super.inject(context,carrier,setter)}};export{CacheSafeTraceContextPropagator};
+import{isStaticGenerationRender}from"./static-generation.mjs";import{W3CTraceContextPropagator}from"@opentelemetry/core";import{z}from"zod";const metadataEntrySchema=z.object({key:z.string()});var CacheSafeTraceContextPropagator=class extends W3CTraceContextPropagator{isStaticRender;constructor(options={}){super(),this.isStaticRender=options.isStaticRender??isStaticGenerationRender}inject(context,carrier,setter){if(Array.isArray(carrier)){for(let index=carrier.length-1;index>=0;index--){let entry=metadataEntrySchema.safeParse(carrier[index]);entry.success&&(entry.data.key===`traceparent`||entry.data.key===`tracestate`)&&carrier.splice(index,1)}if(this.isStaticRender())return}super.inject(context,carrier,setter)}};export{CacheSafeTraceContextPropagator};

package/dist/internal/server/edge-exporter.d.mts

@@ -1,6 +1,6 @@
+import { ExportResult } from "@opentelemetry/core";
 import { ReadableSpan, SpanExporter } from "@opentelemetry/sdk-trace-base";
 import { InterfereClient } from "@interfere/javascript";
-import { ExportResult } from "@opentelemetry/core";
 //#region src/internal/server/edge-exporter.d.ts
 export declare class FetchTraceExporter implements SpanExporter {
   private readonly client;

package/dist/internal/server/edge-exporter.mjs

@@ -1 +1 @@
-import{InterfereClient}from"@interfere/javascript";import{toError}from"@interfere/types/sdk/errors";import{ExportResultCode}from"@opentelemetry/core";import{JsonTraceSerializer}from"@opentelemetry/otlp-transformer";import{z}from"zod";var FetchTraceExporter=class{client;constructor(options){this.client=new InterfereClient({...options,maxRetries:0,fetch:Object.assign(async(url,init)=>globalThis.fetch(url,{...init,keepalive:!0}),globalThis.fetch)})}export(spans,resultCallback){if(spans.length===0){resultCallback({code:ExportResultCode.SUCCESS});return}let payload=JsonTraceSerializer.serializeRequest(spans);if(!payload||payload.byteLength===0){resultCallback({code:ExportResultCode.SUCCESS});return}(async()=>{try{let body=z.record(z.string(),z.unknown()).parse(JSON.parse(new TextDecoder().decode(payload)));await this.client.drain.otlpExport({signal:`traces`,body}),resultCallback({code:ExportResultCode.SUCCESS})}catch(error){resultCallback({code:ExportResultCode.FAILED,error:toError(error)})}})()}async shutdown(){return Promise.resolve()}async forceFlush(){return Promise.resolve()}};export{FetchTraceExporter};
+import{ExportResultCode}from"@opentelemetry/core";import{InterfereClient}from"@interfere/javascript";import{toError}from"@interfere/types/sdk/errors";import{JsonTraceSerializer}from"@opentelemetry/otlp-transformer";import{z}from"zod";var FetchTraceExporter=class{client;constructor(options){this.client=new InterfereClient({...options,maxRetries:0,fetch:Object.assign(async(url,init)=>globalThis.fetch(url,{...init,keepalive:!0}),globalThis.fetch)})}export(spans,resultCallback){if(spans.length===0){resultCallback({code:ExportResultCode.SUCCESS});return}let payload=JsonTraceSerializer.serializeRequest(spans);if(!payload||payload.byteLength===0){resultCallback({code:ExportResultCode.SUCCESS});return}(async()=>{try{let body=z.record(z.string(),z.unknown()).parse(JSON.parse(new TextDecoder().decode(payload)));await this.client.drain.otlpExport({signal:`traces`,body}),resultCallback({code:ExportResultCode.SUCCESS})}catch(error){resultCallback({code:ExportResultCode.FAILED,error:toError(error)})}})()}async shutdown(){return Promise.resolve()}async forceFlush(){return Promise.resolve()}};export{FetchTraceExporter};

package/dist/internal/server/freshness-propagator.mjs

@@ -1 +1 @@
-import{isStaticGenerationRender}from"./static-generation.mjs";import{isSpanContextValid,trace}from"@opentelemetry/api";import{TraceState,isTracingSuppressed}from"@opentelemetry/core";import{TRACESTATE_FRESHNESS_KEY,freshnessStamp}from"@interfere/types/sdk/trace-freshness";const TRACE_STATE_HEADER=`tracestate`;function carrierHoldsTraceparent(carrier){return carrier.some(entry=>typeof entry==`object`&&!!entry&&`key`in entry&&entry.key===`traceparent`)}var FreshnessStampingPropagator=class{isStaticRender;constructor(options={}){this.isStaticRender=options.isStaticRender??isStaticGenerationRender}inject(context,carrier,setter){let spanContext=trace.getSpanContext(context);if(!spanContext||!isSpanContextValid(spanContext)||isTracingSuppressed(context)||Array.isArray(carrier)&&this.isStaticRender()&&!carrierHoldsTraceparent(carrier))return;let traceState=(spanContext.traceState??new TraceState).set(TRACESTATE_FRESHNESS_KEY,freshnessStamp(Date.now()));setter.set(carrier,TRACE_STATE_HEADER,traceState.serialize())}extract(context){return context}fields(){return[TRACE_STATE_HEADER]}};export{FreshnessStampingPropagator};
+import{isStaticGenerationRender}from"./static-generation.mjs";import{TraceState,isTracingSuppressed}from"@opentelemetry/core";import{isSpanContextValid,trace}from"@opentelemetry/api";import{TRACESTATE_FRESHNESS_KEY,freshnessStamp}from"@interfere/types/sdk/trace-freshness";const TRACE_STATE_HEADER=`tracestate`;function carrierHoldsTraceparent(carrier){return carrier.some(entry=>typeof entry==`object`&&!!entry&&`key`in entry&&entry.key===`traceparent`)}var FreshnessStampingPropagator=class{isStaticRender;constructor(options={}){this.isStaticRender=options.isStaticRender??isStaticGenerationRender}inject(context,carrier,setter){let spanContext=trace.getSpanContext(context);if(!spanContext||!isSpanContextValid(spanContext)||isTracingSuppressed(context)||Array.isArray(carrier)&&this.isStaticRender()&&!carrierHoldsTraceparent(carrier))return;let traceState=(spanContext.traceState??new TraceState).set(TRACESTATE_FRESHNESS_KEY,freshnessStamp(Date.now()));setter.set(carrier,TRACE_STATE_HEADER,traceState.serialize())}extract(context){return context}fields(){return[TRACE_STATE_HEADER]}};export{FreshnessStampingPropagator};

package/dist/internal/server/instrumentation-options.d.mts

@@ -58,9 +58,13 @@ export interface ServerInstrumentationOptions {
    */
   consoleBridge?: boolean;
   /**
-   * Override the OTel `service.name` resource attribute. Defaults to
-   * `"interfere-sdk-next-server"`.
+   * Application service name. Defaults to `OTEL_SERVICE_NAME`, then OTel's
+   * `unknown_service:<executable>` or `unknown_service` when unavailable.
    */
   serviceName?: string;
+  /** Optional application namespace for grouping related services. */
+  serviceNamespace?: string;
+  /** Overrides build-injected and environment tracing settings. Use full for direct export during local development. */
+  serverTracing?: "full" | "drain";
 }
 //#endregion

package/dist/package.mjs

@@ -1 +1 @@
-var name=`@interfere/next`,version=`12.0.1`;export{name,version};
+var name=`@interfere/next`,version=`12.0.3`;export{name,version};

package/dist/provider.d.mts

@@ -1,9 +1,9 @@
 import { PluginOverrides, useInterfere, useSession } from "@interfere/react/provider";
 import { PropsWithChildren } from "react";
-import { ConsentCategory, ConsentState, ConsentState as ConsentState$1, GateableCategory } from "@interfere/types/sdk/plugins/manifest";
+import { ConsentCategory, ConsentInput, ConsentInput as ConsentInput$1, ConsentState, GateableCategory } from "@interfere/types/sdk/plugins/manifest";
 //#region src/provider.d.ts
 interface InterfereProviderProps extends PropsWithChildren {
-  consent?: ConsentState$1 | undefined;
+  consent?: ConsentInput$1 | undefined;
   errorBoundary?: boolean;
   plugins?: PluginOverrides | undefined;
 }
@@ -17,4 +17,4 @@ interface InterfereProviderProps extends PropsWithChildren {
  */
 export declare function InterfereProvider({ children, consent, plugins, errorBoundary }: InterfereProviderProps): import("react").JSX.Element;
 //#endregion
-export { type ConsentCategory, type ConsentState, type GateableCategory, useInterfere, useSession };
+export { type ConsentCategory, type ConsentInput, type ConsentState, type GateableCategory, useInterfere, useSession };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interfere/next",
-  "version": "12.0.1",
+  "version": "12.0.3",
   "description": "Build software that never breaks.",
   "keywords": [
     "error-tracking",
@@ -24,7 +24,9 @@
     "dist"
   ],
   "type": "module",
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/instrumentation-client.mjs"
+  ],
   "exports": {
     "./config": {
       "monorepo": "./src/config.ts",
@@ -89,17 +91,17 @@
   },
   "scripts": {
     "build": "tsdown",
-    "test": "vitest run",
+    "test": "vitest run --config ../../../../vitest.config.ts",
     "test:e2e": "playwright test",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "bun check"
   },
   "dependencies": {
-    "@interfere/build": "^0.2.1",
-    "@interfere/constants": "^9.1.0",
+    "@interfere/build": "^0.2.2",
+    "@interfere/constants": "^9.2.0",
     "@interfere/helpers": "^9.2.0",
     "@interfere/javascript": "^0.2.1",
-    "@interfere/react": "^12.0.1",
-    "@interfere/types": "^10.2.0",
+    "@interfere/react": "^12.0.3",
+    "@interfere/types": "^10.2.1",
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.222.0",
     "@opentelemetry/baggage-span-processor": "^0.5.0",
@@ -112,12 +114,15 @@
     "@opentelemetry/otlp-transformer": "^0.222.0",
     "@opentelemetry/resources": "^2.11.0",
     "@opentelemetry/sdk-logs": "^0.222.0",
+    "@opentelemetry/sdk-metrics": "^2.11.0",
     "@opentelemetry/sdk-trace-base": "^2.11.0",
     "@opentelemetry/sdk-trace-node": "^2.11.0",
+    "@vercel/otel": "2.1.3",
     "chalk": "^6.0.0",
     "zod": "^4.5.4"
   },
   "devDependencies": {
+    "@interfere/test-utils": "^10.0.0",
     "@interfere/typescript-config": "^9.0.2",
     "@interfere/vitest-config": "0.0.0",
     "@playwright/test": "^1.63.0",