@sentry/cloudflare 10.47.0 → 10.49.0

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

@@ -0,0 +1,16 @@
+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 (wraps `fetch` for trace propagation)
+ *
+ * Extensible for future binding types (KV, D1, Queue, etc.).
+ *
+ * @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,7 +1,12 @@
 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: Parameters<NonNullable<T['fetch']>>[1]) => CloudflareOptions | undefined): void;
+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

@@ -0,0 +1,10 @@
+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,7 +1,12 @@
 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: Parameters<NonNullable<T['queue']>>[1]) => CloudflareOptions | undefined): void;
+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/instrumentScheduled.d.ts

@@ -1,7 +1,12 @@
 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: Parameters<NonNullable<T['scheduled']>>[1]) => CloudflareOptions | undefined): void;
+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,7 +1,12 @@
 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: Parameters<NonNullable<T['tail']>>[1]) => CloudflareOptions | undefined): void;
+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/tracing/vercelai.d.ts

@@ -7,6 +7,13 @@
  * 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.
@@ -33,5 +40,6 @@
  *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },
  * });
  */
-export declare const vercelAIIntegration: () => import("@sentry/core").Integration;
+export declare const vercelAIIntegration: (options?: VercelAiOptions | undefined) => import("@sentry/core").Integration;
+export {};
 //# sourceMappingURL=vercelai.d.ts.map

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

