@sentry/cloudflare 10.68.0 → 11.0.0-alpha.0

package/build/types-ts3.8/durableobject.d.ts

@@ -1,37 +0,0 @@
-import { DurableObject } from 'cloudflare:workers';
-import { CloudflareOptions } from './client';
-/**
- * Instruments a Durable Object class to capture errors and performance data.
- *
- * Instruments the following methods by default:
- * - fetch
- * - alarm
- * - webSocketMessage
- * - webSocketClose
- * - webSocketError
- *
- * To instrument RPC methods (prototype methods), enable the `enableRpcTracePropagation` option.
- *
- * @param optionsCallback Function that returns the options for the SDK initialization.
- * @param DurableObjectClass The Durable Object class to instrument.
- * @returns The instrumented Durable Object class.
- *
- * @example
- * ```ts
- * class MyDurableObjectBase extends DurableObject {
- *   constructor(ctx: DurableObjectState, env: Env) {
- *     super(ctx, env);
- *   }
- * }
- *
- * export const MyDurableObject = instrumentDurableObjectWithSentry(
- *   env => ({
- *     dsn: env.SENTRY_DSN,
- *     tracesSampleRate: 1.0,
- *   }),
- *   MyDurableObjectBase,
- * );
- * ```
- */
-export declare function instrumentDurableObjectWithSentry<E, T extends DurableObject<E>, C extends new (state: DurableObjectState, env: E) => T>(optionsCallback: (env: E) => CloudflareOptions, DurableObjectClass: C): C;
-//# sourceMappingURL=durableobject.d.ts.map

package/build/types-ts3.8/executionContext.d.ts

@@ -1,13 +0,0 @@
-import { ExecutionContext } from '@cloudflare/workers-types';
-/**
- * A structural subset of `ExecutionContext` that is compatible with both `@cloudflare/workers-types`
- * v4 and v5.
- *
- * v5 added `exports` and `tracing` as required members. Referencing the full `ExecutionContext` in
- * public input positions would force consumers on v4 (still allowed by our `peerDependencies` range)
- * to provide members their types don't have. We only ever use `waitUntil` (plus a runtime
- * `'storage' in ctx` check), so picking the members that exist in both majors keeps a context
- * constructed against either version assignable here.
- */
-export type ExecutionContextCompat = Pick<ExecutionContext, 'waitUntil' | 'passThroughOnException'> | ExecutionContext;
-//# sourceMappingURL=executionContext.d.ts.map

package/build/types-ts3.8/flush.d.ts

@@ -1,47 +0,0 @@
-import { ExecutionContext } from '@cloudflare/workers-types';
-import { Client } from '@sentry/core';
-import { ExecutionContextCompat } from './executionContext';
-type FlushLock = {
-    readonly ready: Promise<void>;
-    readonly finalize: () => Promise<void>;
-};
-/**
- * Returns the original (un-instrumented) waitUntil function for a context.
- * This should be used when calling waitUntil with flushAndDispose to avoid deadlock.
- *
- * The flush lock mechanism wraps context.waitUntil to track pending tasks.
- * If we call waitUntil(flushAndDispose(client)) through the instrumented version,
- * it creates a deadlock because:
- * 1. The instrumented waitUntil acquires the flush lock
- * 2. flushAndDispose calls client.flush() which waits for the lock to be released
- * 3. The lock won't be released until the waitUntil promise completes
- * 4. The waitUntil promise won't complete until flush() returns
- *
- * By using the original waitUntil for flush operations, we bypass this issue.
- */
-export declare function getOriginalWaitUntil(context: ExecutionContextCompat): ExecutionContext['waitUntil'] | undefined;
-/**
- * Enhances the given execution context by wrapping its `waitUntil` method with a proxy
- * to monitor pending tasks, and provides a flusher function to ensure all tasks
- * have been completed before executing any subsequent logic.
- *
- * @param {ExecutionContext} context - The execution context to be enhanced. If no context is provided, the function returns undefined.
- * @return {FlushLock} Returns a flusher function if a valid context is provided, otherwise undefined.
- */
-export declare function makeFlushLock(context: ExecutionContextCompat): FlushLock;
-/**
- * Flushes the client and then disposes of it to allow garbage collection.
- * This should be called at the end of each request to prevent memory leaks.
- *
- * This function never rejects. On Workers, a rejected promise passed to
- * `ctx.waitUntil` marks the whole invocation as `outcome: exception` even when
- * the handler itself completed successfully. Since flush/dispose is internal
- * SDK housekeeping, a failure here must not fail the user's invocation.
- *
- * @param client - The CloudflareClient instance to flush and dispose
- * @param timeout - Timeout in milliseconds for the flush operation
- * @returns A promise that resolves when flush and dispose are complete
- */
-export declare function flushAndDispose(client: Client | undefined, timeout?: number): Promise<void>;
-export {};
-//# sourceMappingURL=flush.d.ts.map

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

