@depup/sentry__server-utils 10.75.2-depup.0 → 11.0.0-depup.0

package/build/types-ts3.8/redis/redis-dc-subscriber.d.ts

@@ -1,89 +0,0 @@
-import { TracingChannel } from 'node:diagnostics_channel';
-import { Span } from '@sentry/core';
-export declare const REDIS_DC_CHANNEL_COMMAND = "node-redis:command";
-export declare const REDIS_DC_CHANNEL_BATCH = "node-redis:batch";
-export declare const REDIS_DC_CHANNEL_CONNECT = "node-redis:connect";
-export declare const IOREDIS_DC_CHANNEL_COMMAND = "ioredis:command";
-export declare const IOREDIS_DC_CHANNEL_CONNECT = "ioredis:connect";
-/**
- * Shape of the `node-redis:command` channel payload published by node-redis.
- *
- * Both `command` and `args` are already redacted by node-redis itself (see
- * `sanitizeArgs` in @redis/client) using the OTel `redis-common` rules. The
- * arg array is `[<command>, <safe arg>, ..., '?', ...]` — `?` replaces any
- * value the library considers sensitive. Subscribers can emit `args` directly
- * as `db.query.text` without further serialization.
- */
-export interface RedisCommandData {
-    command: string;
-    /** First arg is the command name itself; consumers should slice it off. */
-    args: string[];
-    database?: number;
-    serverAddress?: string;
-    serverPort?: number;
-    result?: unknown;
-    error?: Error;
-}
-/**
- * Shape of the `ioredis:command` channel payload published by ioredis >= 5.11.0.
- *
- * As with node-redis, args are already sanitized by ioredis (`sanitizeArgs` in
- * `lib/tracing.ts`) before publishing. Unlike node-redis, the command name is
- * NOT prepended to `args`.
- */
-export interface IORedisCommandData {
-    command: string;
-    args: string[];
-    batchMode?: 'MULTI';
-    batchSize?: number;
-    database?: number;
-    serverAddress?: string;
-    serverPort?: number;
-    result?: unknown;
-    error?: Error;
-}
-/** Shape of the `node-redis:batch` channel payload published by node-redis. */
-export interface RedisBatchData {
-    batchMode?: 'MULTI' | 'PIPELINE';
-    batchSize?: number;
-    database?: number;
-    clientId?: string | number;
-    serverAddress?: string;
-    serverPort?: number;
-    result?: unknown[];
-    error?: Error;
-}
-/** Shape of the `*:connect` channel payload published by node-redis and ioredis. */
-export interface RedisConnectData {
-    serverAddress?: string;
-    serverPort?: number;
-    url?: string;
-    error?: Error;
-}
-/**
- * Optional callback invoked once the redis command response arrives. Useful
- * for attaching response-derived attributes (e.g. cache hit/miss, payload size).
- *
- * Mirrors `@opentelemetry/instrumentation-ioredis`' response hook so existing
- * Sentry node code (`cacheResponseHook`) can be reused unchanged.
- */
-export type RedisDiagnosticChannelResponseHook = (span: Span, cmdName: string, cmdArgs: string[], result: unknown) => void;
-/**
- * Platform-provided factory that creates a native tracing channel for the given name. The
- * subscriber binds the span and its lifecycle onto the channel via `bindTracingChannelToSpan`,
- * which propagates the active span through the runtime's async context.
- *
- * Both Node and Deno pass `node:diagnostics_channel`'s `tracingChannel` directly.
- */
-export type RedisTracingChannelFactory = <T extends object>(name: string) => TracingChannel<T, T>;
-/**
- * Subscribe Sentry span handlers to node-redis and ioredis diagnostics-channel
- * events: `node-redis:command`/`:batch`/`:connect` (published by node-redis
- * >= 5.12.0) and `ioredis:command`/`:connect` (published by ioredis >= 5.11.0).
- *
- * On older client versions the channels are never published to, so subscribers
- * are inert — there is no double-instrumentation against any IITM-based
- * patcher gated to those older versions.
- */
-export declare function subscribeRedisDiagnosticChannels(tracingChannel: RedisTracingChannelFactory, responseHook?: RedisDiagnosticChannelResponseHook): void;
-//# sourceMappingURL=redis-dc-subscriber.d.ts.map

package/build/types-ts3.8/redis/redis-statement-serializer.d.ts