@@ -1,9 +1,9 @@
-import { ExecutionContext, IncomingRequestCfProperties } from '@cloudflare/workers-types';
+import { CfProperties, ExecutionContext, IncomingRequestCfProperties } from '@cloudflare/workers-types';
 import { CloudflareOptions } from './client';
 interface RequestHandlerWrapperOptions {
     options: CloudflareOptions;
-    request: Request<unknown, IncomingRequestCfProperties<unknown>>;
-    context: ExecutionContext;
+    request: Request<unknown, IncomingRequestCfProperties<unknown> | CfProperties<unknown>>;
+    context: ExecutionContext | undefined;
     /**
      * If true, errors will be captured, rethrown and sent to Sentry.
      * Otherwise, errors are rethrown but not captured.

package/build/types-ts3.8/scope-utils.d.ts

@@ -1,4 +1,4 @@
-import { IncomingRequestCfProperties } from '@cloudflare/workers-types';
+import { CfProperties, IncomingRequestCfProperties } from '@cloudflare/workers-types';
 import { Scope } from '@sentry/core';
 /**
  * Set cloud resource context on scope.
@@ -7,7 +7,7 @@ export declare function addCloudResourceContext(scope: Scope): void;
 /**
  * Set culture context on scope
  */
-export declare function addCultureContext(scope: Scope, cf: IncomingRequestCfProperties): void;
+export declare function addCultureContext(scope: Scope, cf: IncomingRequestCfProperties | CfProperties): void;
 /**
  * Set request data on scope
  */

package/build/types-ts3.8/utils/isBinding.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Adapted from https://github.com/evanderkoogh/otel-cf-workers/blob/effeb549f0a4ed1c55ea0c4f0d8e8e37e5494fb3/src/instrumentation/env.ts
+ *
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2023, Erwin van der Koogh
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import { DurableObjectNamespace } from '@cloudflare/workers-types';
+/**
+ * Checks if a value is a JSRPC proxy (service binding).
+ *
+ * JSRPC proxies return a truthy value for ANY property access, including
+ * properties that don't exist. This makes other duck-type checks unreliable
+ * unless we exclude JSRPC first.
+ *
+ * Must be checked before other binding type checks.
+ */
+export declare function isJSRPC(item: unknown): item is Service;
+/**
+ * Duck-type check for DurableObjectNamespace bindings.
+ * DurableObjectNamespace has `idFromName`, `idFromString`, `get`, `newUniqueId`.
+ */
+export declare function isDurableObjectNamespace(item: unknown): item is DurableObjectNamespace;
+//# sourceMappingURL=isBinding.d.ts.map

package/build/types-ts3.8/utils/isCloudflareClass.d.ts

@@ -0,0 +1,30 @@
+import { DurableObject, WorkflowEntrypoint } from 'cloudflare:workers';
+import { WorkerEntrypointConstructor } from '../instrumentations/instrumentWorkerEntrypoint';
+/**
+ * Checks if a class constructor extends a specific Cloudflare base class.
+ *
+ * Uses prototype chain walking with constructor names rather than instanceof,
+ * so it works in Node at build time without requiring the cloudflare:workers
+ * module (which only exists in the Workers runtime).
+ *
+ * This is used to differentiate between different Cloudflare worker types:
+ * - WorkerEntrypoint: Class-based workers (used with instrumentWorkerEntrypoint)
+ * - DurableObject: Durable Object classes
+ * - Workflow: Workflow classes
+ *
+ * For ExportedHandler (plain objects), this will return false for all types.
+ *
+ * @param value - The value to check (typically a class constructor)
+ * @param className - The Cloudflare base class name to check against
+ * @returns true if the value is a class that extends the specified Cloudflare class
+ *
+ * @example
+ * ```ts
+ * isCloudflareClass(MyWorker, 'WorkerEntrypoint') // true if MyWorker extends WorkerEntrypoint
+ * isCloudflareClass(MyDO, 'DurableObject') // true if MyDO extends DurableObject
+ * ```
+ */
+export declare function isCloudflareClass(value: unknown, className: 'WorkerEntrypoint'): value is WorkerEntrypointConstructor;
+export declare function isCloudflareClass(value: unknown, className: 'DurableObject'): value is new (...args: unknown[]) => DurableObject;
+export declare function isCloudflareClass(value: unknown, className: 'WorkflowEntrypoint'): value is new (...args: unknown[]) => WorkflowEntrypoint;
+//# sourceMappingURL=isCloudflareClass.d.ts.map

package/build/types-ts3.8/utils/rpcOptions.d.ts

@@ -0,0 +1,24 @@
+import { CloudflareOptions } from '../client';
+/**
+ * Gets the effective RPC propagation setting, handling deprecation of `instrumentPrototypeMethods`.
+ *
+ * Priority:
+ * 1. If `enableRpcTracePropagation` is set, use it (ignore `instrumentPrototypeMethods`)
+ * 2. If only `instrumentPrototypeMethods` is set, use it with deprecation warning (converted to boolean)
+ * 3. If neither is set, return `false`
+ *
+ * @returns The effective setting for RPC trace propagation
+ */
+export declare function getEffectiveRpcPropagation(options: CloudflareOptions): boolean;
+/**
+ * Gets the method filter for prototype method instrumentation.
+ *
+ * Returns:
+ * - `null` if no instrumentation should occur
+ * - `true` if all methods should be instrumented
+ * - `string[]` if only specific methods should be instrumented (deprecated behavior)
+ *
+ * @returns The method filter or null if no instrumentation
+ */
+export declare function getPrototypeMethodFilter(options: CloudflareOptions): boolean | string[];
+//# sourceMappingURL=rpcOptions.d.ts.map

package/build/types-ts3.8/utils/traceLinks.d.ts

@@ -0,0 +1,27 @@
+import { DurableObjectStorage } from '@cloudflare/workers-types';
+import { SpanLink } from '@sentry/core';
+/** Stored span context for creating span links */
+export interface StoredSpanContext {
+    traceId: string;
+    spanId: string;
+    sampled: boolean;
+}
+/**
+ * Gets the storage key for a specific method's trace link.
+ */
+export declare function getTraceLinkKey(methodName: string): string;
+/**
+ * Stores the current span context in Durable Object storage for trace linking.
+ * Uses the original uninstrumented storage to avoid creating spans for internal operations.
+ * Errors are silently ignored to prevent internal storage failures from propagating to user code.
+ */
+export declare function storeSpanContext(originalStorage: DurableObjectStorage, methodName: string): Promise<void>;
+/**
+ * Retrieves a stored span context from Durable Object storage.
+ */
+export declare function getStoredSpanContext(originalStorage: DurableObjectStorage, methodName: string): Promise<StoredSpanContext | undefined>;
+/**
+ * Builds span links from a stored span context.
+ */
+export declare function buildSpanLinks(storedContext: StoredSpanContext): SpanLink[];
+//# sourceMappingURL=traceLinks.d.ts.map

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

@@ -1,5 +1,6 @@
-import { env } from 'cloudflare:workers';
+import { env as cloudflareEnv } from 'cloudflare:workers';
 import { CloudflareOptions } from './client';
+import { WorkerEntrypointConstructor } from './instrumentations/instrumentWorkerEntrypoint';
 /**
  * Wrapper for Cloudflare handlers.
  *
@@ -11,5 +12,5 @@ import { CloudflareOptions } from './client';
  * @param handler {ExportedHandler} The handler to wrap.
  * @returns The wrapped handler.
  */
-export declare function withSentry<Env = typeof env, QueueHandlerMessage = unknown, CfHostMetadata = unknown, T extends ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata> = ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata>>(optionsCallback: (env: Env) => CloudflareOptions | undefined, handler: T): T;
+export declare function withSentry<Env = typeof cloudflareEnv, QueueHandlerMessage = unknown, CfHostMetadata = unknown, T extends ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata> | WorkerEntrypointConstructor = ExportedHandler<Env, QueueHandlerMessage, CfHostMetadata>>(optionsCallback: (env: Env) => CloudflareOptions | undefined, handler: T): T;
 //# sourceMappingURL=withSentry.d.ts.map

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

@@ -1,14 +1,31 @@
+import { DurableObjectStorage } from '@cloudflare/workers-types';
 import { CloudflareOptions } from './client';
+/** Extended DurableObjectState with originalStorage exposed by instrumentContext */
+interface InstrumentedDurableObjectState extends DurableObjectState {
+    originalStorage?: DurableObjectStorage;
+}
 type MethodWrapperOptions = {
     spanName?: string;
     spanOp?: string;
     options: CloudflareOptions;
-    context: ExecutionContext | DurableObjectState;
+    context: ExecutionContext | InstrumentedDurableObjectState;
+    /**
+     * If true, starts a fresh trace instead of inheriting from a parent trace.
+     * Useful for scheduled/independent invocations like alarms.
+     *
+     * If true, it also stores the current span context and links to the previous invocation's span.
+     * Uses Durable Object storage to persist the link. The link is set asynchronously via `span.addLinks()`
+     * in a `waitUntil` to avoid blocking.
+     *
+     * @default false
+     */
+    startNewTrace?: boolean;
 };
 export type UncheckedMethod = (...args: any[]) => any;
 type OriginalMethod = UncheckedMethod;
 /**
- * Wraps a method with Sentry tracing.
+ * Wraps a method with Sentry error tracking and optional tracing.
+ * Supports starting new traces and linking to previous invocations via Durable Object storage.
  *
  * @param wrapperOptions - The options for the wrapper.
  * @param handler - The method to wrap.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/cloudflare",
-  "version": "10.47.0",
+  "version": "10.49.0",
   "description": "Official Sentry SDK for Cloudflare Workers and Pages",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/cloudflare",
@@ -50,7 +50,7 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@sentry/core": "10.47.0"
+    "@sentry/core": "10.49.0"
   },
   "peerDependencies": {
     "@cloudflare/workers-types": "^4.x"