@sentry/core 10.47.0 → 10.49.0

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

@@ -31,6 +31,8 @@ export { prepareEvent } from './utils/prepareEvent';
 export { ExclusiveEventHintOrCaptureContext } from './utils/prepareEvent';
 export { createCheckInEnvelope } from './checkin';
 export { hasSpansEnabled } from './utils/hasSpansEnabled';
+export { withStreamedSpan } from './tracing/spans/beforeSendSpan';
+export { isStreamedBeforeSendSpanCallback } from './tracing/spans/beforeSendSpan';
 export { isSentryRequestUrl } from './utils/isSentryRequestUrl';
 export { handleCallbackErrors } from './utils/handleCallbackErrors';
 export { parameterize, fmt } from './utils/parameterize';
@@ -38,7 +40,7 @@ export { HandleTunnelRequestOptions } from './utils/tunnel';
 export { handleTunnelRequest } from './utils/tunnel';
 export { addAutoIpAddressToSession } from './utils/ipAddress';
 export { addAutoIpAddressToUser } from './utils/ipAddress';
-export { convertSpanLinksForEnvelope, spanToTraceHeader, spanToJSON, spanIsSampled, spanToTraceContext, getSpanDescendants, getStatusMessage, getRootSpan, getActiveSpan, addChildSpanToSpan, spanTimeInputToSeconds, updateSpanName, } from './utils/spanUtils';
+export { convertSpanLinksForEnvelope, spanToTraceHeader, spanToJSON, spanToStreamedSpanJSON, spanIsSampled, spanToTraceContext, getSpanDescendants, getStatusMessage, getRootSpan, INTERNAL_getSegmentSpan, getActiveSpan, addChildSpanToSpan, spanTimeInputToSeconds, updateSpanName, } from './utils/spanUtils';
 export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnScope';
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
@@ -46,6 +48,9 @@ export { getTraceData } from './utils/traceData';
 export { shouldPropagateTraceForUrl } from './utils/tracePropagationTargets';
 export { getTraceMetaTags } from './utils/meta';
 export { debounce } from './utils/debounce';
+export { makeWeakRef, derefWeakRef } from './utils/weakRef';
+export { MaybeWeakRef } from './utils/weakRef';
+export { shouldIgnoreSpan } from './utils/should-ignore-span';
 export { winterCGHeadersToDict, winterCGRequestToRequestData, httpRequestToRequestData, extractQueryParamsFromUrl, headersToDict, httpHeadersToSpanAttributes, } from './utils/request';
 export { DEFAULT_ENVIRONMENT, DEV_ENVIRONMENT } from './constants';
 export { addBreadcrumb } from './breadcrumbs';
@@ -56,6 +61,8 @@ export { linkedErrorsIntegration } from './integrations/linkederrors';
 export { moduleMetadataIntegration } from './integrations/moduleMetadata';
 export { requestDataIntegration } from './integrations/requestdata';
 export { captureConsoleIntegration } from './integrations/captureconsole';
+export { patchExpressModule, setupExpressErrorHandler, expressErrorHandler } from './integrations/express/index';
+export { ExpressIntegrationOptions, ExpressHandlerOptions, ExpressMiddleware, ExpressErrorMiddleware, } from './integrations/express/types';
 export { dedupeIntegration } from './integrations/dedupe';
 export { extraErrorDataIntegration } from './integrations/extraerrordata';
 export { rewriteFramesIntegration } from './integrations/rewriteframes';
@@ -68,7 +75,7 @@ export { featureFlagsIntegration, FeatureFlagsIntegration } from './integrations
 export { growthbookIntegration } from './integrations/featureFlags';
 export { conversationIdIntegration } from './integrations/conversationId';
 export { profiler } from './profiling';
-export { instrumentFetchRequest } from './fetch';
+export { instrumentFetchRequest, _INTERNAL_getTracingHeadersForFetchRequest } from './fetch';
 export { trpcMiddleware } from './trpc';
 export { wrapMcpServerWithSentry } from './integrations/mcp-server';
 export { captureFeedback } from './feedback';