@@ -1,6 +0,0 @@
-/**
- * Given the redis command name and arguments, return a combination of the
- * command name + the allowed arguments according to `serializationSubsets`.
- */
-export declare const defaultDbStatementSerializer: (cmdName: string, cmdArgs: Array<string | Buffer | number | unknown[]>) => string;
-//# sourceMappingURL=redis-statement-serializer.d.ts.map

package/build/types-ts3.8/tracing-channel.d.ts

@@ -1,75 +0,0 @@
-import { TracingChannel, TracingChannelSubscribers } from 'node:diagnostics_channel';
-import { ExclusiveEventHintOrCaptureContext, Span } from '@sentry/core';
-export type TracingChannelPayloadWithSpan<TData extends object> = TData & {
-    /**
-     * The current active span for the traced call.
-     */
-    _sentrySpan?: Span;
-    /**
-     * The context's active store value, used to restore the context for asyncStart continuations for callback-based tracing.
-     */
-    _sentryCallerStore?: unknown;
-    /** Set by Node's tracing channel when the traced operation failed. */
-    error?: unknown;
-};
-export interface SentryTracingChannel<TData extends object = object> extends Pick<TracingChannel<TData, TracingChannelPayloadWithSpan<TData>>, Exclude<keyof TracingChannel<TData, TracingChannelPayloadWithSpan<TData>>, 'subscribe' | 'unsubscribe'>> {
-    subscribe(subscribers: Partial<TracingChannelSubscribers<TracingChannelPayloadWithSpan<TData>>>): void;
-    unsubscribe(subscribers: Partial<TracingChannelSubscribers<TracingChannelPayloadWithSpan<TData>>>): void;
-}
-export interface TracingChannelLifeCycleOptions<TData extends object = object> {
-    /**
-     * Invoked with the span and the channel context object once the traced operation completes
-     * Use it to enrich the span from the result/error (branch on `'error' in data` / `'result' in data`) or to run cleanup.
-     */
-    beforeSpanEnd?: (span: Span, data: TracingChannelPayloadWithSpan<TData>) => void;
-    /**
-     * Whether a thrown error is captured as a Sentry event. The span is always marked with error status regardless. Defaults to `false`.
-     * You can alternatively pass a function that sets the ExclusiveEventHintOrCaptureContext on the captured error.
-     * Set `true` for instrumentations that own the error boundary, (e.g: route handlers)
-     * For database drivers, it is not recommended to set this at all.
-     */
-    captureError?: boolean | ((e: unknown) => ExclusiveEventHintOrCaptureContext);
-    /**
-     * Take ownership of *when* the span ends: return `true` and the helper won't end it on
-     * `end`/`asyncEnd`. For results that settle out-of-band — e.g. a streamed `EventEmitter` that
-     * completes via its own `'end'`/`'error'` events.
-     *
-     * Call `end` when it settles — `end()` on success, `end(error)` on failure. `end` owns *how* the span
-     * ends (error status/attributes, `captureError`, `beforeSpanEnd`) and is idempotent. Default `false`
-     * lets the helper end the span as usual.
-     */
-    deferSpanEnd?: (args: {
-        span: Span;
-        data: TracingChannelPayloadWithSpan<TData>;
-        /** Ends the span: `end()` on success, `end(error)` on failure (which marks `data` as errored). Idempotent. */
-        end: (error?: unknown) => void;
-    }) => boolean;
-    /**
-     * Apply span/scope binding only if there is a parent span, similar to returning `undefined` in the `getSpan` callback.
-     * If you need to perform some conditional checking on the parent span before deciding, do it in the `getSpan` callback.
-     */
-    requiresParentSpan?: boolean;
-}
-/** Returned by {@link bindTracingChannelToSpan}: the bound channel plus a teardown handle. */
-export interface TracingChannelBindingHandle<TData extends object = object> {
-    /**
-     * The tracing channel with the span bound into async context.
-     */
-    channel: SentryTracingChannel<TData>;
-    /**
-     * Tears down the binding: unsubscribes lifecycle handlers, when present, and unbinds the start store.
-     * Idempotent, and a no-op when no async context binding was available.
-     */
-    unbind: () => void;
-}
-/**
- * Bind a span and its lifecycle to a tracing channel so the span becomes the active async context
- * for the traced operation and is ended when the operation completes.
- *
- * `getSpan` may return `undefined` to opt a payload out entirely: nothing is bound, no span is
- * tracked, and the active context is left untouched. Use it for events that ride the same channel
- * but should reuse the enclosing span instead of opening (and ending) their own — e.g. an agent
- * loop's per-step events, where ending a freshly opened span would close the parent prematurely.
- */
-export declare function bindTracingChannelToSpan<TData extends object>(channel: TracingChannel<TData, TData>, getSpan: (data: TracingChannelPayloadWithSpan<TData>) => Span | undefined, opts?: TracingChannelLifeCycleOptions<TData>): TracingChannelBindingHandle<TData>;
-//# sourceMappingURL=tracing-channel.d.ts.map

