@sentry/cloudflare 10.70.0 → 11.0.0-alpha.1

package/build/cjs/prod/integrations/spotlight.js

@@ -0,0 +1,64 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const debugBuild = require('../debug-build.js');
+
+const INTEGRATION_NAME = "Spotlight";
+const _spotlightIntegration = ((options = {}) => {
+  const sidecarUrl = options.sidecarUrl || "http://localhost:8969/stream";
+  return {
+    name: INTEGRATION_NAME,
+    setup(client) {
+      debugBuild.DEBUG_BUILD && core.debug.log("[Spotlight] Using Sidecar URL", sidecarUrl);
+      setupSidecarForwarding(client, sidecarUrl);
+    }
+  };
+});
+const spotlightIntegration = core.defineIntegration(_spotlightIntegration);
+function setupSidecarForwarding(client, sidecarUrl) {
+  const parsedUrl = parseSidecarUrl(sidecarUrl);
+  if (!parsedUrl) {
+    return;
+  }
+  let failCount = 0;
+  client.on("beforeEnvelope", (envelope) => {
+    if (failCount > 3) {
+      debugBuild.DEBUG_BUILD && core.debug.warn("[Spotlight] Disabled Sentry -> Spotlight forwarding due to too many failed requests");
+      return;
+    }
+    const body = core.serializeEnvelope(envelope);
+    core.suppressTracing(() => {
+      fetch(parsedUrl.href, {
+        method: "POST",
+        body,
+        headers: {
+          "Content-Type": "application/x-sentry-envelope"
+        }
+      }).then(
+        (res) => {
+          res.text().catch(() => {
+          });
+          if (res.status >= 200 && res.status < 400) {
+            failCount = 0;
+          }
+        },
+        () => {
+          failCount++;
+          debugBuild.DEBUG_BUILD && core.debug.warn("[Spotlight] Failed to send envelope to Spotlight Sidecar");
+        }
+      );
+    });
+  });
+}
+function parseSidecarUrl(url) {
+  try {
+    return new URL(url);
+  } catch {
+    debugBuild.DEBUG_BUILD && core.debug.warn(`[Spotlight] Invalid sidecar URL: ${url}`);
+    return void 0;
+  }
+}
+
+exports.INTEGRATION_NAME = INTEGRATION_NAME;
+exports.spotlightIntegration = spotlightIntegration;
+//# sourceMappingURL=spotlight.js.map

package/build/cjs/prod/integrations/spotlight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spotlight.js","sources":["../../../../src/integrations/spotlight.ts"],"sourcesContent":["import type { Client, Envelope, IntegrationFn } from '@sentry/core';\nimport { debug, defineIntegration, serializeEnvelope, suppressTracing } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build';\n\ntype SpotlightConnectionOptions = {\n  /**\n   * Set this if the Spotlight Sidecar is not running on localhost:8969.\n   * By default, the URL is set to http://localhost:8969/stream\n   */\n  sidecarUrl?: string;\n};\n\nexport const INTEGRATION_NAME = 'Spotlight' as const;\n\nconst _spotlightIntegration = ((options: Partial<SpotlightConnectionOptions> = {}) => {\n  const sidecarUrl = options.sidecarUrl || 'http://localhost:8969/stream';\n\n  return {\n    name: INTEGRATION_NAME,\n    setup(client) {\n      DEBUG_BUILD && debug.log('[Spotlight] Using Sidecar URL', sidecarUrl);\n      setupSidecarForwarding(client, sidecarUrl);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Use this integration to send errors and transactions to Spotlight.\n *\n * Learn more about spotlight at https://spotlightjs.com\n *\n * Important: This integration is intended for local development only.\n * Each forwarded envelope counts as a Worker subrequest (50 free / 1000 paid\n * per invocation), so it should not be enabled in production.\n */\nexport const spotlightIntegration = defineIntegration(_spotlightIntegration);\n\nfunction setupSidecarForwarding(client: Client, sidecarUrl: string): void {\n  const parsedUrl = parseSidecarUrl(sidecarUrl);\n  if (!parsedUrl) {\n    return;\n  }\n\n  let failCount = 0;\n\n  client.on('beforeEnvelope', (envelope: Envelope) => {\n    if (failCount > 3) {\n      DEBUG_BUILD && debug.warn('[Spotlight] Disabled Sentry -> Spotlight forwarding due to too many failed requests');\n      return;\n    }\n\n    const body = serializeEnvelope(envelope);\n\n    suppressTracing(() => {\n      fetch(parsedUrl.href, {\n        method: 'POST',\n        body,\n        headers: {\n          'Content-Type': 'application/x-sentry-envelope',\n        },\n      }).then(\n        res => {\n          // Consume the response body to satisfy Cloudflare Workers' requirement\n          // that all fetch response bodies are read or cancelled.\n          res.text().catch(() => {\n            // no-op\n          });\n\n          if (res.status >= 200 && res.status < 400) {\n            failCount = 0;\n          }\n        },\n        () => {\n          failCount++;\n          DEBUG_BUILD && debug.warn('[Spotlight] Failed to send envelope to Spotlight Sidecar');\n        },\n      );\n    });\n  });\n}\n\nfunction parseSidecarUrl(url: string): URL | undefined {\n  try {\n    return new URL(url);\n  } catch {\n    DEBUG_BUILD && debug.warn(`[Spotlight] Invalid sidecar URL: ${url}`);\n    return undefined;\n  }\n}\n"],"names":["DEBUG_BUILD","debug","defineIntegration","serializeEnvelope","suppressTracing"],"mappings":";;;;;AAYO,MAAM,gBAAA,GAAmB;AAEhC,MAAM,qBAAA,IAAyB,CAAC,OAAA,GAA+C,EAAC,KAAM;AACpF,EAAA,MAAM,UAAA,GAAa,QAAQ,UAAA,IAAc,8BAAA;AAEzC,EAAA,OAAO;AAAA,IACL,IAAA,EAAM,gBAAA;AAAA,IACN,MAAM,MAAA,EAAQ;AACZ,MAAAA,sBAAA,IAAeC,UAAA,CAAM,GAAA,CAAI,+BAAA,EAAiC,UAAU,CAAA;AACpE,MAAA,sBAAA,CAAuB,QAAQ,UAAU,CAAA;AAAA,IAC3C;AAAA,GACF;AACF,CAAA,CAAA;AAWO,MAAM,oBAAA,GAAuBC,uBAAkB,qBAAqB;AAE3E,SAAS,sBAAA,CAAuB,QAAgB,UAAA,EAA0B;AACxE,EAAA,MAAM,SAAA,GAAY,gBAAgB,UAAU,CAAA;AAC5C,EAAA,IAAI,CAAC,SAAA,EAAW;AACd,IAAA;AAAA,EACF;AAEA,EAAA,IAAI,SAAA,GAAY,CAAA;AAEhB,EAAA,MAAA,CAAO,EAAA,CAAG,gBAAA,EAAkB,CAAC,QAAA,KAAuB;AAClD,IAAA,IAAI,YAAY,CAAA,EAAG;AACjB,MAAAF,sBAAA,IAAeC,UAAA,CAAM,KAAK,qFAAqF,CAAA;AAC/G,MAAA;AAAA,IACF;AAEA,IAAA,MAAM,IAAA,GAAOE,uBAAkB,QAAQ,CAAA;AAEvC,IAAAC,oBAAA,CAAgB,MAAM;AACpB,MAAA,KAAA,CAAM,UAAU,IAAA,EAAM;AAAA,QACpB,MAAA,EAAQ,MAAA;AAAA,QACR,IAAA;AAAA,QACA,OAAA,EAAS;AAAA,UACP,cAAA,EAAgB;AAAA;AAClB,OACD,CAAA,CAAE,IAAA;AAAA,QACD,CAAA,GAAA,KAAO;AAGL,UAAA,GAAA,CAAI,IAAA,EAAK,CAAE,KAAA,CAAM,MAAM;AAAA,UAEvB,CAAC,CAAA;AAED,UAAA,IAAI,GAAA,CAAI,MAAA,IAAU,GAAA,IAAO,GAAA,CAAI,SAAS,GAAA,EAAK;AACzC,YAAA,SAAA,GAAY,CAAA;AAAA,UACd;AAAA,QACF,CAAA;AAAA,QACA,MAAM;AACJ,UAAA,SAAA,EAAA;AACA,UAAAJ,sBAAA,IAAeC,UAAA,CAAM,KAAK,0DAA0D,CAAA;AAAA,QACtF;AAAA,OACF;AAAA,IACF,CAAC,CAAA;AAAA,EACH,CAAC,CAAA;AACH;AAEA,SAAS,gBAAgB,GAAA,EAA8B;AACrD,EAAA,IAAI;AACF,IAAA,OAAO,IAAI,IAAI,GAAG,CAAA;AAAA,EACpB,CAAA,CAAA,MAAQ;AACN,IAAAD,sBAAA,IAAeC,UAAA,CAAM,IAAA,CAAK,CAAA,iCAAA,EAAoC,GAAG,CAAA,CAAE,CAAA;AACnE,IAAA,OAAO,MAAA;AAAA,EACT;AACF;;;;;"}