@@ -1,18 +0,0 @@
-export { Breadcrumb, BreadcrumbHint, PolymorphicRequest, RequestEventData, SdkInfo, Event, EventHint, ErrorEvent, Exception, FeatureFlagsIntegration, Session, SeverityLevel, Span, StackFrame, Stacktrace, Thread, User, Metric, ExclusiveEventHintOrCaptureContext, CaptureContext, } from '@sentry/core';
-export { CloudflareOptions } from './client';
-export { addEventProcessor, addBreadcrumb, addIntegration, captureException, captureEvent, captureMessage, captureFeedback, close, createTransport, lastEventId, flush, getClient, isInitialized, isEnabled, getCurrentScope, getGlobalScope, getIsolationScope, setCurrentClient, Scope, SDK_VERSION, setContext, setExtra, setExtras, setTag, setTags, setAttribute, setAttributes, setUser, setConversationId, getSpanStatusFromHttpCode, setHttpStatus, withScope, withIsolationScope, captureCheckIn, withMonitor, setMeasurement, getActiveSpan, getRootSpan, getTraceData, getTraceMetaTags, startSpan, startInactiveSpan, startSpanManual, startNewTrace, bindScopeToEmitter, suppressTracing, withActiveSpan, getSpanDescendants, continueTrace, functionToStringIntegration, inboundFiltersIntegration, instrumentOpenAiClient, instrumentGoogleGenAIClient, instrumentAnthropicAiClient, eventFiltersIntegration, linkedErrorsIntegration, requestDataIntegration, extraErrorDataIntegration, dedupeIntegration, rewriteFramesIntegration, captureConsoleIntegration, moduleMetadataIntegration, supabaseIntegration, instrumentSupabaseClient, instrumentPostgresJsSql, zodErrorsIntegration, consoleIntegration, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, trpcMiddleware, spanToJSON, spanToTraceHeader, spanToBaggageHeader, updateSpanName, wrapMcpServerWithSentry, consoleLoggingIntegration, createConsolaReporter, createLangChainCallbackHandler, instrumentLangChainEmbeddings, featureFlagsIntegration, growthbookIntegration, logger, metrics, withStreamedSpan, spanStreamingIntegration, instrumentStateGraph, instrumentLangGraph, instrumentCreateReactAgent, } from '@sentry/core';
-export { withSentry } from './withSentry';
-export { defineCloudflareOptions } from './defineCloudflareOptions';
-export { instrumentDurableObjectWithSentry } from './durableobject';
-export { sentryPagesPlugin } from './pages-plugin';
-export { wrapRequestHandler } from './request';
-export { CloudflareClient } from './client';
-export { getDefaultIntegrations } from './sdk';
-export { httpServerIntegration } from './integrations/httpServer';
-export { fetchIntegration } from './integrations/fetch';
-export { vercelAIIntegration } from './integrations/tracing/vercelai';
-export { honoIntegration } from './integrations/hono';
-export { instrumentD1WithSentry } from './instrumentations/worker/instrumentD1';
-export { instrumentWorkflowWithSentry } from './workflows';
-export { setAsyncLocalStorageAsyncContextStrategy } from './async';
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/instrument.d.ts

@@ -1,20 +0,0 @@
-/**
- * Mark an object as instrumented, storing the instrumented version.
- * @param original The original uninstrumented object
- * @param instrumented The instrumented version (defaults to original if not provided)
- */
-export declare function markAsInstrumented<T>(original: T, instrumented?: T): void;
-/**
- * Get the instrumented version of an object, if available.
- * Returns the instrumented version if the object was previously instrumented,
- * or undefined if not found.
- */
-export declare function getInstrumented<T>(obj: T): T | undefined;
-/**
- * Returns the already-instrumented version of `original` if one exists,
- * otherwise calls `instrumentFn` to create it, marks the mapping, and returns it.
- *
- * @param noMark - If true, skips storing the original→instrumented mapping.
- */
-export declare function ensureInstrumented<T>(original: T, instrumentFn: (original: T) => T, noMark?: boolean): T;
-//# sourceMappingURL=instrument.d.ts.map