package/build/types-ts3.8/vercel-ai/index.d.ts

@@ -1,26 +0,0 @@
-export interface VercelAiOptions {
-    /**
-     * Enable or disable input recording. Enabled if `dataCollection.genAI.inputs` (or the deprecated `sendDefaultPii` option) is `true`
-     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
-     * Integration-level options take precedence over global `dataCollection` config.
-     */
-    recordInputs?: boolean;
-    /**
-     * Enable or disable output recording. Enabled if `dataCollection.genAI.outputs` (or the deprecated `sendDefaultPii` option) is `true`
-     * or if you set `isEnabled` to `true` in your ai SDK method telemetry settings.
-     * Integration-level options take precedence over global `dataCollection` config.
-     */
-    recordOutputs?: boolean;
-    /**
-     * Enable or disable truncation of recorded input messages.
-     * Defaults to `true`.
-     */
-    enableTruncation?: boolean;
-}
-/**
- * Auto-instrument the `ai` SDK's native telemetry tracing channel (ai >= 7).
- */
-export declare const vercelAiIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
-    name: "VercelAI";
-};
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/vercel-ai/util.d.ts

@@ -1,30 +0,0 @@
-/** Shared, state-free helpers for the Vercel AI (`ai`) channel subscribers, plus the streamed model-call tap. */
-/** Narrow to a string, or `undefined` for anything else. */
-export declare function asString(value: unknown): string | undefined;
-/** Narrow to a finite number, or `undefined` for anything else (including `NaN`). */
-export declare function asNumber(value: unknown): number | undefined;
-/** Add two optional numbers, treating a missing operand as `0` but returning `undefined` when both are absent. */
-export declare function sum(a: number | undefined, b: number | undefined): number | undefined;
-/** The aggregate handed back once a streamed model call finishes, in the shape `enrichSpanOnEnd` expects. */
-export interface StreamedModelCallResult {
-    text?: string;
-    toolCalls: Array<Record<string, unknown>>;
-    usage?: unknown;
-    finishReason?: unknown;
-    responseId?: string;
-    responseModel?: string;
-    providerMetadata?: unknown;
-}
-/** A minimal structural check — the streamed model call exposes a web `ReadableStream` on `result.stream`. */
-export declare function isReadableStream(value: unknown): value is ReadableStream<unknown>;
-/**
- * Wrap a streamed model call's `ReadableStream` so its chunks are observed as the SDK consumes them,
- * without altering what the SDK sees. Returns a replacement stream to swap onto `result.stream`.
- *
- * `onFinal` runs exactly once when the stream drains cleanly; `onError` runs exactly once if it errors
- * or is cancelled. Reading one source chunk per `pull` preserves the SDK's backpressure. The
- * `try/catch` around every read guarantees the owning span is always ended — a leaked open span on a
- * mid-stream failure would be worse than a slightly-less-enriched one.
- */
-export declare function tapModelCallStream(stream: ReadableStream<unknown>, onFinal: (result: StreamedModelCallResult) => void, onError: (error: unknown) => void): ReadableStream<unknown>;
-//# sourceMappingURL=util.d.ts.map

package/build/types-ts3.8/vercel-ai/vercel-ai-dc-subscriber.d.ts