@@ -92,7 +99,7 @@ export { ANTHROPIC_AI_INTEGRATION_NAME } from './tracing/anthropic-ai/constants'
 export { instrumentGoogleGenAIClient } from './tracing/google-genai';
 export { GOOGLE_GENAI_INTEGRATION_NAME } from './tracing/google-genai/constants';
 export { GoogleGenAIResponse } from './tracing/google-genai/types';
-export { createLangChainCallbackHandler } from './tracing/langchain';
+export { createLangChainCallbackHandler, instrumentLangChainEmbeddings } from './tracing/langchain';
 export { LANGCHAIN_INTEGRATION_NAME } from './tracing/langchain/constants';
 export { LangChainOptions, LangChainIntegration } from './tracing/langchain/types';
 export { instrumentStateGraphCompile, instrumentLangGraph } from './tracing/langgraph';
@@ -101,6 +108,9 @@ export { LangGraphOptions, LangGraphIntegration, CompiledGraph } from './tracing
 export { OpenAiClient, OpenAiOptions, InstrumentedMethod } from './tracing/openai/types';
 export { AnthropicAiClient, AnthropicAiOptions, AnthropicAiInstrumentedMethod, AnthropicAiResponse, } from './tracing/anthropic-ai/types';
 export { GoogleGenAIClient, GoogleGenAIChat, GoogleGenAIOptions, GoogleGenAIIstrumentedMethod, } from './tracing/google-genai/types';
+export { SpanBuffer } from './tracing/spans/spanBuffer';
+export { hasSpanStreamingEnabled } from './tracing/spans/hasSpanStreamingEnabled';
+export { spanStreamingIntegration } from './integrations/spanStreaming';
 export { FeatureFlag } from './utils/featureFlags';
 export { _INTERNAL_copyFlagsFromScopeToEvent, _INTERNAL_insertFlagToScope, _INTERNAL_addFeatureFlagToActiveSpan, _INTERNAL_FLAG_BUFFER_SIZE, _INTERNAL_MAX_FLAGS_PER_SPAN, } from './utils/featureFlags';
 export { applyAggregateErrorsToEvent } from './utils/aggregate-errors';
