@sentry/core 10.51.0 → 10.53.0

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

@@ -0,0 +1,4 @@
+export { HttpInstrumentationOptions } from './types';
+export * from './client-patch';
+export * from './client-subscriptions';
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/http/inject-trace-propagation-headers.d.ts

@@ -0,0 +1,12 @@
+import { LRUMap } from '../../utils/lru';
+import { HttpClientRequest } from './types';
+/**
+ * Inject Sentry trace-propagation headers into an outgoing request if the
+ * target URL matches the configured `tracePropagationTargets`.
+ *
+ * Note: this must be called *before* calling `request.end()` (or firing the
+ * `http.client.request.start` diagnostics channel), because at that point,
+ * the headers have already been sent, and cannot be modified.
+ */
+export declare function injectTracePropagationHeaders(request: HttpClientRequest, propagationDecisionMap: LRUMap<string, boolean>): void;
+//# sourceMappingURL=inject-trace-propagation-headers.d.ts.map

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

@@ -0,0 +1,252 @@
+/**
+ * Platform-portable HTTP(S) outgoing-request integration – type definitions.
+ *
+ * @module
+ *
+ * This Sentry integration is a derivative work based on the OpenTelemetry
+ * HTTP instrumentation.
+ *
+ * <https://github.com/open-telemetry/opentelemetry-js/tree/main/experimental/packages/opentelemetry-instrumentation-http>
+ *
+ * Extended under the terms of the Apache 2.0 license linked below:
+ *
+ * ----
+ *
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { RequestEventData } from '../../types-hoist/request';
+import { Span } from '../../types-hoist/span';
+/** Minimal interface for a Node.js http.ClientRequest */
+export interface HttpClientRequest {
+    method?: string;
+    path?: string;
+    host?: string;
+    protocol?: string;
+    port?: number;
+    end(): void;
+    getHeader(name: string): string | string[] | number | undefined;
+    getHeaders(): Record<string, string | string[] | undefined | number>;
+    setHeader(name: string, value: string | string[] | number): void;
+    removeHeader(name: string): void;
+    prependListener(event: 'response', listener: (res: HttpIncomingMessage) => void): this;
+    prependListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    listenerCount(event: string | symbol): number;
+    removeListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+}
+/** Minimal interface for http client RequestOptions */
+export interface HttpRequestOptions {
+    method?: string;
+    protocol?: string | null;
+    hostname?: string | null;
+    host?: string | null;
+    port?: string | number | null;
+    path?: string | null;
+    headers?: Record<string, string | string[] | undefined | number>;
+}
+/** Minimal interface for a Node.js http.ServerResponse */
+export interface HttpServerResponse {
+    statusCode: number;
+    statusMessage?: string;
+    headers: Record<string, string | undefined | string[] | number>;
+    once(ev: string, ...data: unknown[]): this;
+    once(ev: 'close'): this;
+    on(ev: string | symbol, handler: (...data: unknown[]) => void): this;
+}
+export interface HttpServer {
+    emit(ev: string, ...data: unknown[]): this;
+    emit(ev: 'request', request: HttpIncomingMessage, response: HttpServerResponse): this;
+}
+export interface HttpSocket {
+    remoteAddress?: string;
+    remotePort?: number;
+    localAddress?: string;
+    localPort?: number;
+}
+/** Minimal interface for a Node.js http.IncomingMessage */
+export interface HttpIncomingMessage {
+    statusCode?: number;
+    statusMessage?: string;
+    httpVersion?: string;
+    url?: string;
+    method?: string;
+    headers: Record<string, string | string[] | undefined>;
+    socket?: HttpSocket;
+    aborted?: boolean;
+    complete?: boolean;
+    resume(): void;
+    on(event: 'end', listener: () => void): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    addListener(event: 'end', listener: () => void): this;
+    addListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    off(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    removeListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+}
+/** Minimal interface for a Node.js http / https module export */
+export interface HttpExport {
+    request: (...args: any[]) => HttpClientRequest;
+    get: (...args: any[]) => HttpClientRequest;
+    [key: string]: unknown;
+}
+export type HttpModuleExport = HttpExport | (HttpExport & {
+    default: HttpExport;
+});
+export interface HttpInstrumentationOptions {
+    /**
+     * Whether to create spans for outgoing HTTP requests.
+     * @default true
+     */
+    spans?: boolean;
+    /**
+     * Whether to inject distributed trace propagation headers
+     * (`sentry-trace`, `baggage`, `traceparent`) into outgoing requests.
+     * @default false
+     */
+    propagateTrace?: boolean;
+    /**
+     * Skip span / breadcrumb creation for requests to matching URLs.
+     * Receives the full URL string and the outgoing request object.
+     */
+    ignoreOutgoingRequests?: (url: string, request: HttpClientRequest) => boolean;
+    /**
+     * Whether breadcrumbs should be recorded for outgoing requests.
+     * @default true
+     */
+    breadcrumbs?: boolean;
+    /**
+     * Called after the outgoing-request span is created by the client.
+     * Use this to add custom attributes to the span.
+     */
+    outgoingRequestHook?: (span: Span, request: HttpClientRequest) => void;
+    /**
+     * Called when the response is received by the client.
+     */
+    outgoingResponseHook?: (span: Span, response: HttpIncomingMessage) => void;
+    /**
+     * Called when both the request and response are available (after the
+     * response ends).  Useful for adding attributes based on both objects.
+     */
+    applyCustomAttributesOnSpan?: (span: Span, request: HttpClientRequest, response: HttpIncomingMessage) => void;
+    /**
+     * Symbol to use for observing errors on EventEmitters without consuming
+     * them.  Pass `EventEmitter.errorMonitor` from Node.js `events` module.
+     * Falls back to the plain `'error'` event string when not provided.
+     *
+     * Using the real `errorMonitor` symbol ensures that Sentry does not
+     * swallow errors before they reach user-supplied `'error'` handlers.
+     */
+    errorMonitor?: symbol | string;
+    /**
+     * Controls the maximum size of incoming HTTP request bodies attached to events.
+     *
+     * 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
+     *
+     * Note that even with 'always' setting, bodies exceeding 1MB will never be attached
+     * for performance and security reasons.
+     *
+     * @default 'medium'
+     */
+    maxRequestBodySize?: 'none' | 'small' | 'medium' | 'always';
+    /**
+     * 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 and we want to avoid capturing it.
+     *
+     * @param url Contains the entire URL, including query string (if any), protocol, host, etc. of the incoming request.
+     * @param request Contains the {@type RequestOptions} object used to make the incoming request.
+     */
+    ignoreRequestBody?: (url: string, request: HttpIncomingMessage) => boolean;
+    /**
+     * Whether the integration should create [Sessions](https://docs.sentry.io/product/releases/health/#sessions) for incoming requests to track the health and crash-free rate of your releases in Sentry.
+     * Read more about Release Health: https://docs.sentry.io/product/releases/health/
+     *
+     * Defaults to `true`.
+     */
+    sessions?: boolean;
+    /**
+     * Number of milliseconds until sessions tracked with `trackIncomingRequestsAsSessions` will be flushed as a session aggregate.
+     *
+     * Defaults to `60000` (60s).
+     */
+    sessionFlushingDelayMS?: number;
+    /**
+     * Optional callback that can be used by integrations to emit the 'request'
+     * event within a given Sentry or OTEL context, possibly after creating a
+     * span, as in the HttpServerSpansIntegration.
+     */
+    wrapServerEmitRequest?: (request: HttpIncomingMessage, response: HttpServerResponse, normalizedRequest: RequestEventData, next: () => void) => void;
+    /**
+     * Do not capture spans for incoming HTTP requests to URLs where the given callback returns `true`.
+     * Spans will be non recording if tracing is disabled.
+     *
+     * The `urlPath` param consists of the URL path and query string (if any) of the incoming request.
+     * For example: `'/users/details?id=123'`
+     *
+     * The `request` param contains the original {@type IncomingMessage} object of the incoming request.
+     * You can use it to filter on additional properties like method, headers, etc.
+     */
+    ignoreIncomingRequests?: (urlPath: string, request: HttpIncomingMessage) => boolean;
+    /**
+     * Whether to automatically ignore common static asset requests like favicon.ico, robots.txt, etc.
+     * This helps reduce noise in your transactions.
+     *
+     * @default `true`
+     */
+    ignoreStaticAssets?: boolean;
+    /**
+     * Do not capture spans for incoming HTTP requests with the given status codes.
+     * By default, spans with some 3xx and 4xx status codes are ignored (see @default).
+     * Expects an array of status codes or a range of status codes, e.g. [[300,399], 404] would ignore 3xx and 404 status codes.
+     *
+     * @default `[[401, 404], [301, 303], [305, 399]]`
+     */
+    ignoreStatusCodes?: (number | [
+        number,
+        number
+    ])[];
+    /**
+     * A hook that can be used to mutate the span for incoming requests.
+     * This is triggered after the span is created, but before it is recorded.
+     */
+    onSpanCreated?: (span: Span, request: HttpIncomingMessage, response: HttpServerResponse) => void;
+    /**
+     * A hook that can be used to mutate the span one last time when the
+     * response is finished, eg to update the transaction name based on
+     * the RPC metadata.
+     */
+    onSpanEnd?: (span: Span, request: HttpIncomingMessage, response: HttpServerResponse) => void;
+    /**
+     * Optional: pass in the `http` and `https` modules in order to detect
+     * whether a standalone OTel instrumentation is attempting to wrap them
+     * as well. This is fine, as long as `spans` option is disabled, but will
+     * result in double-emitting spans otherwise.
+     *
+     * Since this cannot be fully prevented due to module load timing, and isn't
+     * necessarily harmful per se (just noisy/annoying), and there are a number
+     * of reasonable approaches to fix it (disable the OTel instrumentation,
+     * disable this instrumentation, or keep both and disable spans in one or the
+     * other), we simply print a warning so the user can hopefully make an
+     * informed decision about how to address it (if at all).
+     */
+    http?: HttpModuleExport;
+    https?: HttpModuleExport;
+    /** suppress the warning about double-wrapping with OTel */
+    suppressOtelWarning?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -2,6 +2,6 @@ interface LinkedErrorsOptions {
     key?: string;
     limit?: number;
 }
-export declare const linkedErrorsIntegration: (options?: LinkedErrorsOptions | undefined) => import("../types-hoist/integration").Integration;
+export declare const linkedErrorsIntegration: (options?: LinkedErrorsOptions | undefined) => import("..").Integration;
 export {};
 //# sourceMappingURL=linkederrors.d.ts.map

package/build/types-ts3.8/integrations/mcp-server/handlers.d.ts

@@ -30,4 +30,22 @@ export declare function wrapPromptHandlers(serverInstance: MCPServerInstance): v
  * @param serverInstance - MCP server instance
  */
 export declare function wrapAllMCPHandlers(serverInstance: MCPServerInstance): void;
+/**
+ * Retroactively wraps handlers on tools, resources, and prompts that were registered
+ * before `wrapMcpServerWithSentry` was called.
+ *
+ * The MCP SDK stores registered entries in private maps and invokes them via the entry's
+ * own property at call time — `executor` for tools, `readCallback` for resources, and
+ * `handler` for prompts. Replacing those properties
+ * in-place is therefore equivalent to having wrapped the original registration call.
+ *
+ * NOTE: This intentionally accesses private MCP SDK internals (`_registeredTools` etc.).
+ * The properties and their shapes are verified against @modelcontextprotocol/sdk source:
+ * https://github.com/modelcontextprotocol/typescript-sdk/blob/2c0c481cb9dbfd15c8613f765c940a5f5bace94d/packages/server/src/server/mcp.ts#L304
+ * When upgrading the MCP SDK, re-verify that these internal maps and their callable
+ * properties still exist and are invoked directly (not captured by closure at registration).
+ * All access is defensive — if a property is absent or not a function we skip silently.
+ * @internal
+ */
+export declare function wrapExistingHandlers(serverInstance: MCPServerInstance): void;
 //# sourceMappingURL=handlers.d.ts.map

package/build/types-ts3.8/integrations/mcp-server/index.d.ts

@@ -6,17 +6,24 @@ import { McpServerWrapperOptions } from './types';
  * and versions that expose the newer `registerTool`/`registerResource`/`registerPrompt` API (introduced in 1.x, sole API in 2.x).
  * Automatically instruments transport methods and handler functions for comprehensive monitoring.
  *
+ * Both call orderings are supported: wrapping before or after registering tools, resources,
+ * and prompts. Sentry patches the registration methods for future handlers and retroactively
+ * wraps any already-registered ones. Wrapping at construction time is recommended by
+ * convention (consistent with other SDK integrations), but is not required.
+ *
  * @example
  * ```typescript
  * import * as Sentry from '@sentry/core';
  * import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
  * import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
  *
- * // Default: inputs/outputs captured based on sendDefaultPii option
+ * // Wrap first, then register tools — this is the correct order
  * const server = Sentry.wrapMcpServerWithSentry(
  *   new McpServer({ name: "my-server", version: "1.0.0" })
  * );
  *
+ * server.registerTool('my-tool', schema, handler);
+ *
  * // Explicitly control input/output capture
  * const server = Sentry.wrapMcpServerWithSentry(
  *   new McpServer({ name: "my-server", version: "1.0.0" }),

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

@@ -16,6 +16,6 @@ type RequestDataIntegrationOptions = {
  * Add data about a request to an event. Primarily for use in Node-based SDKs, but included in `@sentry/core`
  * so it can be used in cross-platform SDKs like `@sentry/nextjs`.
  */
-export declare const requestDataIntegration: (options?: RequestDataIntegrationOptions | undefined) => import("../types-hoist/integration").Integration;
+export declare const requestDataIntegration: (options?: RequestDataIntegrationOptions | undefined) => import("..").Integration;
 export {};
 //# sourceMappingURL=requestdata.d.ts.map

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

@@ -1,2 +1,2 @@
-export declare const spanStreamingIntegration: () => import("../types-hoist/integration").Integration;
+export declare const spanStreamingIntegration: () => import("..").Integration;
 //# sourceMappingURL=spanStreaming.d.ts.map

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

@@ -95,6 +95,6 @@ export declare function translateFiltersIntoMethods(key: string, query: string):
 export declare const instrumentSupabaseClient: (supabaseClient: unknown) => void;
 export declare const supabaseIntegration: (options: {
     supabaseClient: any;
-}) => import("../types-hoist/integration").Integration;
+}) => import("..").Integration;
 export {};
 //# sourceMappingURL=supabase.d.ts.map

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

@@ -71,6 +71,6 @@ export declare function applyZodErrorsToEvent(limit: number, saveZodIssuesAsAtta
 /**
  * Sentry integration to process Zod errors, making them easier to work with in Sentry.
  */
-export declare const zodErrorsIntegration: (options?: ZodErrorsOptions | undefined) => import("../types-hoist/integration").Integration;
+export declare const zodErrorsIntegration: (options?: ZodErrorsOptions | undefined) => import("..").Integration;
 export {};
 //# sourceMappingURL=zoderrors.d.ts.map

package/build/types-ts3.8/logs/console-integration.d.ts

@@ -22,6 +22,6 @@ interface CaptureConsoleOptions {
  * });
  * ```
  */
-export declare const consoleLoggingIntegration: (options?: Partial<CaptureConsoleOptions> | undefined) => import("../types-hoist/integration").Integration;
+export declare const consoleLoggingIntegration: (options?: Partial<CaptureConsoleOptions> | undefined) => import("..").Integration;
 export {};
 //# sourceMappingURL=console-integration.d.ts.map

package/build/types-ts3.8/logs/envelope.d.ts

@@ -6,9 +6,11 @@ import { SdkMetadata } from '../types-hoist/sdkmetadata';
  * Creates a log container envelope item for a list of logs.
  *
  * @param items - The logs to include in the envelope.
+ * @param inferUserData - If true, tells Relay to infer the end-user IP and User-Agent from the incoming request.
+ *                        Only emitted as `ingest_settings` in browser environments.
  * @returns The created log container envelope item.
  */
-export declare function createLogContainerEnvelopeItem(items: Array<SerializedLog>): LogContainerItem;
+export declare function createLogContainerEnvelopeItem(items: Array<SerializedLog>, inferUserData?: boolean): LogContainerItem;
 /**
  * Creates an envelope for a list of logs.
  *
@@ -18,7 +20,8 @@ export declare function createLogContainerEnvelopeItem(items: Array<SerializedLo
  * @param metadata - The metadata to include in the envelope.
  * @param tunnel - The tunnel to include in the envelope.
  * @param dsn - The DSN to include in the envelope.
+ * @param inferUserData - If true, tells Relay to infer the end-user IP and User-Agent from the incoming request.
  * @returns The created envelope.
  */
-export declare function createLogEnvelope(logs: Array<SerializedLog>, metadata?: SdkMetadata, tunnel?: string, dsn?: DsnComponents): LogEnvelope;
+export declare function createLogEnvelope(logs: Array<SerializedLog>, metadata?: SdkMetadata, tunnel?: string, dsn?: DsnComponents, inferUserData?: boolean): LogEnvelope;
 //# sourceMappingURL=envelope.d.ts.map

package/build/types-ts3.8/metrics/envelope.d.ts

@@ -6,9 +6,11 @@ import { SdkMetadata } from '../types-hoist/sdkmetadata';
  * Creates a metric container envelope item for a list of metrics.
  *
  * @param items - The metrics to include in the envelope.
+ * @param inferUserData - If true, tells Relay to infer the end-user IP and User-Agent from the incoming request.
+ *                        Only emitted as `ingest_settings` in browser environments.
  * @returns The created metric container envelope item.
  */
-export declare function createMetricContainerEnvelopeItem(items: Array<SerializedMetric>): MetricContainerItem;
+export declare function createMetricContainerEnvelopeItem(items: Array<SerializedMetric>, inferUserData?: boolean): MetricContainerItem;
 /**
  * Creates an envelope for a list of metrics.
  *
@@ -18,7 +20,8 @@ export declare function createMetricContainerEnvelopeItem(items: Array<Serialize
  * @param metadata - The metadata to include in the envelope.
  * @param tunnel - The tunnel to include in the envelope.
  * @param dsn - The DSN to include in the envelope.
+ * @param inferUserData - If true, tells Relay to infer the end-user IP and User-Agent from the incoming request.
  * @returns The created envelope.
  */
-export declare function createMetricEnvelope(metrics: Array<SerializedMetric>, metadata?: SdkMetadata, tunnel?: string, dsn?: DsnComponents): MetricEnvelope;
+export declare function createMetricEnvelope(metrics: Array<SerializedMetric>, metadata?: SdkMetadata, tunnel?: string, dsn?: DsnComponents, inferUserData?: boolean): MetricEnvelope;
 //# sourceMappingURL=envelope.d.ts.map

package/build/types-ts3.8/server-exports.d.ts

@@ -0,0 +1,21 @@
+export { ServerRuntimeClientOptions } from './server-runtime-client';
+export { ServerRuntimeClient } from './server-runtime-client';
+export { ServerRuntimeOptions } from './types-hoist/options';
+export { trpcMiddleware } from './trpc';
+export { wrapMcpServerWithSentry } from './integrations/mcp-server';
+export { isNodeEnv, loadModule } from './utils/node';
+export { filenameIsInApp, node, nodeStackLineParser } from './utils/node-stack-trace';
+export { vercelWaitUntil } from './utils/vercelWaitUntil';
+export { flushIfServerless } from './utils/flushIfServerless';
+export { callFrameToStackFrame, watchdogTimer } from './utils/anr';
+export { safeUnref as _INTERNAL_safeUnref } from './utils/timer';
+export { patchExpressModule, setupExpressErrorHandler, expressErrorHandler } from './integrations/express/index';
+export { ExpressIntegrationOptions, ExpressHandlerOptions, ExpressMiddleware, ExpressErrorMiddleware, } from './integrations/express/types';
+export { instrumentPostgresJsSql } from './integrations/postgresjs';
+export { patchHttpModuleClient } from './integrations/http/client-patch';
+export { getHttpClientSubscriptions } from './integrations/http/client-subscriptions';
+export { addOutgoingRequestBreadcrumb } from './integrations/http/add-outgoing-request-breadcrumb';
+export { getRequestUrl, getRequestUrlObject, getRequestUrlFromClientRequest, getRequestOptions, } from './integrations/http/get-request-url';
+export { HTTP_ON_CLIENT_REQUEST, HTTP_ON_SERVER_REQUEST } from './integrations/http/constants';
+export { HttpInstrumentationOptions, HttpClientRequest, HttpIncomingMessage, HttpServerResponse, HttpModuleExport, } from './integrations/http/types';
+//# sourceMappingURL=server-exports.d.ts.map

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

@@ -0,0 +1,10 @@
+/**
+ * The Sentry core SDK and integrations used by node, node-core, cloudflare,
+ * bun, deno, aws lambda, and other server-side platforms, where bundle size
+ * is less of an issue.
+ *
+ * This export should not contain anything strictly browser-specific.
+ */
+export * from './shared-exports';
+export * from './server-exports';
+//# sourceMappingURL=server.d.ts.map