package/build/types-ts3.8/instrumentations/instrumentDurableObjectNamespace.d.ts

@@ -1,13 +0,0 @@
-import { DurableObjectNamespace } from '@cloudflare/workers-types';
-export declare const STUB_NON_RPC_METHODS: Set<string>;
-/**
- * Instruments a DurableObjectNamespace binding to create spans for DO interactions.
- *
- * Wraps:
- * - `namespace.get(id)` / `namespace.getByName(name)` with a span + instruments returned stub
- * - `namespace.idFromName(name)` / `namespace.idFromString(id)` / `namespace.newUniqueId()` with breadcrumbs
- *
- * @param namespace - The DurableObjectNamespace to instrument
- */
-export declare function instrumentDurableObjectNamespace(namespace: DurableObjectNamespace): DurableObjectNamespace;
-//# sourceMappingURL=instrumentDurableObjectNamespace.d.ts.map

package/build/types-ts3.8/instrumentations/instrumentDurableObjectStorage.d.ts

@@ -1,19 +0,0 @@
-import { DurableObjectStorage } from '@cloudflare/workers-types';
-type WaitUntil = (promise: Promise<unknown>) => void;
-/**
- * Instruments DurableObjectStorage methods with Sentry spans.
- *
- * Wraps the following async methods:
- * - get, put, delete, list (KV API)
- * - setAlarm, getAlarm, deleteAlarm (Alarm API)
- *
- * When setAlarm is called, it also stores the current span context so that when
- * the alarm fires later, it can link back to the trace that called setAlarm.
- *
- * @param storage - The DurableObjectStorage instance to instrument
- * @param waitUntil - Optional waitUntil function to defer span context storage
- * @returns An instrumented DurableObjectStorage instance
- */
-export declare function instrumentDurableObjectStorage(storage: DurableObjectStorage, waitUntil?: WaitUntil): DurableObjectStorage;
-export {};
-//# sourceMappingURL=instrumentDurableObjectStorage.d.ts.map

package/build/types-ts3.8/instrumentations/instrumentDurableObjectSyncKvStorage.d.ts

@@ -1,3 +0,0 @@
-import { SyncKvStorage } from '@cloudflare/workers-types';
-export declare function instrumentDurableObjectSyncKvStorage(syncKv: SyncKvStorage): SyncKvStorage;
-//# sourceMappingURL=instrumentDurableObjectSyncKvStorage.d.ts.map

package/build/types-ts3.8/instrumentations/instrumentSqlStorage.d.ts

@@ -1,9 +0,0 @@
-import { SqlStorage } from '@cloudflare/workers-types';
-/**
- * Instruments the Durable Object SqlStorage `exec` method with Sentry spans.
- *
- * @param sql - The SqlStorage instance to instrument
- * @returns An instrumented SqlStorage instance
- */
-export declare function instrumentSqlStorage(sql: SqlStorage): SqlStorage;
-//# sourceMappingURL=instrumentSqlStorage.d.ts.map

package/build/types-ts3.8/instrumentations/instrumentWorkerEntrypoint.d.ts