@@ -160,7 +170,7 @@ export { Context, Contexts, DeviceContext, OsContext, AppContext, CultureContext
 export { DataCategory } from './types-hoist/datacategory';
 export { DsnComponents, DsnLike, DsnProtocol } from './types-hoist/dsn';
 export { DebugImage, DebugMeta } from './types-hoist/debugMeta';
-export { AttachmentItem, BaseEnvelopeHeaders, BaseEnvelopeItemHeaders, ClientReportEnvelope, ClientReportItem, DynamicSamplingContext, Envelope, EnvelopeItemType, EnvelopeItem, EventEnvelope, EventEnvelopeHeaders, EventItem, ReplayEnvelope, FeedbackItem, SessionEnvelope, SessionItem, UserFeedbackItem, CheckInItem, CheckInEnvelope, RawSecurityEnvelope, RawSecurityItem, ProfileItem, ProfileChunkEnvelope, ProfileChunkItem, SpanEnvelope, SpanItem, LogEnvelope, MetricEnvelope, } from './types-hoist/envelope';
+export { AttachmentItem, BaseEnvelopeHeaders, BaseEnvelopeItemHeaders, ClientReportEnvelope, ClientReportItem, DynamicSamplingContext, Envelope, EnvelopeItemType, EnvelopeItem, EventEnvelope, EventEnvelopeHeaders, EventItem, ReplayEnvelope, FeedbackItem, SessionEnvelope, SessionItem, UserFeedbackItem, CheckInItem, CheckInEnvelope, RawSecurityEnvelope, RawSecurityItem, ProfileItem, ProfileChunkEnvelope, ProfileChunkItem, SpanEnvelope, StreamedSpanEnvelope, SpanItem, LogEnvelope, MetricEnvelope, } from './types-hoist/envelope';
 export { ExtendedError } from './types-hoist/error';
 export { Event, EventHint, EventType, ErrorEvent, TransactionEvent } from './types-hoist/event';
 export { EventProcessor } from './types-hoist/eventprocessor';
@@ -181,9 +191,10 @@ export { SdkInfo } from './types-hoist/sdkinfo';
 export { SdkMetadata } from './types-hoist/sdkmetadata';
 export { SessionAggregates, AggregationCounts, Session, SessionContext, SessionStatus, SerializedSession, } from './types-hoist/session';
 export { SeverityLevel } from './types-hoist/severity';
-export { Span, SentrySpanArguments, SpanOrigin, SpanAttributeValue, SpanAttributes, SpanTimeInput, SpanJSON, SpanContextData, TraceFlag, } from './types-hoist/span';
+export { Span, SentrySpanArguments, SpanOrigin, SpanAttributeValue, SpanAttributes, SpanTimeInput, SpanJSON, SpanContextData, TraceFlag, SerializedStreamedSpan, SerializedStreamedSpanContainer, StreamedSpanJSON, } from './types-hoist/span';
 export { SpanStatus } from './types-hoist/spanStatus';
 export { Log, LogSeverityLevel } from './types-hoist/log';
+export { SpanLink } from './types-hoist/link';
 export { Metric, MetricType, SerializedMetric, SerializedMetricContainer, SerializedMetricAttributeValue, } from './types-hoist/metric';
 export { TimedEvent } from './types-hoist/timedEvent';
 export { StackFrame } from './types-hoist/stackframe';

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

@@ -0,0 +1,82 @@
+/**
+ * Platform-portable Express tracing integration.
+ *
+ * @module
+ *
+ * This Sentry integration is a derivative work based on the OpenTelemetry
+ * Express instrumentation.
+ *
+ * <https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/packages/instrumentation-express>
+ *
+ * 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 { ExpressErrorMiddleware, ExpressHandlerOptions, ExpressIntegrationOptions, ExpressModuleExport } from './types';
+/**
+ * This is a portable instrumentatiton function that works in any environment
+ * where Express can be loaded, without depending on OpenTelemetry.
+ *
+ * @example
+ * ```javascript
+ * import express from 'express';
+ * import * as Sentry from '@sentry/deno'; // or any SDK that extends core
+ *
+ * Sentry.patchExpressModule(express, () => ({}));
+ * ```
+ */
+export declare function patchExpressModule(moduleExports: ExpressModuleExport, getOptions: () => ExpressIntegrationOptions): ExpressModuleExport;
+/**
+ * @deprecated Pass the Express module export as the first argument and options getter as the second argument.
+ */
+export declare function patchExpressModule(options: ExpressIntegrationOptions & {
+    express: ExpressModuleExport;
+}): ExpressModuleExport;
+/**
+ * An Express-compatible error handler, used by setupExpressErrorHandler
+ */
+export declare function expressErrorHandler(options?: ExpressHandlerOptions): ExpressErrorMiddleware;
+/**
+ * Add an Express error handler to capture errors to Sentry.
+ *
+ * The error handler must be before any other middleware and after all controllers.
+ *
+ * @param app The Express instances
+ * @param options {ExpressHandlerOptions} Configuration options for the handler
+ *
+ * @example
+ * ```javascript
+ * import * as Sentry from 'sentry/deno'; // or any other @sentry/<platform>
+ * import * as express from 'express';
+ *
+ * Sentry.instrumentExpress(express);
+ *
+ * const app = express();
+ *
+ * // Add your routes, etc.
+ *
+ * // Add this after all routes,
+ * // but before any and other error-handling middlewares are defined
+ * Sentry.setupExpressErrorHandler(app);
+ *
+ * app.listen(3000);
+ * ```
+ */
+export declare function setupExpressErrorHandler(app: {
+    use: (middleware: any) => unknown;
+}, options?: ExpressHandlerOptions): void;
+//# sourceMappingURL=index.d.ts.map

package/build/types-ts3.8/integrations/express/patch-layer.d.ts

@@ -0,0 +1,32 @@
+/*
+* Platform-portable Express tracing integration.
+*
+* @module
+*
+* This Sentry integration is a derivative work based on the OpenTelemetry
+* Express instrumentation.
+*
+* <https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/packages/instrumentation-express>
+*
+* 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 { ExpressIntegrationOptions, ExpressLayer } from './types';
+export type ExpressPatchLayerOptions = Pick<ExpressIntegrationOptions, 'onRouteResolved' | 'ignoreLayers' | 'ignoreLayersType'>;
+export declare function patchLayer(getOptions: () => ExpressPatchLayerOptions, maybeLayer?: ExpressLayer, layerPath?: string): void;
+//# sourceMappingURL=patch-layer.d.ts.map

package/build/types-ts3.8/integrations/express/request-layer-store.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Platform-portable Express tracing integration.
+ *
+ * @module
+ *
+ * This Sentry integration is a derivative work based on the OpenTelemetry
+ * Express instrumentation.
+ *
+ * <https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/packages/instrumentation-express>
+ *
+ * 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 { ExpressRequest } from './types';
+export declare const storeLayer: (req: ExpressRequest, layer: string) => void;
+export declare const getStoredLayers: (req: ExpressRequest) => string[];
+//# sourceMappingURL=request-layer-store.d.ts.map

package/build/types-ts3.8/integrations/express/set-sdk-processing-metadata.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Platform-portable Express tracing integration.
+ *
+ * @module
+ *
+ * This Sentry integration is a derivative work based on the OpenTelemetry
+ * Express instrumentation.
+ *
+ * <https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/packages/instrumentation-express>
+ *
+ * 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.
+ */
+/**
+ * Abstract this out because we call it in multiple places, and it's cheaper to
+ * only do one time for any given request.
+ */
+import { ExpressRequest } from './types';
+export declare function setSDKProcessingMetadata(request: ExpressRequest): void;
+//# sourceMappingURL=set-sdk-processing-metadata.d.ts.map

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

@@ -0,0 +1,158 @@
+/**
+ * Platform-portable Express tracing integration.
+ *
+ * @module
+ *
+ * This Sentry integration is a derivative work based on the OpenTelemetry
+ * Express instrumentation.
+ *
+ * <https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/packages/instrumentation-express>
+ *
+ * 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 { SpanAttributes } from '../../types-hoist/span';
+export declare const ATTR_EXPRESS_NAME = "express.name";
+export declare const ATTR_HTTP_ROUTE = "http.route";
+export declare const ATTR_EXPRESS_TYPE = "express.type";
+export type ExpressExport = {
+    Router: ExpressRouterv5 | ExpressRouterv4;
+    application: ExpressApplication;
+};
+export type ExpressExportv5 = ExpressExport & {
+    Router: ExpressRouterv5;
+};
+export type ExpressExportv4 = ExpressExport & {
+    Router: ExpressRouterv4;
+};
+export type ExpressModuleExport = ExpressExport | {
+    default: ExpressExport;
+};
+export interface ExpressRequest extends RequestEventData {
+    originalUrl: string;
+    route: unknown;
+    res?: ExpressResponse;
+}
+export interface ExpressResponse {
+    once(ev: string, listener: Function): this;
+    removeListener(ev: string, listener?: Function): this;
+    emit(ev: string, ...data: unknown[]): this;
+}
+export interface NextFunction {
+    (err?: unknown): void;
+    /**
+     * "Break-out" of a router by calling {next('router')};
+     * @see {https://expressjs.com/en/guide/using-middleware.html#middleware.router}
+     */
+    (deferToNext: 'router'): void;
+    /**
+     * "Break-out" of a route by calling {next('route')};
+     * @see {https://expressjs.com/en/guide/using-middleware.html#middleware.application}
+     */
+    (deferToNext: 'route'): void;
+}
+export type ExpressApplicationRequestHandler = (...handlers: any[]) => any;
+export type ExpressRequestInfo<T = unknown> = {
+    /** An express request object */
+    request: T;
+    route: string;
+    layerType: ExpressLayerType;
+};
+export type ExpressLayerType = 'router' | 'middleware' | 'request_handler';
+export declare const ExpressLayerType_ROUTER = "router";
+export declare const ExpressLayerType_MIDDLEWARE = "middleware";
+export declare const ExpressLayerType_REQUEST_HANDLER = "request_handler";
+export type PathParams = string | RegExp | Array<string | RegExp>;
+export type LayerPathSegment = string | RegExp | number;
+export interface ExpressRoute {
+    path: string;
+    stack: ExpressLayer[];
+}
+export type ExpressRouterv4 = ExpressRouter;
+export interface ExpressRouterv5 {
+    prototype: ExpressRouter;
+}
+export type ExpressLayer = {
+    handle: Function & Record<string, unknown> & {
+        stack?: ExpressLayer[];
+    };
+    name: string;
+    params: {
+        [key: string]: string;
+    };
+    path?: string;
+    regexp: RegExp;
+    route?: ExpressLayer;
+};
+export type ExpressRouter = {
+    params: {
+        [key: string]: string;
+    };
+    _params: string[];
+    caseSensitive: boolean;
+    mergeParams: boolean;
+    strict: boolean;
+    stack: ExpressLayer[];
+    route(prefix: PathParams): ExpressRoute;
+    use(...handlers: unknown[]): unknown;
+};
+export type IgnoreMatcher = string | RegExp | ((name: string) => boolean);
+export type ExpressIntegrationOptions = {
+    /**
+     * @deprecated Pass the express module as the first argument, and an
+     * options getter as the second argument to patchExpressModule.
+     */
+    express?: ExpressModuleExport;
+    /** Ignore specific based on their name */
+    ignoreLayers?: IgnoreMatcher[];
+    /** Ignore specific layers based on their type */
+    ignoreLayersType?: ExpressLayerType[];
+    /**
+     * Optional callback invoked each time a layer resolves the matched HTTP route.
+     * Platform-specific integrations (e.g. Node.js) use this to propagate the
+     * resolved route to the underlying transport layer (e.g. OTel RPCMetadata).
+     */
+    onRouteResolved?: (route: string | undefined) => void;
+};
+export type LayerMetadata = {
+    attributes: SpanAttributes;
+    name: string;
+};
+export interface ExpressApplication {
+    stack: ExpressLayer[];
+    use: ExpressApplicationRequestHandler;
+}
+export interface MiddlewareError extends Error {
+    status?: number | string;
+    statusCode?: number | string;
+    status_code?: number | string;
+    output?: {
+        statusCode?: number | string;
+    };
+}
+export type ExpressMiddleware = (req: ExpressRequest, res: ExpressResponse, next: () => void) => void;
+export type ExpressErrorMiddleware = (error: MiddlewareError, req: ExpressRequest, res: ExpressResponse, next: (error: MiddlewareError) => void) => void;
+export interface ExpressHandlerOptions {
+    /**
+     * Callback method deciding whether error should be captured and sent to Sentry
+     * @param error Captured middleware error
+     */
+    shouldHandleError?(this: void, error: MiddlewareError): boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types-ts3.8/integrations/express/utils.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Platform-portable Express tracing integration.
+ *
+ * @module
+ *
+ * This Sentry integration is a derivative work based on the OpenTelemetry
+ * Express instrumentation.
+ *
+ * <https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/packages/instrumentation-express>
+ *
+ * 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 { SpanAttributes } from '../../types-hoist/span';
+import { ExpressExport, ExpressIntegrationOptions, ExpressLayer, ExpressLayerType, ExpressRequest, MiddlewareError, ExpressExportv5, ExpressExportv4 } from './types';
+import { ATTR_EXPRESS_NAME, ATTR_EXPRESS_TYPE } from './types';
+/**
+ * Converts a user-provided error value into an error and error message pair
+ *
+ * @param error - User-provided error value
+ * @returns Both an Error or string representation of the value and an error message
+ */
+export declare const asErrorAndMessage: (error: unknown) => [
+    string | Error,
+    string
+];
+/**
+ * Checks if a route contains parameter patterns (e.g., :id, :userId)
+ * which are valid even if they don't exactly match the original URL
+ */
+export declare function isRoutePattern(route: string): boolean;
+/**
+ * Parse express layer context to retrieve a name and attributes.
+ * @param route The route of the layer
+ * @param layer Express layer
+ * @param [layerPath] if present, the path on which the layer has been mounted
+ */
+export declare const getLayerMetadata: (route: string, layer: ExpressLayer, layerPath?: string) => {
+    attributes: SpanAttributes & {
+        [ATTR_EXPRESS_NAME]: string;
+        [ATTR_EXPRESS_TYPE]: ExpressLayerType;
+    };
+    name: string;
+};
+/**
+ * Recursively search the router path from layer stack
+ * @param path The path to reconstruct
+ * @param layer The layer to reconstruct from
+ * @returns The reconstructed path
+ */
+export declare const getRouterPath: (path: string, layer: ExpressLayer) => string;
+/**
+ * Check whether the given request is ignored by configuration
+ * It will not re-throw exceptions from `list` provided by the client
+ * @param constant e.g URL of request
+ * @param [list] List of ignore patterns
+ * @param [onException] callback for doing something when an exception has
+ *     occurred
+ */
+export type ExpressIsLayerIgnoredOptions = Pick<ExpressIntegrationOptions, 'ignoreLayersType' | 'ignoreLayers'>;
+export declare const isLayerIgnored: (name: string, type: ExpressLayerType, config?: ExpressIsLayerIgnoredOptions) => boolean;
+/**
+ * Extracts the actual matched route from Express request for OpenTelemetry instrumentation.
+ * Returns the route that should be used as the http.route attribute.
+ *
+ * @param req - The Express request object with layers store
+ * @param constructedRoute - The constructed route from `getConstructedRoute`
+ * @returns The matched route string or undefined if no valid route is found
+ */
+export declare function getActualMatchedRoute(req: ExpressRequest, constructedRoute: string): string | undefined;
+export declare function getConstructedRoute(req: ExpressRequest): string;
+export declare const getLayerPath: (args: unknown[]) => string | undefined;
+export declare const isExpressWithRouterPrototype: (express: unknown) => express is ExpressExportv5;
+export declare const isExpressWithoutRouterPrototype: (express: unknown) => express is ExpressExportv4;
+export declare const hasDefaultProp: (express: unknown) => express is {
+    [k: string]: unknown;
+    default: ExpressExport;
+};
+/** Returns true if response code is internal server error */
+export declare function defaultShouldHandleError(error: MiddlewareError): boolean;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -25,8 +25,9 @@ export declare function storeSpanForRequest(transport: MCPTransport, requestId:
  * @param requestId - Request identifier
  * @param result - Execution result for attribute extraction
  * @param options - Resolved MCP options
+ * @param hasError - Whether the JSON-RPC response contained an error
  */
-export declare function completeSpanWithResults(transport: MCPTransport, requestId: RequestId, result: unknown, options: ResolvedMcpOptions): void;
+export declare function completeSpanWithResults(transport: MCPTransport, requestId: RequestId, result: unknown, options: ResolvedMcpOptions, hasError?: boolean): void;
 /**
  * Cleans up pending spans for a specific transport (when that transport closes)
  * @param transport - MCP transport instance

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

@@ -6,22 +6,27 @@
  */
 import { MCPServerInstance } from './types';
 /**
- * Wraps tool handlers to associate them with request spans
+ * Wraps tool handlers to associate them with request spans.
+ * Instruments both `tool` (legacy API) and `registerTool` (new API) if present.
  * @param serverInstance - MCP server instance
  */
 export declare function wrapToolHandlers(serverInstance: MCPServerInstance): void;
 /**
- * Wraps resource handlers to associate them with request spans
+ * Wraps resource handlers to associate them with request spans.
+ * Instruments both `resource` (legacy API) and `registerResource` (new API) if present.
  * @param serverInstance - MCP server instance
  */
 export declare function wrapResourceHandlers(serverInstance: MCPServerInstance): void;
 /**
- * Wraps prompt handlers to associate them with request spans
+ * Wraps prompt handlers to associate them with request spans.
+ * Instruments both `prompt` (legacy API) and `registerPrompt` (new API) if present.
  * @param serverInstance - MCP server instance
  */
 export declare function wrapPromptHandlers(serverInstance: MCPServerInstance): void;
 /**
- * Wraps all MCP handler types (tool, resource, prompt) for span correlation
+ * Wraps all MCP handler types for span correlation.
+ * Supports both the legacy API (`tool`, `resource`, `prompt`) and the newer API
+ * (`registerTool`, `registerResource`, `registerPrompt`), instrumenting whichever methods are present.
  * @param serverInstance - MCP server instance
  */
 export declare function wrapAllMCPHandlers(serverInstance: MCPServerInstance): void;

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

@@ -2,7 +2,8 @@ import { McpServerWrapperOptions } from './types';
 /**
  * Wraps a MCP Server instance from the `@modelcontextprotocol/sdk` package with Sentry instrumentation.
  *
- * Compatible with versions `^1.9.0` of the `@modelcontextprotocol/sdk` package.
+ * Compatible with versions `^1.9.0` of the `@modelcontextprotocol/sdk` package (legacy `tool`/`resource`/`prompt` API)
+ * 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.
  *
  * @example

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

@@ -74,15 +74,48 @@ export interface MCPTransport {
 export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcResponse;
 /**
  * MCP server instance interface
- * @description MCP server methods for registering handlers
+ * @description MCP server methods for registering handlers.
+ * Supports both the legacy API (`tool`, `resource`, `prompt`) used in SDK 1.x
+ * and the newer API (`registerTool`, `registerResource`, `registerPrompt`) introduced in SDK 1.x
+ * and made the only option in SDK 2.x.
  */
 export interface MCPServerInstance {
-    /** Register a resource handler */
-    resource: (name: string, ...args: unknown[]) => void;
-    /** Register a tool handler */
-    tool: (name: string, ...args: unknown[]) => void;
-    /** Register a prompt handler */
-    prompt: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a resource handler.
+     * Supported in `@modelcontextprotocol/sdk` v1.x alongside `registerResource`.
+     * @deprecated Removed in `@modelcontextprotocol/sdk` v2.0.0 — use `registerResource` instead.
+     */
+    resource?: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a tool handler.
+     * Supported in `@modelcontextprotocol/sdk` v1.x alongside `registerTool`.
+     * @deprecated Removed in `@modelcontextprotocol/sdk` v2.0.0 — use `registerTool` instead.
+     */
+    tool?: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a prompt handler.
+     * Supported in `@modelcontextprotocol/sdk` v1.x alongside `registerPrompt`.
+     * @deprecated Removed in `@modelcontextprotocol/sdk` v2.0.0 — use `registerPrompt` instead.
+     */
+    prompt?: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a resource handler.
+     * Available in `@modelcontextprotocol/sdk` v1.x (alongside the legacy `resource` method)
+     * and the only supported form in v2.0.0+.
+     */
+    registerResource?: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a tool handler.
+     * Available in `@modelcontextprotocol/sdk` v1.x (alongside the legacy `tool` method)
+     * and the only supported form in v2.0.0+.
+     */
+    registerTool?: (name: string, ...args: unknown[]) => void;
+    /**
+     * Register a prompt handler.
+     * Available in `@modelcontextprotocol/sdk` v1.x (alongside the legacy `prompt` method)
+     * and the only supported form in v2.0.0+.
+     */
+    registerPrompt?: (name: string, ...args: unknown[]) => void;
     /** Connect the server to a transport */
     connect(transport: MCPTransport): Promise<void>;
 }

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

@@ -23,7 +23,10 @@ export declare function isJsonRpcNotification(message: unknown): message is Json
  */
 export declare function isJsonRpcResponse(message: unknown): message is JsonRpcResponse;
 /**
- * Validates MCP server instance with type checking
+ * Validates MCP server instance with type checking.
+ * Accepts both the legacy API (`tool`, `resource`, `prompt`) used in SDK 1.x
+ * and the newer API (`registerTool`, `registerResource`, `registerPrompt`) introduced
+ * alongside the legacy API in SDK 1.x and made the only option in SDK 2.x.
  * @param instance - Object to validate as MCP server instance
  * @returns True if instance has required MCP server methods
  */

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

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