package/build/cjs/{integrations → prod/integrations}/tracing/vercelai.js

@@ -1,16 +1,16 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const core = require('@sentry/core');
+const serverUtils = require('@sentry/server-utils');
 
-const INTEGRATION_NAME = "VercelAI";
 const _vercelAIIntegration = ((options = {}) => {
-  return {
-    name: INTEGRATION_NAME,
+  const inner = serverUtils.vercelAiIntegration(options);
+  return core.extendIntegration(inner, {
     options,
     setup(client) {
-      core.addVercelAiProcessors(client);
+      serverUtils.addVercelAiProcessors(client);
     }
-  };
+  });
 });
 const vercelAIIntegration = core.defineIntegration(_vercelAIIntegration);
 

package/build/cjs/prod/integrations/tracing/vercelai.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercelai.js","sources":["../../../../../src/integrations/tracing/vercelai.ts"],"sourcesContent":["/**\n * This is a copy of the Vercel AI integration from the node SDK.\n *\n * The only difference is that it does not use `@opentelemetry/instrumentation`\n * because Cloudflare Workers do not support it.\n *\n * Therefore, we cannot automatically patch setting `experimental_telemetry: { isEnabled: true }`\n * and users have to manually set this to get spans.\n */\n\nimport type { IntegrationFn } from '@sentry/core';\nimport { defineIntegration, extendIntegration } from '@sentry/core';\nimport { addVercelAiProcessors, vercelAiIntegration, type VercelAiOptions } from '@sentry/server-utils';\n\nconst _vercelAIIntegration = ((options: VercelAiOptions = {}) => {\n  const inner = vercelAiIntegration(options);\n\n  return extendIntegration(inner, {\n    options,\n    setup(client) {\n      addVercelAiProcessors(client);\n    },\n  });\n}) satisfies IntegrationFn;\n\n/**\n * Adds Sentry tracing instrumentation for the [ai](https://www.npmjs.com/package/ai) library.\n * This integration is not enabled by default, you need to manually add it.\n *\n * For more information, see the [`ai` documentation](https://sdk.vercel.ai/docs/ai-sdk-core/telemetry).\n *\n *  You need to enable collecting spans for a specific call by setting\n * `experimental_telemetry.isEnabled` to `true` in the first argument of the function call.\n *\n * ```javascript\n * const result = await generateText({\n *   model: openai('gpt-4-turbo'),\n *   experimental_telemetry: { isEnabled: true },\n * });\n * ```\n *\n * If you want to collect inputs and outputs for a specific call, you must specifically opt-in to each\n * function call by setting `experimental_telemetry.recordInputs` and `experimental_telemetry.recordOutputs`\n * to `true`.\n *\n * ```javascript\n * const result = await generateText({\n *  model: openai('gpt-4-turbo'),\n *  experimental_telemetry: { isEnabled: true, recordInputs: true, recordOutputs: true },\n * });\n */\nexport const vercelAIIntegration = defineIntegration(_vercelAIIntegration);\n"],"names":["vercelAiIntegration","extendIntegration","addVercelAiProcessors","defineIntegration"],"mappings":";;;;;AAcA,MAAM,oBAAA,IAAwB,CAAC,OAAA,GAA2B,EAAC,KAAM;AAC/D,EAAA,MAAM,KAAA,GAAQA,gCAAoB,OAAO,CAAA;AAEzC,EAAA,OAAOC,uBAAkB,KAAA,EAAO;AAAA,IAC9B,OAAA;AAAA,IACA,MAAM,MAAA,EAAQ;AACZ,MAAAC,iCAAA,CAAsB,MAAM,CAAA;AAAA,IAC9B;AAAA,GACD,CAAA;AACH,CAAA,CAAA;AA4BO,MAAM,mBAAA,GAAsBC,uBAAkB,oBAAoB;;;;"}

package/build/cjs/prod/opentelemetry/tracer.js

@@ -0,0 +1,49 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const api = require('@opentelemetry/api');
+const core = require('@sentry/core');
+
+function setupOpenTelemetryTracer() {
+  api.trace.setGlobalTracerProvider(new SentryCloudflareTraceProvider());
+}
+class SentryCloudflareTraceProvider {
+  constructor() {
+    this._tracers = /* @__PURE__ */ new Map();
+  }
+  getTracer(name, version, options) {
+    const key = `${name}@${version || ""}:${options?.schemaUrl || ""}`;
+    if (!this._tracers.has(key)) {
+      this._tracers.set(key, new SentryCloudflareTracer());
+    }
+    return this._tracers.get(key);
+  }
+}
+class SentryCloudflareTracer {
+  startSpan(name, options) {
+    return core.startInactiveSpan({
+      ...options,
+      name,
+      attributes: {
+        ...options?.attributes,
+        "sentry.cloudflare_tracer": true
+      }
+    });
+  }
+  startActiveSpan(name, options, context, fn) {
+    const opts = typeof options === "object" && options !== null ? options : {};
+    const spanOpts = {
+      ...opts,
+      name,
+      attributes: {
+        ...opts.attributes,
+        "sentry.cloudflare_tracer": true
+      }
+    };
+    const callback = typeof options === "function" ? options : typeof context === "function" ? context : typeof fn === "function" ? fn : () => {
+    };
+    return core.startSpanManual(spanOpts, callback);
+  }
+}
+
+exports.setupOpenTelemetryTracer = setupOpenTelemetryTracer;
+//# sourceMappingURL=tracer.js.map