@@ -1,42 +0,0 @@
-import { WorkerEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from '../client';
-export type WorkerEntrypointConstructor<Env = unknown, Props = {}> = new (ctx: ExecutionContext, env: any) => InstanceType<typeof WorkerEntrypoint<Env, Props>>;
-/**
- * Instruments a WorkerEntrypoint class to capture errors and performance data.
- *
- * Instruments the following methods (same as `withSentry` for ExportedHandler):
- * - fetch (HTTP requests)
- * - scheduled (cron triggers)
- * - queue (queue consumers)
- * - email (email handlers)
- * - tail (tail workers)
- *
- * as well as any other public RPC methods on the WorkerEntrypoint instance.
- *
- * @param optionsCallback Function that returns the options for the SDK initialization.
- * @param WorkerEntrypointClass The WorkerEntrypoint class to instrument.
- * @returns The instrumented WorkerEntrypoint class.
- *
- * @example
- * ```ts
- * class MyWorkerBase extends WorkerEntrypoint<Env> {
- *   async fetch(request: Request): Promise<Response> {
- *     return new Response('Hello World!');
- *   }
- *
- *   async myRpcMethod(arg: string): Promise<string> {
- *     return `Hello ${arg}!`;
- *   }
- * }
- *
- * export default instrumentWorkerEntrypoint(
- *   env => ({
- *     dsn: env.SENTRY_DSN,
- *     tracesSampleRate: 1.0,
- *   }),
- *   MyWorkerBase,
- * );
- * ```
- */
-export declare function instrumentWorkerEntrypoint<Env, Props, T extends InstanceType<typeof WorkerEntrypoint<Env, Props>>, C extends new (ctx: ExecutionContext, env: Env) => T>(optionsCallback: (env: Env) => CloudflareOptions | undefined, WorkerEntrypointClass: C): C;
-//# sourceMappingURL=instrumentWorkerEntrypoint.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentD1.d.ts

@@ -1,19 +0,0 @@
-import { D1Database } from '@cloudflare/workers-types';
-export declare function instrumentD1(db: D1Database): D1Database;
-/**
- * Instruments Cloudflare D1 bindings with Sentry.
- *
- * @deprecated `withSentry()` automatically instruments all D1 bindings via `env`
- * so this function is not needed anymore. It will be removed in the next major version of the SDK.
- *
- * @example
- *
- * ```js
- * // env.DB is the D1 DB binding configured in your `wrangler.toml`
- * const db = instrumentD1WithSentry(env.DB);
- * // Now you can use the database as usual
- * await db.prepare('SELECT * FROM table WHERE id = ?').bind(1).run();
- * ```
- */
-export declare function instrumentD1WithSentry(db: D1Database): D1Database;
-//# sourceMappingURL=instrumentD1.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentEmail.d.ts

@@ -1,8 +0,0 @@
-import { ExportedHandler } from '@cloudflare/workers-types';
-import { env as cloudflareEnv } from 'cloudflare:workers';
-import { CloudflareOptions } from '../../client';
-/**
- * Instruments an email handler for ExportedHandler (env/ctx come from args).
- */
-export declare function instrumentExportedHandlerEmail<T extends ExportedHandler<any, any, any>>(handler: T, optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined): void;
-//# sourceMappingURL=instrumentEmail.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentEnv.d.ts

@@ -1,18 +0,0 @@
-import { CloudflareOptions } from '../../client';
-/**
- * Wraps the Cloudflare `env` object in a Proxy that detects binding types
- * on property access and returns instrumented versions.
- *
- * Currently detects:
- * - DurableObjectNamespace (via `idFromName` duck-typing)
- * - Service bindings / JSRPC proxies
- * - Queue producers (via `send` + `sendBatch` duck-typing)
- * - R2 Buckets (via `head` + `put` + `createMultipartUpload` duck-typing)
- * - Rate limiters (via `limit` duck-typing)
- * - Workers AI (via `run` + `gateway` + `toMarkdown` duck-typing)
- *
- * @param env - The Cloudflare env object to instrument
- * @param options - Optional CloudflareOptions to control RPC trace propagation
- */
-export declare function instrumentEnv<Env extends Record<string, unknown>>(env: Env, options?: CloudflareOptions): Env;
-//# sourceMappingURL=instrumentEnv.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentFetch.d.ts

@@ -1,12 +0,0 @@
-import { ExportedHandler } from '@cloudflare/workers-types';
-import { env as cloudflareEnv, WorkerEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from '../../client';
-/**
- * Instruments a fetch handler for ExportedHandler (env/ctx come from args).
- */
-export declare function instrumentExportedHandlerFetch<T extends ExportedHandler<any, any, any>>(handler: T, optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined): void;
-/**
- * Instruments a fetch method for WorkerEntrypoint (options/context already available).
- */
-export declare function instrumentWorkerEntrypointFetch<T extends WorkerEntrypoint>(instance: T, options: CloudflareOptions, context: ExecutionContext): void;
-//# sourceMappingURL=instrumentFetch.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentFetcher.d.ts

@@ -1,10 +0,0 @@
-import { Fetcher } from '@cloudflare/workers-types';
-/**
- * Wraps a fetch-like function to create a span and propagate trace headers
- * (`sentry-trace` and `baggage`) on the outgoing request.
- *
- * Useful for instrumenting Cloudflare bindings that expose a `fetch` method
- * (e.g. Durable Object stubs, Service bindings).
- */
-export declare function instrumentFetcher(fetchFn: Fetcher['fetch']): Fetcher['fetch'];
-//# sourceMappingURL=instrumentFetcher.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentQueue.d.ts

@@ -1,12 +0,0 @@
-import { ExportedHandler } from '@cloudflare/workers-types';
-import { env as cloudflareEnv, WorkerEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from '../../client';
-/**
- * Instruments a queue handler for ExportedHandler (env/ctx come from args).
- */
-export declare function instrumentExportedHandlerQueue<T extends ExportedHandler<any, any, any>>(handler: T, optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined): void;
-/**
- * Instruments a queue method for WorkerEntrypoint (options/context already available).
- */
-export declare function instrumentWorkerEntrypointQueue<T extends WorkerEntrypoint>(instance: T, options: CloudflareOptions, context: ExecutionContext): void;
-//# sourceMappingURL=instrumentQueue.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentQueueProducer.d.ts

@@ -1,10 +0,0 @@
-import { Queue } from '@cloudflare/workers-types';
-/**
- * Wraps a Queue producer binding to create `queue.publish` spans on
- * `send` and `sendBatch` calls.
- *
- * The queue's own name is not available on the binding object, so we use
- * the env binding key (e.g. `MY_QUEUE`) as `messaging.destination.name`.
- */
-export declare function instrumentQueueProducer<T extends Queue>(queue: T, bindingName: string): T;
-//# sourceMappingURL=instrumentQueueProducer.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentR2.d.ts

@@ -1,9 +0,0 @@
-import { R2Bucket } from '@cloudflare/workers-types';
-/**
- * Wraps a Cloudflare R2 Bucket binding to create spans on bucket operations.
- *
- * Instrumented methods: get, head, put, delete, list, createMultipartUpload,
- * resumeMultipartUpload (and the resulting multipart upload operations).
- */
-export declare function instrumentR2Bucket<T extends R2Bucket>(bucket: T, bindingName: string): T;
-//# sourceMappingURL=instrumentR2.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentRateLimit.d.ts

@@ -1,6 +0,0 @@
-import { RateLimit } from '@cloudflare/workers-types';
-/**
- * Wraps a Cloudflare rate limiter binding to create a span on each `limit()` call.
- */
-export declare function instrumentRateLimit<T extends RateLimit>(rateLimit: T, bindingName: string): T;
-//# sourceMappingURL=instrumentRateLimit.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentScheduled.d.ts

@@ -1,12 +0,0 @@
-import { ExportedHandler } from '@cloudflare/workers-types';
-import { env as cloudflareEnv, WorkerEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from '../../client';
-/**
- * Instruments a scheduled handler for ExportedHandler (env/ctx come from args).
- */
-export declare function instrumentExportedHandlerScheduled<T extends ExportedHandler<any, any, any>>(handler: T, optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined): void;
-/**
- * Instruments a scheduled method for WorkerEntrypoint (options/context already available).
- */
-export declare function instrumentWorkerEntrypointScheduled<T extends WorkerEntrypoint>(instance: T, options: CloudflareOptions, context: ExecutionContext): void;
-//# sourceMappingURL=instrumentScheduled.d.ts.map

package/build/types-ts3.8/instrumentations/worker/instrumentTail.d.ts

@@ -1,12 +0,0 @@
-import { ExportedHandler } from '@cloudflare/workers-types';
-import { env as cloudflareEnv, WorkerEntrypoint } from 'cloudflare:workers';
-import { CloudflareOptions } from '../../client';
-/**
- * Instruments a tail handler for ExportedHandler (env/ctx come from args).
- */
-export declare function instrumentExportedHandlerTail<T extends ExportedHandler<any, any, any>>(handler: T, optionsCallback: (env: typeof cloudflareEnv) => CloudflareOptions | undefined): void;
-/**
- * Instruments a tail method for WorkerEntrypoint (options/context already available).
- */
-export declare function instrumentWorkerEntrypointTail<T extends WorkerEntrypoint>(instance: T, options: CloudflareOptions, context: ExecutionContext): void;
-//# sourceMappingURL=instrumentTail.d.ts.map

package/build/types-ts3.8/integrations/fetch.d.ts

@@ -1,19 +0,0 @@
-export interface Options {
-    /**
-     * Whether breadcrumbs should be recorded for requests
-     * Defaults to true
-     */
-    breadcrumbs: boolean;
-    /**
-     * Function determining whether or not to create spans to track outgoing requests to the given URL.
-     * By default, spans will be created for all outgoing requests.
-     */
-    shouldCreateSpanForRequest?: (url: string) => boolean;
-}
-/**
- * Creates spans and attaches tracing headers to fetch requests.
- */
-export declare const fetchIntegration: (options?: Partial<Options> | undefined) => import("@sentry/core").Integration & {
-    name: "Fetch";
-};
-//# sourceMappingURL=fetch.d.ts.map

package/build/types-ts3.8/integrations/hono.d.ts

@@ -1,42 +0,0 @@
-interface HonoError extends Error {
-    status?: number;
-}
-export interface HonoContext {
-    req: {
-        method: string;
-        path?: string;
-    };
-}
-export interface Options {
-    /**
-     * Callback method deciding whether error should be captured and sent to Sentry
-     * @param error Captured middleware error
-     */
-    shouldHandleError?(this: void, error: HonoError): boolean;
-}
-/** Only exported for internal use */
-export declare function getHonoIntegration(): ReturnType<typeof _honoIntegration> | undefined;
-declare const _honoIntegration: (options?: Partial<Options>) => {
-    name: "Hono";
-    handleHonoException(err: HonoError, context: HonoContext): void;
-};
-/**
- * Automatically captures exceptions caught with the `onError` handler in Hono.
- *
- * The integration is enabled by default.
- *
- * @deprecated Use the `@sentry/hono` package instead. The `sentry()` middleware from `@sentry/hono/cloudflare`
- * handles error capturing automatically without needing this integration.
- *
- * @example
- * integrations: [
- *   honoIntegration({
- *     shouldHandleError: (err) => true; // always capture exceptions in onError
- *   })
- * ]
- */
-export declare const honoIntegration: (options?: Partial<Options> | undefined) => import("@sentry/core").Integration & {
-    name: "Hono";
-};
-export {};
-//# sourceMappingURL=hono.d.ts.map

package/build/types-ts3.8/integrations/httpServer.d.ts

@@ -1,63 +0,0 @@
-import { Client, MaxRequestBodySize } from '@sentry/core';
-export interface HttpServerIntegrationOptions {
-    /**
-     * Controls the maximum size of incoming request bodies attached to events.
-     *
-     * Only applies to requests with textual content types (text/*, application/json,
-     * application/x-www-form-urlencoded, application/xml, application/graphql).
-     * Binary data is not captured.
-     *
-     * Available options:
-     * - `'none'`: No request bodies will be attached
-     * - `'small'`: Request bodies up to 1,000 bytes will be attached
-     * - `'medium'`: Request bodies up to 10,000 bytes will be attached (default)
-     * - `'always'`: Request bodies will always be attached (up to 1MB limit)
-     *
-     * @default 'medium'
-     */
-    maxRequestBodySize?: MaxRequestBodySize;
-    /**
-     * Do not capture the request body for incoming HTTP requests to URLs where the given callback returns `true`.
-     * This can be useful for long running requests where the body is not needed, health check endpoints,
-     * or requests containing sensitive data that should not be captured.
-     *
-     * @param url The full URL of the incoming request, including query string, protocol, host, etc.
-     * @param request The incoming Request object.
-     * @returns `true` to skip body capture for this request, `false` to capture normally.
-     *
-     * @example
-     * ```ts
-     * Sentry.httpServerIntegration({
-     *   ignoreRequestBody: (url) => url.includes('/health') || url.includes('/upload'),
-     * })
-     * ```
-     */
-    ignoreRequestBody?: (url: string, request: Request) => boolean;
-}
-/**
- * Configures incoming HTTP request handling for Cloudflare Workers.
- *
- * This integration controls how incoming HTTP request data is captured,
- * matching the API of `httpServerIntegration` in Node.js.
- *
- * @example
- * ```ts
- * Sentry.init({
- *   integrations: [
- *     Sentry.httpServerIntegration({
- *       maxRequestBodySize: 'medium',
- *       ignoreRequestBody: (url) => url.includes('/health'),
- *     }),
- *   ],
- * });
- * ```
- */
-export declare const httpServerIntegration: (options?: HttpServerIntegrationOptions | undefined) => import("@sentry/core").Integration & {
-    name: string;
-};
-/**
- * Capture the request body based on the HttpServer integration config.
- * Called internally by `wrapRequestHandler`.
- */
-export declare function captureIncomingRequestBody(client: Client, request: Request): Promise<void>;
-//# sourceMappingURL=httpServer.d.ts.map

package/build/types-ts3.8/integrations/tracing/vercelai.d.ts

@@ -1,47 +0,0 @@
-/**
- * This is a copy of the Vercel AI integration from the node SDK.
- *
- * The only difference is that it does not use `@opentelemetry/instrumentation`
- * because Cloudflare Workers do not support it.
- *
- * Therefore, we cannot automatically patch setting `experimental_telemetry: { isEnabled: true }`
- * and users have to manually set this to get spans.
- */
-interface VercelAiOptions {
-    /**
-     * Enable or disable truncation of recorded input messages.
-     * Defaults to `true`.
-     */
-    enableTruncation?: boolean;
-}
-/**
- * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
- * This integration is not enabled by default, you need to manually add it.
- *
- * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).
- *
- *  You need to enable collecting spans for a specific call by setting
- * `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.
- *
- * ```javascript
- * const result = await generateText({
- *   model: openai('gpt-4-turbo'),
- *   experimental_telemetry: { isEnabled: true },
- * });
- * ```
- *
- * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each
- * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`
- * to `true`.
- *
- * ```javascript
- * const result = await generateText({
- *  model: openai('gpt-4-turbo'),
- *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
- * });
- */
-export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
-    name: string;
-};
-export {};
-//# sourceMappingURL=vercelai.d.ts.map

package/build/types-ts3.8/nodejs_compat/index.d.ts

@@ -1,4 +0,0 @@
-export * from '../index';
-export { prismaIntegration } from '@sentry/server-utils';
-export { vercelAIIntegration } from './integrations/tracing/vercelai';
-//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/nodejs_compat/integrations/tracing/vercelai.d.ts

@@ -1,37 +0,0 @@
-/*
-* This is a copy of the Vercel AI integration from the Cloudflare SDK (src/integrations/tracing/vercelai.ts).
-*
-* The only difference is that it includes tracing channel support
-* because the default Vercel AI integration needs `nodejs_als`, while this one uses `nodejs_compat`.
-*/
-import { VercelAiOptions } from '@sentry/server-utils';
-/**
- * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.
- * This integration is not enabled by default, you need to manually add it.
- *
- * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).
- *
- *  You need to enable collecting spans for a specific call by setting
- * `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.
- *
- * ```javascript
- * const result = await generateText({
- *   model: openai('gpt-4-turbo'),
- *   experimental_telemetry: { isEnabled: true },
- * });
- * ```
- *
- * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each
- * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`
- * to `true`.
- *
- * ```javascript
- * const result = await generateText({
- *  model: openai('gpt-4-turbo'),
- *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
- * });
- */
-export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration & {
-    name: string;
-};
-//# sourceMappingURL=vercelai.d.ts.map

package/build/types-ts3.8/opentelemetry/tracer.d.ts

@@ -1,6 +0,0 @@
-/**
- * Set up a mock OTEL tracer to allow inter-op with OpenTelemetry emitted spans.
- * This is not perfect but handles easy/common use cases.
- */
-export declare function setupOpenTelemetryTracer(): void;
-//# sourceMappingURL=tracer.d.ts.map

package/build/types-ts3.8/options.d.ts

@@ -1,17 +0,0 @@
-import { CloudflareOptions } from './client';
-/**
- * Merges the options passed in from the user with the options we read from
- * the Cloudflare `env` environment variable object.
- *
- * Release is determined with the following priority (highest to lowest):
- * 1. User-provided release option
- * 2. SENTRY_RELEASE environment variable
- * 3. CF_VERSION_METADATA.id binding (if configured in the wrangler config)
- *
- * @param userOptions - The options passed in from the user.
- * @param env - The environment variables.
- *
- * @returns The final options.
- */
-export declare function getFinalOptions(userOptions: CloudflareOptions | undefined, env: unknown): CloudflareOptions;
-//# sourceMappingURL=options.d.ts.map