@sentry/cloudflare 10.72.0 → 10.74.0

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

@@ -4,6 +4,7 @@ export { addEventProcessor, addBreadcrumb, addIntegration, captureException, cap
 export { withSentry } from './withSentry';
 export { defineCloudflareOptions } from './defineCloudflareOptions';
 export { instrumentAgentWithSentry, instrumentDurableObjectWithSentry } from './durableobject';
+export { _INTERNAL_wrapUnlessInstrumented } from './instrument';
 export { sentryPagesPlugin } from './pages-plugin';
 export { wrapRequestHandler } from './request';
 export { CloudflareClient } from './client';

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

@@ -17,4 +17,14 @@ export declare function getInstrumented<T>(obj: T): T | undefined;
  * @param noMark - If true, skips storing the original→instrumented mapping.
  */
 export declare function ensureInstrumented<T>(original: T, instrumentFn: (original: T) => T, noMark?: boolean): T;
+/**
+ * Applies `wrap` to `Class` unless `Class` is already an instrumented wrapper.
+ *
+ * Emitted by the Vite auto-instrumentation transform for classes the worker entry only re-exports:
+ * such a class may already be hand-wrapped with `instrument*WithSentry` in the module it comes
+ * from, which the build cannot see. Wrapping again would nest two proxies and instrument the same
+ * work twice, duplicated child spans, so the hand-wrapped class is returned as-is. Not part of the
+ * public API, hand-written wrapper calls are deliberately left untouched by this guard.
+ */
+export declare function _INTERNAL_wrapUnlessInstrumented<C>(wrap: (optionsCallback: (env: never) => unknown, Class: C) => C, optionsCallback: (env: never) => unknown, Class: C): C;
 //# sourceMappingURL=instrument.d.ts.map

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

@@ -0,0 +1,28 @@
+import { DurableObject } from 'cloudflare:workers';
+import { CloudflareOptions } from '../client';
+/**
+ * The instrumented context of the Durable Object being wrapped.
+ *
+ * Kept as `any` for the same reason as in `durableobject.ts`: a concrete `DurableObjectState` here
+ * makes `tsc` relate its `SqlStorage` graph against the parameter union of `wrapMethodWithSentry`,
+ * which hangs the type build.
+ */
+type InstrumentedDurableObjectContext = any;
+/**
+ * Instruments the built-in Durable Object handler methods on a constructed instance.
+ *
+ * These are the methods that are available on a Durable Object
+ * ref: https://developers.cloudflare.com/durable-objects/api/base/
+ * - obj.alarm
+ * - obj.fetch
+ * - obj.webSocketError
+ * - obj.webSocketClose
+ * - obj.webSocketMessage
+ *
+ * Any other public methods on the Durable Object instance are RPC calls.
+ *
+ * @internal
+ */
+export declare function instrumentDurableObjectHandlers<E, T extends DurableObject<E>>(obj: T, options: CloudflareOptions, context: InstrumentedDurableObjectContext): void;
+export {};
+//# sourceMappingURL=instrumentDurableObjectHandlers.d.ts.map

package/build/types-ts3.8/vite/agentClass.d.ts

@@ -32,10 +32,11 @@ export interface ModuleResolver {
  */
 export declare function detectAgentClasses(ast: ProgramBody, entryId: string, candidates: Iterable<string>, resolver: ModuleResolver): Promise<Set<string>>;
 /**
- * The local class names in the entry that a configured class name could refer to — either declared
- * under that name directly, or aliased to it by an `export { Local as Configured }` specifier.
+ * The entry-module binding names a configured class name could refer to — a class declared under
+ * that name, an import of it from another module, a `export { X } from './x'` re-export, or the
+ * local binding an `export { Local as Configured }` specifier aliases.
  *
- * Keeps detection (which reads and scans other modules) off classes that no binding points at.
+ * Keeps detection (which reads and scans other modules) off names no binding points at.
  */
 export declare function collectAgentCandidates(ast: ProgramBody, configuredNames: Iterable<string>): Set<string>;
 //# sourceMappingURL=agentClass.d.ts.map

package/build/types-ts3.8/vite/transform.d.ts

@@ -54,10 +54,11 @@ export interface TransformResult {
  * {@link TransformContext.classWrappers}, e.g. Durable Object classes with
  * `instrumentDurableObjectWithSentry`).
  *
- * Handles both `export class MyDO {}` and the specifier form
- * (`class MyDO {}` … `export { MyDO }` / `export { Foo as MyDO }`).
- * Re-exports from other modules (`export { MyDO } from './do'`) cannot be
- * wrapped here and are left alone — the plugin warns about them via
+ * Handles `export class MyDO {}`, the specifier form (`class MyDO {}` …
+ * `export { MyDO }` / `export { Foo as MyDO }`), and classes that live in
+ * another module (`import { MyDO } from './do'; export { MyDO }` or
+ * `export { MyDO } from './do'`). Only star re-exports (`export * from './do'`)
+ * are left alone — the plugin warns about those via
  * {@link TransformResult.wrappedClasses}.
  *
  * Exported (rather than inlined into the plugin) so it can be unit-tested with a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/cloudflare",
-  "version": "10.72.0",
+  "version": "10.74.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",
@@ -70,8 +70,8 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@sentry/core": "10.72.0",
-    "@sentry/server-utils": "10.72.0",
+    "@sentry/core": "10.74.0",
+    "@sentry/server-utils": "10.74.0",
     "magic-string": "~0.30.21"
   },
   "peerDependencies": {