package/build/cjs/prod/opentelemetry/tracer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracer.js","sources":["../../../../src/opentelemetry/tracer.ts"],"sourcesContent":["import type { Context, Span, SpanOptions, Tracer, TracerProvider } from '@opentelemetry/api';\nimport { trace } from '@opentelemetry/api';\nimport { startInactiveSpan, startSpanManual } from '@sentry/core';\n\n/**\n * Set up a mock OTEL tracer to allow inter-op with OpenTelemetry emitted spans.\n * This is not perfect but handles easy/common use cases.\n */\nexport function setupOpenTelemetryTracer(): void {\n  trace.setGlobalTracerProvider(new SentryCloudflareTraceProvider());\n}\n\nclass SentryCloudflareTraceProvider implements TracerProvider {\n  private readonly _tracers: Map<string, Tracer> = new Map();\n\n  public getTracer(name: string, version?: string, options?: { schemaUrl?: string }): Tracer {\n    const key = `${name}@${version || ''}:${options?.schemaUrl || ''}`;\n    if (!this._tracers.has(key)) {\n      this._tracers.set(key, new SentryCloudflareTracer());\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return this._tracers.get(key)!;\n  }\n}\n\nclass SentryCloudflareTracer implements Tracer {\n  public startSpan(name: string, options?: SpanOptions): Span {\n    return startInactiveSpan({\n      ...options,\n      name,\n      attributes: {\n        ...options?.attributes,\n        'sentry.cloudflare_tracer': true,\n      },\n    });\n  }\n\n  /**\n   * NOTE: This does not handle `context` being passed in. It will always put spans on the current scope.\n   */\n  public startActiveSpan<F extends (span: Span) => unknown>(name: string, fn: F): ReturnType<F>;\n  public startActiveSpan<F extends (span: Span) => unknown>(name: string, options: SpanOptions, fn: F): ReturnType<F>;\n  public startActiveSpan<F extends (span: Span) => unknown>(\n    name: string,\n    options: SpanOptions,\n    context: Context,\n    fn: F,\n  ): ReturnType<F>;\n  public startActiveSpan<F extends (span: Span) => unknown>(\n    name: string,\n    options: unknown,\n    context?: unknown,\n    fn?: F,\n  ): ReturnType<F> {\n    const opts = (typeof options === 'object' && options !== null ? options : {}) as SpanOptions;\n\n    const spanOpts = {\n      ...opts,\n      name,\n      attributes: {\n        ...opts.attributes,\n        'sentry.cloudflare_tracer': true,\n      },\n    };\n\n    const callback = (\n      typeof options === 'function'\n        ? options\n        : typeof context === 'function'\n          ? context\n          : typeof fn === 'function'\n            ? fn\n            : () => {}\n    ) as F;\n\n    // In OTEL the semantic matches `startSpanManual` because spans are not auto-ended\n    return startSpanManual(spanOpts, callback) as ReturnType<F>;\n  }\n}\n"],"names":["trace","startInactiveSpan","startSpanManual"],"mappings":";;;;;AAQO,SAAS,wBAAA,GAAiC;AAC/C,EAAAA,SAAA,CAAM,uBAAA,CAAwB,IAAI,6BAAA,EAA+B,CAAA;AACnE;AAEA,MAAM,6BAAA,CAAwD;AAAA,EAA9D,WAAA,GAAA;AACE,IAAA,IAAA,CAAiB,QAAA,uBAAoC,GAAA,EAAI;AAAA,EAAA;AAAA,EAElD,SAAA,CAAU,IAAA,EAAc,OAAA,EAAkB,OAAA,EAA0C;AACzF,IAAA,MAAM,GAAA,GAAM,GAAG,IAAI,CAAA,CAAA,EAAI,WAAW,EAAE,CAAA,CAAA,EAAI,OAAA,EAAS,SAAA,IAAa,EAAE,CAAA,CAAA;AAChE,IAAA,IAAI,CAAC,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,GAAG,CAAA,EAAG;AAC3B,MAAA,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,GAAA,EAAK,IAAI,wBAAwB,CAAA;AAAA,IACrD;AAGA,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,GAAG,CAAA;AAAA,EAC9B;AACF;AAEA,MAAM,sBAAA,CAAyC;AAAA,EACtC,SAAA,CAAU,MAAc,OAAA,EAA6B;AAC1D,IAAA,OAAOC,sBAAA,CAAkB;AAAA,MACvB,GAAG,OAAA;AAAA,MACH,IAAA;AAAA,MACA,UAAA,EAAY;AAAA,QACV,GAAG,OAAA,EAAS,UAAA;AAAA,QACZ,0BAAA,EAA4B;AAAA;AAC9B,KACD,CAAA;AAAA,EACH;AAAA,EAaO,eAAA,CACL,IAAA,EACA,OAAA,EACA,OAAA,EACA,EAAA,EACe;AACf,IAAA,MAAM,OAAQ,OAAO,OAAA,KAAY,YAAY,OAAA,KAAY,IAAA,GAAO,UAAU,EAAC;AAE3E,IAAA,MAAM,QAAA,GAAW;AAAA,MACf,GAAG,IAAA;AAAA,MACH,IAAA;AAAA,MACA,UAAA,EAAY;AAAA,QACV,GAAG,IAAA,CAAK,UAAA;AAAA,QACR,0BAAA,EAA4B;AAAA;AAC9B,KACF;AAEA,IAAA,MAAM,QAAA,GACJ,OAAO,OAAA,KAAY,UAAA,GACf,OAAA,GACA,OAAO,OAAA,KAAY,UAAA,GACjB,OAAA,GACA,OAAO,EAAA,KAAO,UAAA,GACZ,KACA,MAAM;AAAA,IAAC,CAAA;AAIjB,IAAA,OAAOC,oBAAA,CAAgB,UAAU,QAAQ,CAAA;AAAA,EAC3C;AACF;;;;"}

package/build/cjs/prod/options.js

@@ -0,0 +1,33 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+function isVersionMetadata(value) {
+  return core.isObjectLike(value) && "id" in value && typeof value.id === "string";
+}
+function getEnvVar(env, varName) {
+  return core.isObjectLike(env) && varName in env && typeof env[varName] === "string" ? env[varName] : void 0;
+}
+function getFinalOptions(userOptions = {}, env) {
+  if (typeof env !== "object" || env === null) {
+    return userOptions;
+  }
+  const release = "SENTRY_RELEASE" in env && typeof env.SENTRY_RELEASE === "string" ? env.SENTRY_RELEASE : "CF_VERSION_METADATA" in env && isVersionMetadata(env.CF_VERSION_METADATA) ? env.CF_VERSION_METADATA.id : void 0;
+  const tracesSampleRate = userOptions.tracesSampleRate ?? parseFloat(getEnvVar(env, "SENTRY_TRACES_SAMPLE_RATE") ?? "");
+  return {
+    release,
+    ...userOptions,
+    dsn: userOptions.dsn ?? getEnvVar(env, "SENTRY_DSN"),
+    environment: userOptions.environment ?? getEnvVar(env, "SENTRY_ENVIRONMENT"),
+    tracesSampleRate: isFinite(tracesSampleRate) ? tracesSampleRate : void 0,
+    debug: userOptions.debug ?? core.envToBool(getEnvVar(env, "SENTRY_DEBUG")),
+    tunnel: userOptions.tunnel ?? getEnvVar(env, "SENTRY_TUNNEL"),
+    traceLifecycle: userOptions.traceLifecycle ?? getTraceLifecycleFromEnv(getEnvVar(env, "SENTRY_TRACE_LIFECYCLE"))
+  };
+}
+function getTraceLifecycleFromEnv(envVar) {
+  return envVar === "stream" || envVar === "static" ? envVar : void 0;
+}
+
+exports.getFinalOptions = getFinalOptions;
+//# sourceMappingURL=options.js.map

package/build/cjs/prod/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sources":["../../../src/options.ts"],"sourcesContent":["import { isObjectLike, envToBool } from '@sentry/core';\nimport type { CloudflareOptions } from './client';\n\n/**\n * Cloudflare's version metadata binding structure.\n * @see https://developers.cloudflare.com/workers/runtime-apis/bindings/version-metadata/\n */\ninterface CfVersionMetadata {\n  id: string;\n  tag?: string;\n  timestamp?: string;\n}\n\n/**\n * Checks if the value is a valid CF_VERSION_METADATA binding.\n */\nfunction isVersionMetadata(value: unknown): value is CfVersionMetadata {\n  return isObjectLike(value) && 'id' in value && typeof value.id === 'string';\n}\n\nfunction getEnvVar<T extends Record<string, unknown>>(env: unknown, varName: keyof T): string | undefined {\n  return isObjectLike(env) && varName in env && typeof (env as T)[varName] === 'string'\n    ? ((env as T)[varName] as string)\n    : undefined;\n}\n\n/**\n * Merges the options passed in from the user with the options we read from\n * the Cloudflare `env` environment variable object.\n *\n * Release is determined with the following priority (highest to lowest):\n * 1. User-provided release option\n * 2. SENTRY_RELEASE environment variable\n * 3. CF_VERSION_METADATA.id binding (if configured in the wrangler config)\n *\n * @param userOptions - The options passed in from the user.\n * @param env - The environment variables.\n *\n * @returns The final options.\n */\nexport function getFinalOptions(userOptions: CloudflareOptions = {}, env: unknown): CloudflareOptions {\n  if (typeof env !== 'object' || env === null) {\n    return userOptions;\n  }\n\n  // Priority: userOptions.release > SENTRY_RELEASE > CF_VERSION_METADATA.id\n  const release =\n    'SENTRY_RELEASE' in env && typeof env.SENTRY_RELEASE === 'string'\n      ? env.SENTRY_RELEASE\n      : 'CF_VERSION_METADATA' in env && isVersionMetadata(env.CF_VERSION_METADATA)\n        ? env.CF_VERSION_METADATA.id\n        : undefined;\n\n  const tracesSampleRate =\n    userOptions.tracesSampleRate ?? parseFloat(getEnvVar(env, 'SENTRY_TRACES_SAMPLE_RATE') ?? '');\n\n  // Spotlight precedence (mirrors node-core's getSpotlightConfig):\n  // - false or explicit string from options: use as-is\n  // - true: enable, but prefer a custom URL from the env var if set\n  // - undefined: defer entirely to the env var (bool or URL)\n  /*! rollup-include-development-only */\n  const spotlight = getSpotlightFromEnv(userOptions.spotlight, getEnvVar(env, 'SENTRY_SPOTLIGHT'));\n  /*! rollup-include-development-only-end */\n\n  return {\n    release,\n    ...userOptions,\n    dsn: userOptions.dsn ?? getEnvVar(env, 'SENTRY_DSN'),\n    environment: userOptions.environment ?? getEnvVar(env, 'SENTRY_ENVIRONMENT'),\n    tracesSampleRate: isFinite(tracesSampleRate) ? tracesSampleRate : undefined,\n    debug: userOptions.debug ?? envToBool(getEnvVar(env, 'SENTRY_DEBUG')),\n    tunnel: userOptions.tunnel ?? getEnvVar(env, 'SENTRY_TUNNEL'),\n    traceLifecycle: userOptions.traceLifecycle ?? getTraceLifecycleFromEnv(getEnvVar(env, 'SENTRY_TRACE_LIFECYCLE')),\n    /*! rollup-include-development-only */\n    spotlight,\n    /*! rollup-include-development-only-end */\n  };\n}\n\n/**\n * Resolve the spotlight option from a user-supplied value and an env binding string.\n * Mirrors node-core's `getSpotlightConfig` precedence:\n *   - `false` or explicit string from options → use as-is\n *   - `true` → enable, but prefer a custom URL from the env var if set\n *   - `undefined` → defer entirely to the env var (bool or URL)\n */\nfunction getSpotlightFromEnv(\n  optionsSpotlight: boolean | string | undefined,\n  envVar: string | undefined,\n): boolean | string | undefined {\n  if (optionsSpotlight === false) {\n    return false;\n  }\n  if (typeof optionsSpotlight === 'string') {\n    return optionsSpotlight;\n  }\n\n  // optionsSpotlight is true or undefined\n  const envBool = envToBool(envVar, { strict: true });\n  const envUrl = envBool === null && envVar ? envVar : undefined;\n\n  return optionsSpotlight === true\n    ? (envUrl ?? true) // true: use env URL if present, otherwise true\n    : (envBool ?? envUrl); // undefined: use env var (bool or URL)\n}\n\nfunction getTraceLifecycleFromEnv(envVar: string | undefined): 'static' | 'stream' | undefined {\n  return envVar === 'stream' || envVar === 'static' ? envVar : undefined;\n}\n"],"names":["isObjectLike","envToBool"],"mappings":";;;;AAgBA,SAAS,kBAAkB,KAAA,EAA4C;AACrE,EAAA,OAAOA,kBAAa,KAAK,CAAA,IAAK,QAAQ,KAAA,IAAS,OAAO,MAAM,EAAA,KAAO,QAAA;AACrE;AAEA,SAAS,SAAA,CAA6C,KAAc,OAAA,EAAsC;AACxG,EAAA,OAAOA,iBAAA,CAAa,GAAG,CAAA,IAAK,OAAA,IAAW,GAAA,IAAO,OAAQ,GAAA,CAAU,OAAO,CAAA,KAAM,QAAA,GACvE,GAAA,CAAU,OAAO,CAAA,GACnB,MAAA;AACN;AAgBO,SAAS,eAAA,CAAgB,WAAA,GAAiC,EAAC,EAAG,GAAA,EAAiC;AACpG,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,IAAA,EAAM;AAC3C,IAAA,OAAO,WAAA;AAAA,EACT;AAGA,EAAA,MAAM,UACJ,gBAAA,IAAoB,GAAA,IAAO,OAAO,GAAA,CAAI,mBAAmB,QAAA,GACrD,GAAA,CAAI,cAAA,GACJ,qBAAA,IAAyB,OAAO,iBAAA,CAAkB,GAAA,CAAI,mBAAmB,CAAA,GACvE,GAAA,CAAI,oBAAoB,EAAA,GACxB,MAAA;AAER,EAAA,MAAM,gBAAA,GACJ,YAAY,gBAAA,IAAoB,UAAA,CAAW,UAAU,GAAA,EAAK,2BAA2B,KAAK,EAAE,CAAA;AAM9F,EAAA,OAAO;AAAA,IACL,OAAA;AAAA,IACA,GAAG,WAAA;AAAA,IACH,GAAA,EAAK,WAAA,CAAY,GAAA,IAAO,SAAA,CAAU,KAAK,YAAY,CAAA;AAAA,IACnD,WAAA,EAAa,WAAA,CAAY,WAAA,IAAe,SAAA,CAAU,KAAK,oBAAoB,CAAA;AAAA,IAC3E,gBAAA,EAAkB,QAAA,CAAS,gBAAgB,CAAA,GAAI,gBAAA,GAAmB,MAAA;AAAA,IAClE,OAAO,WAAA,CAAY,KAAA,IAASC,eAAU,SAAA,CAAU,GAAA,EAAK,cAAc,CAAC,CAAA;AAAA,IACpE,MAAA,EAAQ,WAAA,CAAY,MAAA,IAAU,SAAA,CAAU,KAAK,eAAe,CAAA;AAAA,IAC5D,gBAAgB,WAAA,CAAY,cAAA,IAAkB,yBAAyB,SAAA,CAAU,GAAA,EAAK,wBAAwB,CAAC;AAAA,GAC/G;AACJ;AA6BA,SAAS,yBAAyB,MAAA,EAA6D;AAC7F,EAAA,OAAO,MAAA,KAAW,QAAA,IAAY,MAAA,KAAW,QAAA,GAAW,MAAA,GAAS,MAAA;AAC/D;;;;"}

package/build/cjs/prod/pages-plugin.js

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const noDiagnosticChannels = require('@sentry/server-utils/no-diagnostic-channels');
+const request = require('./request.js');
+const sdk = require('./sdk.js');
+
+function sentryPagesPlugin(handlerOrOptions) {
+  noDiagnosticChannels.setAsyncLocalStorageAsyncContextStrategy();
+  return (context) => {
+    if (context.request.method === "OPTIONS" || context.request.method === "HEAD") {
+      return context.next();
+    }
+    const options = typeof handlerOrOptions === "function" ? handlerOrOptions(context) : handlerOrOptions;
+    const executionContext = { ...context, props: {} };
+    return request.wrapRequestHandlerWithInit(
+      { options, request: context.request, context: executionContext },
+      () => context.next(),
+      sdk.init
+    );
+  };
+}
+
+exports.sentryPagesPlugin = sentryPagesPlugin;
+//# sourceMappingURL=pages-plugin.js.map

package/build/cjs/prod/pages-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pages-plugin.js","sources":["../../../src/pages-plugin.ts"],"sourcesContent":["import { setAsyncLocalStorageAsyncContextStrategy } from '@sentry/server-utils/no-diagnostic-channels';\nimport type { CloudflareOptions } from './client';\nimport type { ExecutionContextCompat } from './executionContext';\nimport { wrapRequestHandlerWithInit } from './request';\nimport { init } from './sdk';\n\n/**\n * Plugin middleware for Cloudflare Pages.\n *\n * Initializes the SDK and wraps cloudflare pages requests with SDK instrumentation.\n *\n * @example Simple usage\n *\n * ```javascript\n * // functions/_middleware.js\n * import * as Sentry from '@sentry/cloudflare';\n *\n * export const onRequest = Sentry.sentryPagesPlugin({\n *   dsn: process.env.SENTRY_DSN,\n *   tracesSampleRate: 1.0,\n * });\n * ```\n *\n * @example Usage with handler function to access context for environmental variables\n *\n * ```javascript\n * import * as Sentry from '@sentry/cloudflare';\n *\n * const const onRequest = Sentry.sentryPagesPlugin((context) => ({\n *   dsn: context.env.SENTRY_DSN,\n *   tracesSampleRate: 1.0,\n * })\n * ```\n *\n * @param handlerOrOptions Configuration options or a function that returns configuration options.\n * @returns A plugin function that can be used in Cloudflare Pages.\n */\nexport function sentryPagesPlugin<\n  // oxlint-disable-next-line typescript/no-explicit-any\n  Env = any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Params extends string = any,\n  Data extends Record<string, unknown> = Record<string, unknown>,\n  // Although it is not ideal to use `any` here, it makes usage more flexible for different setups.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  PluginParams = any,\n>(\n  handlerOrOptions:\n    | CloudflareOptions\n    | ((context: EventPluginContext<Env, Params, Data, PluginParams>) => CloudflareOptions),\n): PagesPluginFunction<Env, Params, Data, PluginParams> {\n  setAsyncLocalStorageAsyncContextStrategy();\n  return context => {\n    if (context.request.method === 'OPTIONS' || context.request.method === 'HEAD') {\n      return context.next();\n    }\n\n    const options = typeof handlerOrOptions === 'function' ? handlerOrOptions(context) : handlerOrOptions;\n    // A Pages `EventPluginContext` is not a Workers `ExecutionContext`, but `wrapRequestHandler` only\n    // uses `waitUntil` and a `'storage' in context` check, both of which this satisfies.\n    const executionContext = { ...context, props: {} } as unknown as ExecutionContextCompat;\n    return wrapRequestHandlerWithInit(\n      { options, request: context.request, context: executionContext },\n      () => context.next(),\n      init,\n    );\n  };\n}\n"],"names":["setAsyncLocalStorageAsyncContextStrategy","wrapRequestHandlerWithInit","init"],"mappings":";;;;;;AAqCO,SAAS,kBAUd,gBAAA,EAGsD;AACtD,EAAAA,6DAAA,EAAyC;AACzC,EAAA,OAAO,CAAA,OAAA,KAAW;AAChB,IAAA,IAAI,QAAQ,OAAA,CAAQ,MAAA,KAAW,aAAa,OAAA,CAAQ,OAAA,CAAQ,WAAW,MAAA,EAAQ;AAC7E,MAAA,OAAO,QAAQ,IAAA,EAAK;AAAA,IACtB;AAEA,IAAA,MAAM,UAAU,OAAO,gBAAA,KAAqB,UAAA,GAAa,gBAAA,CAAiB,OAAO,CAAA,GAAI,gBAAA;AAGrF,IAAA,MAAM,mBAAmB,EAAE,GAAG,OAAA,EAAS,KAAA,EAAO,EAAC,EAAE;AACjD,IAAA,OAAOC,kCAAA;AAAA,MACL,EAAE,OAAA,EAAS,OAAA,EAAS,OAAA,CAAQ,OAAA,EAAS,SAAS,gBAAA,EAAiB;AAAA,MAC/D,MAAM,QAAQ,IAAA,EAAK;AAAA,MACnBC;AAAA,KACF;AAAA,EACF,CAAA;AACF;;;;"}

package/build/cjs/prod/request.js

@@ -0,0 +1,132 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+const httpServer = require('./integrations/httpServer.js');
+const baseSdk = require('./baseSdk.js');
+const flush = require('./flush.js');
+const scopeUtils = require('./scope-utils.js');
+const invocationScope = require('./utils/invocationScope.js');
+const streaming = require('./utils/streaming.js');
+
+function getRequestErrorMechanismType(context) {
+  return context && "storage" in context ? "auto.faas.cloudflare.durable_object" : "auto.http.cloudflare";
+}
+function wrapRequestHandler(wrapperOptions, handler) {
+  return wrapRequestHandlerWithInit(wrapperOptions, handler, baseSdk.initBaseSdk);
+}
+function wrapRequestHandlerWithInit(wrapperOptions, handler, initSdk) {
+  return invocationScope.withInvocationIsolationScope(async (isolationScope) => {
+    const { options, request, captureErrors = true } = wrapperOptions;
+    const context = wrapperOptions.context;
+    const waitUntil = context ? flush.getOriginalWaitUntil(context).bind(context) : void 0;
+    const errorMechanismType = getRequestErrorMechanismType(context);
+    const client = initSdk({ ...options, ctx: context });
+    isolationScope.setClient(client);
+    const urlObject = core.parseStringToURLObject(request.url);
+    const [name, attributes] = core.getHttpSpanDetailsFromUrlObject(
+      urlObject,
+      "server",
+      "auto.http.cloudflare",
+      request,
+      void 0,
+      client
+    );
+    const contentLength = request.headers.get("content-length");
+    if (contentLength) {
+      attributes["http.request.body.size"] = parseInt(contentLength, 10);
+    }
+    const userAgentHeader = request.headers.get("user-agent");
+    if (userAgentHeader) {
+      attributes["user_agent.original"] = userAgentHeader;
+    }
+    if (client) {
+      Object.assign(
+        attributes,
+        core.httpHeadersToSpanAttributes(core.winterCGHeadersToDict(request.headers), client.getDataCollectionOptions())
+      );
+    }
+    attributes[core.SEMANTIC_ATTRIBUTE_SENTRY_OP] = "http.server";
+    scopeUtils.addCloudResourceContext(isolationScope);
+    scopeUtils.addRequest(isolationScope, request);
+    if (request.cf) {
+      scopeUtils.addCultureContext(isolationScope, request.cf);
+      if (typeof request.cf.httpProtocol === "string") {
+        attributes["network.protocol.name"] = request.cf.httpProtocol;
+      }
+    }
+    if (request.method === "OPTIONS" || request.method === "HEAD") {
+      try {
+        return await handler();
+      } catch (e) {
+        if (captureErrors) {
+          core.captureException(e, { mechanism: { handled: false, type: errorMechanismType } });
+        }
+        throw e;
+      } finally {
+        waitUntil?.(flush.flushAndDispose(client));
+      }
+    }
+    if (client) {
+      await httpServer.captureIncomingRequestBody(client, request);
+    }
+    return core.continueTrace(
+      { sentryTrace: request.headers.get("sentry-trace") || "", baggage: request.headers.get("baggage") },
+      () => {
+        return core.startSpanManual({ name, attributes }, async (span) => {
+          let res;
+          try {
+            res = await handler();
+            core.setHttpStatus(span, res.status);
+          } catch (e) {
+            span.end();
+            if (captureErrors) {
+              core.captureException(e, { mechanism: { handled: false, type: errorMechanismType } });
+            }
+            waitUntil?.(flush.flushAndDispose(client));
+            throw e;
+          }
+          const classification = streaming.classifyResponseStreaming(res);
+          if (classification.isStreaming && res.body) {
+            try {
+              let ended = false;
+              const endSpanOnce = () => {
+                if (ended) return;
+                ended = true;
+                span.end();
+                waitUntil?.(flush.flushAndDispose(client));
+              };
+              const transform = new TransformStream({
+                flush() {
+                  endSpanOnce();
+                },
+                cancel() {
+                  endSpanOnce();
+                }
+              });
+              return new Response(res.body.pipeThrough(transform), {
+                status: res.status,
+                statusText: res.statusText,
+                headers: res.headers
+              });
+            } catch {
+              span.end();
+              waitUntil?.(flush.flushAndDispose(client));
+              return res;
+            }
+          }
+          span.end();
+          if (res.status === 101) {
+            waitUntil?.(client?.flush(2e3));
+          } else {
+            waitUntil?.(flush.flushAndDispose(client));
+          }
+          return res;
+        });
+      }
+    );
+  });
+}
+
+exports.wrapRequestHandler = wrapRequestHandler;
+exports.wrapRequestHandlerWithInit = wrapRequestHandlerWithInit;
+//# sourceMappingURL=request.js.map

package/build/cjs/prod/request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request.js","sources":["../../../src/request.ts"],"sourcesContent":["import type { CfProperties, IncomingRequestCfProperties } from '@cloudflare/workers-types';\nimport {\n  captureException,\n  continueTrace,\n  getHttpSpanDetailsFromUrlObject,\n  httpHeadersToSpanAttributes,\n  parseStringToURLObject,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  setHttpStatus,\n  startSpanManual,\n  winterCGHeadersToDict,\n} from '@sentry/core';\nimport { captureIncomingRequestBody } from './integrations/httpServer';\nimport { initBaseSdk } from './baseSdk';\nimport type { CloudflareClient, CloudflareOptions } from './client';\nimport type { ExecutionContextCompat } from './executionContext';\nimport { flushAndDispose, getOriginalWaitUntil } from './flush';\nimport { addCloudResourceContext, addCultureContext, addRequest } from './scope-utils';\nimport { withInvocationIsolationScope } from './utils/invocationScope';\nimport { classifyResponseStreaming } from './utils/streaming';\n\nfunction getRequestErrorMechanismType(context: ExecutionContextCompat | undefined): string {\n  // Durable Object fetch handlers use DO state as context (see instrumentDurableObjectWithSentry)\n  return context && 'storage' in context ? 'auto.faas.cloudflare.durable_object' : 'auto.http.cloudflare';\n}\n\ninterface RequestHandlerWrapperOptions {\n  options: CloudflareOptions;\n  request: Request<unknown, IncomingRequestCfProperties<unknown> | CfProperties<unknown>>;\n  context: ExecutionContextCompat | undefined;\n  /**\n   * If true, errors will be captured, rethrown and sent to Sentry.\n   * Otherwise, errors are rethrown but not captured.\n   *\n   * You most likely don't want to set this to `false`, if you use `wrapRequestHandler` directly.\n   * This is primarily meant as an escape hatch for higher-level SDKs relying on additional error\n   * capturing mechanisms where this wrapper captures errors too early or too generally.\n   *\n   * @default true\n   */\n  captureErrors?: boolean;\n}\n\ntype InitSdk = (options: CloudflareOptions) => CloudflareClient | undefined;\n\n/**\n * Wraps a cloudflare request handler in Sentry instrumentation.\n *\n * The client is set up with the default integrations that work without the `nodejs_compat`\n * compatibility flag, so that this also works on runtimes that cannot enable it (e.g. Shopify\n * Oxygen). On a runtime that has `nodejs_compat`, pass `defaultIntegrations:\n * getDefaultIntegrations(options)` in `options` to get the full set instead.\n */\nexport function wrapRequestHandler(\n  wrapperOptions: RequestHandlerWrapperOptions,\n  handler: (...args: unknown[]) => Response | Promise<Response>,\n): Promise<Response> {\n  return wrapRequestHandlerWithInit(wrapperOptions, handler, initBaseSdk);\n}\n\n/**\n * Same as {@link wrapRequestHandler}, but with the SDK initialization injected.\n *\n * Wrappers that are only reachable from the main entry point — where `nodejs_compat` is a\n * requirement anyway — pass `init` from `sdk.ts` to get the full default integrations.\n *\n * @internal\n */\nexport function wrapRequestHandlerWithInit(\n  wrapperOptions: RequestHandlerWrapperOptions,\n  handler: (...args: unknown[]) => Response | Promise<Response>,\n  initSdk: InitSdk,\n): Promise<Response> {\n  return withInvocationIsolationScope(async isolationScope => {\n    const { options, request, captureErrors = true } = wrapperOptions;\n    const context = wrapperOptions.context;\n\n    // Use getOriginalWaitUntil to get the un-instrumented waitUntil function.\n    // This is crucial to avoid deadlock: the flush lock mechanism wraps waitUntil\n    // to track pending tasks. If we use the instrumented version for flushAndDispose,\n    // it acquires the lock, then flushAndDispose tries to wait for the same lock,\n    // creating a deadlock.\n    const waitUntil = context ? getOriginalWaitUntil(context).bind(context) : undefined;\n    const errorMechanismType = getRequestErrorMechanismType(context);\n\n    const client = initSdk({ ...options, ctx: context });\n    isolationScope.setClient(client);\n\n    const urlObject = parseStringToURLObject(request.url);\n    const [name, attributes] = getHttpSpanDetailsFromUrlObject(\n      urlObject,\n      'server',\n      'auto.http.cloudflare',\n      request,\n      undefined,\n      client,\n    );\n\n    const contentLength = request.headers.get('content-length');\n    if (contentLength) {\n      attributes['http.request.body.size'] = parseInt(contentLength, 10);\n    }\n\n    const userAgentHeader = request.headers.get('user-agent');\n    if (userAgentHeader) {\n      attributes['user_agent.original'] = userAgentHeader;\n    }\n\n    if (client) {\n      Object.assign(\n        attributes,\n        httpHeadersToSpanAttributes(winterCGHeadersToDict(request.headers), client.getDataCollectionOptions()),\n      );\n    }\n\n    attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] = 'http.server';\n\n    addCloudResourceContext(isolationScope);\n    addRequest(isolationScope, request);\n    if (request.cf) {\n      addCultureContext(isolationScope, request.cf);\n\n      if (typeof request.cf.httpProtocol === 'string') {\n        attributes['network.protocol.name'] = request.cf.httpProtocol;\n      }\n    }\n\n    // Do not capture spans for OPTIONS and HEAD requests\n    if (request.method === 'OPTIONS' || request.method === 'HEAD') {\n      try {\n        return await handler();\n      } catch (e) {\n        if (captureErrors) {\n          captureException(e, { mechanism: { handled: false, type: errorMechanismType } });\n        }\n        throw e;\n      } finally {\n        waitUntil?.(flushAndDispose(client));\n      }\n    }\n\n    if (client) {\n      await captureIncomingRequestBody(client, request);\n    }\n\n    return continueTrace(\n      { sentryTrace: request.headers.get('sentry-trace') || '', baggage: request.headers.get('baggage') },\n      () => {\n        // Note: This span will not have a duration unless I/O happens in the handler. This is\n        // because of how the cloudflare workers runtime works.\n        // See: https://developers.cloudflare.com/workers/runtime-apis/performance/\n\n        // Use startSpanManual to control when span ends (needed for streaming responses)\n        return startSpanManual({ name, attributes }, async span => {\n          let res: Response;\n\n          try {\n            res = await handler();\n            setHttpStatus(span, res.status);\n\n            // After the handler runs, the span name might have been updated by nested instrumentation\n            // (e.g., Remix parameterizing routes). The span should already have the correct name\n            // from that instrumentation, so we don't need to do anything here.\n          } catch (e) {\n            span.end();\n            if (captureErrors) {\n              captureException(e, { mechanism: { handled: false, type: errorMechanismType } });\n            }\n            waitUntil?.(flushAndDispose(client));\n            throw e;\n          }\n\n          // Classify response to detect actual streaming\n          const classification = classifyResponseStreaming(res);\n\n          if (classification.isStreaming && res.body) {\n            try {\n              let ended = false;\n\n              const endSpanOnce = (): void => {\n                if (ended) return;\n\n                ended = true;\n                span.end();\n                waitUntil?.(flushAndDispose(client));\n              };\n\n              const transform = new TransformStream({\n                flush() {\n                  // Source stream completed normally.\n                  endSpanOnce();\n                },\n                cancel() {\n                  // Client disconnected (or downstream cancelled). The `cancel`\n                  // is being called while the response is still considered\n                  // active, so this is a safe place to end the span.\n                  endSpanOnce();\n                },\n              });\n\n              return new Response(res.body.pipeThrough(transform), {\n                status: res.status,\n                statusText: res.statusText,\n                headers: res.headers,\n              });\n            } catch {\n              span.end();\n              waitUntil?.(flushAndDispose(client));\n              return res;\n            }\n          }\n\n          // Non-streaming response - end span immediately and return original\n          span.end();\n\n          // Don't dispose for protocol upgrades (101 Switching Protocols) - the connection stays alive.\n          // This includes WebSocket upgrades where webSocketMessage/webSocketClose handlers\n          // will still be called and may need the client to capture errors.\n          if (res.status === 101) {\n            waitUntil?.(client?.flush(2000));\n          } else {\n            waitUntil?.(flushAndDispose(client));\n          }\n          return res;\n        });\n      },\n    );\n  });\n}\n"],"names":["initBaseSdk","withInvocationIsolationScope","getOriginalWaitUntil","parseStringToURLObject","getHttpSpanDetailsFromUrlObject","httpHeadersToSpanAttributes","winterCGHeadersToDict","SEMANTIC_ATTRIBUTE_SENTRY_OP","addCloudResourceContext","addRequest","addCultureContext","captureException","flushAndDispose","captureIncomingRequestBody","continueTrace","startSpanManual","setHttpStatus","classifyResponseStreaming"],"mappings":"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"}

package/build/cjs/prod/scope-utils.js

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+function addCloudResourceContext(scope) {
+  scope.setContext("cloud_resource", {
+    "cloud.provider": "cloudflare"
+  });
+}
+function addCultureContext(scope, cf) {
+  scope.setContext("culture", {
+    timezone: cf.timezone
+  });
+}
+function addRequest(scope, request) {
+  scope.setSDKProcessingMetadata({ normalizedRequest: core.winterCGRequestToRequestData(request) });
+}
+
+exports.addCloudResourceContext = addCloudResourceContext;
+exports.addCultureContext = addCultureContext;
+exports.addRequest = addRequest;
+//# sourceMappingURL=scope-utils.js.map

package/build/cjs/prod/scope-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-utils.js","sources":["../../../src/scope-utils.ts"],"sourcesContent":["import type { CfProperties, IncomingRequestCfProperties } from '@cloudflare/workers-types';\nimport type { Scope } from '@sentry/core';\nimport { winterCGRequestToRequestData } from '@sentry/core';\n\n/**\n * Set cloud resource context on scope.\n */\nexport function addCloudResourceContext(scope: Scope): void {\n  scope.setContext('cloud_resource', {\n    'cloud.provider': 'cloudflare',\n  });\n}\n\n/**\n * Set culture context on scope\n */\nexport function addCultureContext(scope: Scope, cf: IncomingRequestCfProperties | CfProperties): void {\n  scope.setContext('culture', {\n    timezone: cf.timezone,\n  });\n}\n\n/**\n * Set request data on scope\n */\nexport function addRequest(scope: Scope, request: Request): void {\n  scope.setSDKProcessingMetadata({ normalizedRequest: winterCGRequestToRequestData(request) });\n}\n"],"names":["winterCGRequestToRequestData"],"mappings":";;;;AAOO,SAAS,wBAAwB,KAAA,EAAoB;AAC1D,EAAA,KAAA,CAAM,WAAW,gBAAA,EAAkB;AAAA,IACjC,gBAAA,EAAkB;AAAA,GACnB,CAAA;AACH;AAKO,SAAS,iBAAA,CAAkB,OAAc,EAAA,EAAsD;AACpG,EAAA,KAAA,CAAM,WAAW,SAAA,EAAW;AAAA,IAC1B,UAAU,EAAA,CAAG;AAAA,GACd,CAAA;AACH;AAKO,SAAS,UAAA,CAAW,OAAc,OAAA,EAAwB;AAC/D,EAAA,KAAA,CAAM,yBAAyB,EAAE,iBAAA,EAAmBA,iCAAA,CAA6B,OAAO,GAAG,CAAA;AAC7F;;;;;;"}

package/build/cjs/prod/sdk.js

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const vercelai = require('./integrations/tracing/vercelai.js');
+const baseSdk = require('./baseSdk.js');
+
+function getDefaultIntegrations(options) {
+  return [
+    ...baseSdk.getBaseDefaultIntegrations(options),
+    // Subscribes to the `ai` SDK's native `node:diagnostics_channel` telemetry channel.
+    vercelai.vercelAIIntegration()
+  ];
+}
+function init(options) {
+  return baseSdk.initWithDefaultIntegrations(options, getDefaultIntegrations);
+}
+
+exports.getDefaultIntegrations = getDefaultIntegrations;
+exports.init = init;
+//# sourceMappingURL=sdk.js.map

package/build/cjs/prod/sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk.js","sources":["../../../src/sdk.ts"],"sourcesContent":["import type { Integration } from '@sentry/core';\nimport { vercelAIIntegration } from './integrations/tracing/vercelai';\nimport { getBaseDefaultIntegrations, initWithDefaultIntegrations } from './baseSdk';\nimport type { CloudflareClient, CloudflareOptions } from './client';\n\n/**\n * Get the default integrations for the Cloudflare SDK.\n *\n * This is the full set and requires the `nodejs_compat` compatibility flag. Runtimes that cannot\n * enable it (e.g. Shopify Oxygen) go through `wrapRequestHandler`, which only sets up\n * `getBaseDefaultIntegrations`.\n */\nexport function getDefaultIntegrations(options: CloudflareOptions): Integration[] {\n  return [\n    ...getBaseDefaultIntegrations(options),\n    // Subscribes to the `ai` SDK's native `node:diagnostics_channel` telemetry channel.\n    vercelAIIntegration(),\n  ];\n}\n\n/**\n * Initializes the cloudflare SDK.\n */\nexport function init(options: CloudflareOptions): CloudflareClient | undefined {\n  return initWithDefaultIntegrations(options, getDefaultIntegrations);\n}\n"],"names":["getBaseDefaultIntegrations","vercelAIIntegration","initWithDefaultIntegrations"],"mappings":";;;;;AAYO,SAAS,uBAAuB,OAAA,EAA2C;AAChF,EAAA,OAAO;AAAA,IACL,GAAGA,mCAA2B,OAAO,CAAA;AAAA;AAAA,IAErCC,4BAAA;AAAoB,GACtB;AACF;AAKO,SAAS,KAAK,OAAA,EAA0D;AAC7E,EAAA,OAAOC,mCAAA,CAA4B,SAAS,sBAAsB,CAAA;AACpE;;;;;"}

package/build/cjs/prod/transport.js

@@ -0,0 +1,75 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@sentry/core');
+
+const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;
+class IsolatedPromiseBuffer {
+  constructor(_bufferSize = DEFAULT_TRANSPORT_BUFFER_SIZE) {
+    this.$ = [];
+    this._taskProducers = [];
+    this._bufferSize = _bufferSize;
+  }
+  /**
+   * @inheritdoc
+   */
+  add(taskProducer) {
+    if (this._taskProducers.length >= this._bufferSize) {
+      return Promise.reject(core.SENTRY_BUFFER_FULL_ERROR);
+    }
+    this._taskProducers.push(taskProducer);
+    return Promise.resolve({});
+  }
+  /**
+   * @inheritdoc
+   */
+  drain(timeout) {
+    const oldTaskProducers = [...this._taskProducers];
+    this._taskProducers = [];
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        if (timeout && timeout > 0) {
+          resolve(false);
+        }
+      }, timeout);
+      Promise.all(
+        oldTaskProducers.map(
+          (taskProducer) => taskProducer().then(null, () => {
+          })
+        )
+      ).then(() => {
+        clearTimeout(timer);
+        resolve(true);
+      });
+    });
+  }
+}
+function makeCloudflareTransport(options) {
+  function makeRequest(request) {
+    const requestOptions = {
+      body: request.body,
+      method: "POST",
+      headers: options.headers,
+      ...options.fetchOptions
+    };
+    return core.suppressTracing(() => {
+      return (options.fetch ?? fetch)(options.url, requestOptions).then(async (response) => {
+        try {
+          await response.text();
+        } catch {
+        }
+        return {
+          statusCode: response.status,
+          headers: {
+            "x-sentry-rate-limits": response.headers.get("X-Sentry-Rate-Limits"),
+            "retry-after": response.headers.get("Retry-After")
+          }
+        };
+      });
+    });
+  }
+  return core.createTransport(options, makeRequest, new IsolatedPromiseBuffer(options.bufferSize));
+}
+
+exports.IsolatedPromiseBuffer = IsolatedPromiseBuffer;
+exports.makeCloudflareTransport = makeCloudflareTransport;
+//# sourceMappingURL=transport.js.map

package/build/cjs/prod/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sources":["../../../src/transport.ts"],"sourcesContent":["import type { BaseTransportOptions, Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/core';\nimport { createTransport, SENTRY_BUFFER_FULL_ERROR, suppressTracing } from '@sentry/core';\n\nexport interface CloudflareTransportOptions extends BaseTransportOptions {\n  /** Custom fetch function to use. This allows usage of things like Workers VPC */\n  fetch?: typeof fetch;\n  /** Fetch API init parameters. */\n  fetchOptions?: RequestInit;\n}\n\nconst DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * This is a modified promise buffer that collects tasks until drain is called.\n * We need this in the edge runtime because edge function invocations may not share I/O objects, like fetch requests\n * and responses, and the normal PromiseBuffer inherently buffers stuff inbetween incoming requests.\n *\n * A limitation we need to be aware of is that DEFAULT_TRANSPORT_BUFFER_SIZE is the maximum amount of payloads the\n * SDK can send for a given edge function invocation.\n */\nexport class IsolatedPromiseBuffer {\n  // We just have this field because the promise buffer interface requires it.\n  // If we ever remove it from the interface we should also remove it here.\n  public $: Array<PromiseLike<TransportMakeRequestResponse>>;\n\n  private _taskProducers: (() => PromiseLike<TransportMakeRequestResponse>)[];\n\n  private readonly _bufferSize: number;\n\n  public constructor(_bufferSize = DEFAULT_TRANSPORT_BUFFER_SIZE) {\n    this.$ = [];\n    this._taskProducers = [];\n    this._bufferSize = _bufferSize;\n  }\n\n  /**\n   * @inheritdoc\n   */\n  public add(taskProducer: () => PromiseLike<TransportMakeRequestResponse>): PromiseLike<TransportMakeRequestResponse> {\n    if (this._taskProducers.length >= this._bufferSize) {\n      return Promise.reject(SENTRY_BUFFER_FULL_ERROR);\n    }\n\n    this._taskProducers.push(taskProducer);\n    return Promise.resolve({});\n  }\n\n  /**\n   * @inheritdoc\n   */\n  public drain(timeout?: number): PromiseLike<boolean> {\n    const oldTaskProducers = [...this._taskProducers];\n    this._taskProducers = [];\n\n    return new Promise(resolve => {\n      const timer = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // This cannot reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      Promise.all(\n        oldTaskProducers.map(taskProducer =>\n          taskProducer().then(null, () => {\n            // catch all failed requests\n          }),\n        ),\n      ).then(() => {\n        // resolve to true if all fetch requests settled\n        clearTimeout(timer);\n        resolve(true);\n      });\n    });\n  }\n}\n\n/**\n * Creates a Transport that uses the native fetch API to send events to Sentry.\n */\nexport function makeCloudflareTransport(options: CloudflareTransportOptions): Transport {\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    const requestOptions: RequestInit = {\n      body: request.body as BodyInit,\n      method: 'POST',\n      headers: options.headers,\n      ...options.fetchOptions,\n    };\n\n    return suppressTracing(() => {\n      return (options.fetch ?? fetch)(options.url, requestOptions).then(async response => {\n        // Consume the response body to satisfy Cloudflare Workers' fetch requirements.\n        // The runtime requires all fetch response bodies to be read or explicitly canceled\n        // to prevent connection stalls and potential deadlocks. We read the body as text\n        // even though we don't use the content, as Sentry's response information is in the headers.\n        // See: https://github.com/getsentry/sentry-javascript/issues/18534\n        try {\n          await response.text();\n        } catch {\n          // no-op\n        }\n\n        return {\n          statusCode: response.status,\n          headers: {\n            'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n            'retry-after': response.headers.get('Retry-After'),\n          },\n        };\n      });\n    });\n  }\n\n  return createTransport(options, makeRequest, new IsolatedPromiseBuffer(options.bufferSize));\n}\n"],"names":["SENTRY_BUFFER_FULL_ERROR","suppressTracing","createTransport"],"mappings":";;;;AAUA,MAAM,6BAAA,GAAgC,EAAA;AAU/B,MAAM,qBAAA,CAAsB;AAAA,EAS1B,WAAA,CAAY,cAAc,6BAAA,EAA+B;AAC9D,IAAA,IAAA,CAAK,IAAI,EAAC;AACV,IAAA,IAAA,CAAK,iBAAiB,EAAC;AACvB,IAAA,IAAA,CAAK,WAAA,GAAc,WAAA;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA,EAKO,IAAI,YAAA,EAA0G;AACnH,IAAA,IAAI,IAAA,CAAK,cAAA,CAAe,MAAA,IAAU,IAAA,CAAK,WAAA,EAAa;AAClD,MAAA,OAAO,OAAA,CAAQ,OAAOA,6BAAwB,CAAA;AAAA,IAChD;AAEA,IAAA,IAAA,CAAK,cAAA,CAAe,KAAK,YAAY,CAAA;AACrC,IAAA,OAAO,OAAA,CAAQ,OAAA,CAAQ,EAAE,CAAA;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA,EAKO,MAAM,OAAA,EAAwC;AACnD,IAAA,MAAM,gBAAA,GAAmB,CAAC,GAAG,IAAA,CAAK,cAAc,CAAA;AAChD,IAAA,IAAA,CAAK,iBAAiB,EAAC;AAEvB,IAAA,OAAO,IAAI,QAAQ,CAAA,OAAA,KAAW;AAC5B,MAAA,MAAM,KAAA,GAAQ,WAAW,MAAM;AAC7B,QAAA,IAAI,OAAA,IAAW,UAAU,CAAA,EAAG;AAC1B,UAAA,OAAA,CAAQ,KAAK,CAAA;AAAA,QACf;AAAA,MACF,GAAG,OAAO,CAAA;AAIV,MAAA,OAAA,CAAQ,GAAA;AAAA,QACN,gBAAA,CAAiB,GAAA;AAAA,UAAI,CAAA,YAAA,KACnB,YAAA,EAAa,CAAE,IAAA,CAAK,MAAM,MAAM;AAAA,UAEhC,CAAC;AAAA;AACH,OACF,CAAE,KAAK,MAAM;AAEX,QAAA,YAAA,CAAa,KAAK,CAAA;AAClB,QAAA,OAAA,CAAQ,IAAI,CAAA;AAAA,MACd,CAAC,CAAA;AAAA,IACH,CAAC,CAAA;AAAA,EACH;AACF;AAKO,SAAS,wBAAwB,OAAA,EAAgD;AACtF,EAAA,SAAS,YAAY,OAAA,EAAsE;AACzF,IAAA,MAAM,cAAA,GAA8B;AAAA,MAClC,MAAM,OAAA,CAAQ,IAAA;AAAA,MACd,MAAA,EAAQ,MAAA;AAAA,MACR,SAAS,OAAA,CAAQ,OAAA;AAAA,MACjB,GAAG,OAAA,CAAQ;AAAA,KACb;AAEA,IAAA,OAAOC,qBAAgB,MAAM;AAC3B,MAAA,OAAA,CAAQ,OAAA,CAAQ,SAAS,KAAA,EAAO,OAAA,CAAQ,KAAK,cAAc,CAAA,CAAE,IAAA,CAAK,OAAM,QAAA,KAAY;AAMlF,QAAA,IAAI;AACF,UAAA,MAAM,SAAS,IAAA,EAAK;AAAA,QACtB,CAAA,CAAA,MAAQ;AAAA,QAER;AAEA,QAAA,OAAO;AAAA,UACL,YAAY,QAAA,CAAS,MAAA;AAAA,UACrB,OAAA,EAAS;AAAA,YACP,sBAAA,EAAwB,QAAA,CAAS,OAAA,CAAQ,GAAA,CAAI,sBAAsB,CAAA;AAAA,YACnE,aAAA,EAAe,QAAA,CAAS,OAAA,CAAQ,GAAA,CAAI,aAAa;AAAA;AACnD,SACF;AAAA,MACF,CAAC,CAAA;AAAA,IACH,CAAC,CAAA;AAAA,EACH;AAEA,EAAA,OAAOC,qBAAgB,OAAA,EAAS,WAAA,EAAa,IAAI,qBAAA,CAAsB,OAAA,CAAQ,UAAU,CAAC,CAAA;AAC5F;;;;;"}

package/build/cjs/prod/utils/instrumentContext.js

@@ -0,0 +1,63 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const instrumentDurableObjectStorage = require('../instrumentations/instrumentDurableObjectStorage.js');
+
+function instrumentContext(ctx) {
+  if (!ctx) return ctx;
+  const overrides = /* @__PURE__ */ new Map();
+  const contextPrototype = Object.getPrototypeOf(ctx);
+  const prototypeMethodNames = Object.getOwnPropertyNames(contextPrototype);
+  const ownPropertyNames = Object.getOwnPropertyNames(ctx);
+  const instrumented = /* @__PURE__ */ new Set(["constructor"]);
+  const descriptors = {};
+  for (const methodName of [...ownPropertyNames, ...prototypeMethodNames]) {
+    if (instrumented.has(methodName) || typeof ctx[methodName] !== "function") {
+      continue;
+    }
+    instrumented.add(methodName);
+    descriptors[methodName] = makeOverridableDescriptor(overrides, ctx, methodName);
+  }
+  if ("storage" in ctx && ctx.storage) {
+    const originalStorage = ctx.storage;
+    const waitUntil = "waitUntil" in ctx && typeof ctx.waitUntil === "function" ? ctx.waitUntil.bind(ctx) : void 0;
+    let instrumentedStorage;
+    descriptors.storage = {
+      configurable: true,
+      enumerable: true,
+      get: () => {
+        if (!instrumentedStorage) {
+          instrumentedStorage = instrumentDurableObjectStorage.instrumentDurableObjectStorage(originalStorage, waitUntil);
+        }
+        return instrumentedStorage;
+      }
+    };
+    descriptors.originalStorage = {
+      configurable: true,
+      enumerable: false,
+      get: () => originalStorage
+    };
+  }
+  return Object.create(ctx, descriptors);
+}
+function makeOverridableDescriptor(store, ctx, method) {
+  return {
+    configurable: true,
+    enumerable: true,
+    set: (newValue) => {
+      if (typeof newValue == "function") {
+        store.set(method, newValue);
+        return;
+      }
+      Reflect.set(ctx, method, newValue);
+    },
+    get: () => {
+      if (store.has(method)) return store.get(method);
+      const methodFunction = Reflect.get(ctx, method);
+      if (typeof methodFunction !== "function") return methodFunction;
+      return methodFunction.bind(ctx);
+    }
+  };
+}
+
+exports.instrumentContext = instrumentContext;
+//# sourceMappingURL=instrumentContext.js.map