@@ -1,72 +0,0 @@
-import { Span } from '@sentry/core';
-import { TracingChannel } from 'node:diagnostics_channel';
-import { StreamedModelCallResult } from './util';
-/** Drop the per-operation `callId` maps once the owning top-level operation settles (success or error). */
-export declare function clearOperationId(data: VercelAiChannelMessage): void;
-/**
- * Drop the per-operation `callId` maps for a single id. The v6 orchestrion adapter uses this to clear a
- * `streamText` operation only after its lazily-run model call settles — the operation's own span ends
- * synchronously (when `streamText` returns) but the model call runs later as the stream is consumed, and
- * it still needs the operation's `operationId`/`isStream` entry to name itself `ai.streamText.doStream`.
- */
-export declare function clearOperationCallId(callId: string): void;
-/** The lifecycle event types the `ai:telemetry` channel can carry. */
-export type ChannelEventType = 'generateText' | 'streamText' | 'generateObject' | 'step' | 'languageModelCall' | 'executeTool' | 'embed' | 'embedMany' | 'rerank';
-/**
- * The context object the AI SDK passes through one tracing-channel call. It is the same object
- * identity across `start`/`end`/`asyncEnd`/`error`, and Node's `tracingChannel` attaches
- * `result`/`error` to it as the traced promise settles.
- */
-export interface VercelAiChannelMessage {
-    type: ChannelEventType;
-    event: Record<string, unknown>;
-    result?: unknown;
-    error?: unknown;
-}
-/**
- * Platform-provided factory that returns a tracing channel for the given channel name. The factory
- * is responsible for, when `start` fires, calling `transformStart(data)` and storing the returned
- * span on `data._sentrySpan` so the subscriber's `asyncEnd`/`error` handlers can read it.
- *
- * Node passes `@sentry/opentelemetry/tracing-channel`, which uses `bindStore` to additionally make
- * the span the active OTel context for the duration of the traced operation. That is what makes
- * nested AI SDK operations (model calls, tool calls) become children of the enclosing span without
- * any manual parent bookkeeping here.
- */
-export type VercelAiTracingChannelFactory = <T extends object>(name: string) => TracingChannel<T, T>;
-/** Integration-level recording options, pinned at subscribe time so we never look the integration up per event. */
-export interface VercelAiChannelOptions {
-    recordInputs?: boolean;
-    recordOutputs?: boolean;
-    enableTruncation?: boolean;
-}
-/**
- * Subscribe Sentry span handlers to the `ai` SDK's native telemetry tracing channel (`ai:telemetry`,
- * available in `ai` >= 7) and emit fully-formed `gen_ai.*` spans directly — no OpenTelemetry span
- * post-processing involved.
- *
- * The integration passes its options in directly (rather than us looking the integration up on every
- * event); the global `dataCollection.genAI` default is still read from the client per event.
- *
- * Safe to always call: on `ai` versions that don't publish to the channel (e.g. < 7) nothing is
- * ever emitted and this is inert, so there is no double-instrumentation against the OTel-based
- * patcher. The integration's `setupOnce` guarantees this runs a single time.
- */
-export declare function subscribeVercelAiTracingChannel(tracingChannel: VercelAiTracingChannelFactory, options?: VercelAiChannelOptions): void;
-/** Map the tapped stream aggregate onto the `languageModelCall` result shape `enrichSpanOnEnd` reads. */
-export declare function streamedResultToChannelResult(final: StreamedModelCallResult): Record<string, unknown>;
-/**
- * Transform a channel `start` payload into the span that should be active for the operation. For
- * `step` we deliberately don't open a span (model calls and tool calls are siblings under the
- * invoke_agent span, matching the OTel-based output), so we reuse the active span and mark the
- * payload to skip ending it.
- */
-export declare function createSpanFromMessage(data: VercelAiChannelMessage, channelOptions: VercelAiChannelOptions): Span | undefined;
-/**
- * Best-effort enrichment from the resolved value the AI SDK attaches to the channel context.
- * Everything here is guarded: when a field is missing or the shape differs across `ai` versions,
- * we simply don't set the attribute rather than emit a malformed span.
- */
-export declare function enrichSpanOnEnd(span: Span, data: VercelAiChannelMessage, channelOptions: VercelAiChannelOptions): void;
-export declare function captureToolError(span: Span, data: VercelAiChannelMessage, error: unknown): void;
-//# sourceMappingURL=vercel-ai-dc-subscriber.d.ts.map

package/build/types-ts3.8/vercel-ai/vercel-ai-orchestrion-subscriber.d.ts

@@ -1,12 +0,0 @@
-import { VercelAiChannelOptions, VercelAiTracingChannelFactory } from './vercel-ai-dc-subscriber';
-/**
- * Subscribe the v6 orchestrion channel adapter. Safe to always call: inert on
- * `ai` >= 7 (those channels are never published) and when orchestrion injection
- * isn't active. Idempotent.
- *
- * `tracingChannel` is the platform-provided factory (the same one passed to
- * `subscribeVercelAiTracingChannel`); `options` pins the recording settings at
- * subscribe time so we never look the integration up per event.
- */
-export declare function subscribeVercelAiOrchestrionChannels(tracingChannel: VercelAiTracingChannelFactory, options?: VercelAiChannelOptions): void;
-//# sourceMappingURL=vercel-ai-orchestrion-subscriber.d.ts.map