@sentry/core 10.47.0 → 10.48.0

package/build/types/utils/stacktrace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stacktrace.d.ts","sourceRoot":"","sources":["../../../src/utils/stacktrace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC9E,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAG9D,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAKpC;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,OAAO,EAAE,eAAe,EAAE,GAAG,WAAW,CA2C5E;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,WAAW,EAAE,WAAW,GAAG,eAAe,EAAE,GAAG,WAAW,CAK3G;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,UAAU,EAAE,CAqC1F;AAQD;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,CAWnD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,EAAE,GAAG,SAAS,CAoBzE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,GAAG,MAAM,CAKtE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAOpF"}
+{"version":3,"file":"stacktrace.d.ts","sourceRoot":"","sources":["../../../src/utils/stacktrace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC9E,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAG9D,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAKpC;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,OAAO,EAAE,eAAe,EAAE,GAAG,WAAW,CA6C5E;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,WAAW,EAAE,WAAW,GAAG,eAAe,EAAE,GAAG,WAAW,CAK3G;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,aAAa,CAAC,UAAU,CAAC,GAAG,UAAU,EAAE,CAqC1F;AAQD;;GAEG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,GAAG,MAAM,CAWnD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,EAAE,GAAG,SAAS,CAoBzE;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,GAAG,MAAM,CAKtE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAOpF"}

package/build/types/utils/string.d.ts

@@ -31,7 +31,7 @@ export declare function safeJoin(input: unknown[], delimiter?: string): string;
  * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match
  * `pattern` if it contains `pattern`. Only applies to string-type patterns.
  */
-export declare function isMatchingPattern(value: string, pattern: RegExp | string, requireExactStringMatch?: boolean): boolean;
+export declare function isMatchingPattern(value: string, pattern: RegExp | string | ((value: string) => boolean), requireExactStringMatch?: boolean): boolean;
 /**
  * Test the given string against an array of strings and regexes. By default, string matching is done on a
  * substring-inclusion basis rather than a strict equality basis
@@ -42,5 +42,5 @@ export declare function isMatchingPattern(value: string, pattern: RegExp | strin
  * count. If false, `testString` will match a string pattern if it contains that pattern.
  * @returns
  */
-export declare function stringMatchesSomePattern(testString: string, patterns?: Array<string | RegExp>, requireExactStringMatch?: boolean): boolean;
+export declare function stringMatchesSomePattern(testString: string, patterns?: Array<string | RegExp | ((value: string) => boolean)>, requireExactStringMatch?: boolean): boolean;
 //# sourceMappingURL=string.d.ts.map

package/build/types/utils/string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src/utils/string.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAEtE;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,GAAE,MAAU,GAAG,MAAM,CAK7D;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAiC5D;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CA0BrE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,uBAAuB,GAAE,OAAe,GACvC,OAAO,CAaT;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAM,EACrC,uBAAuB,GAAE,OAAe,GACvC,OAAO,CAET"}
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../src/utils/string.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAEtE;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,GAAE,MAAU,GAAG,MAAM,CAK7D;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAiC5D;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CA0BrE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,EACvD,uBAAuB,GAAE,OAAe,GACvC,OAAO,CAgBT;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,KAAK,CAAC,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAM,EACpE,uBAAuB,GAAE,OAAe,GACvC,OAAO,CAET"}

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

@@ -66,5 +66,10 @@ export declare function attributeValueToTypedAttributeValue(rawValue: unknown, u
  * @returns The serialized attributes.
  */
 export declare function serializeAttributes<T>(attributes: RawAttributes<T> | undefined, fallback?: boolean | 'skip-undefined'): Attributes;
+/**
+ * Estimates the serialized byte size of {@link Attributes},
+ * with a couple of heuristics for performance.
+ */
+export declare function estimateTypedAttributesSizeInBytes(attributes: Attributes | undefined): number;
 export {};
 //# sourceMappingURL=attributes.d.ts.map

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

@@ -18,7 +18,7 @@ import { RequestEventData } from './types-hoist/request';
 import { SdkMetadata } from './types-hoist/sdkmetadata';
 import { Session, SessionAggregates } from './types-hoist/session';
 import { SeverityLevel } from './types-hoist/severity';
-import { Span, SpanAttributes, SpanContextData } from './types-hoist/span';
+import { Span, SpanAttributes, SpanContextData, StreamedSpanJSON } from './types-hoist/span';
 import { StartSpanOptions } from './types-hoist/startSpanOptions';
 import { Transport, TransportMakeRequestResponse } from './types-hoist/transport';
 import { PromiseBuffer } from './utils/promisebuffer';
@@ -210,6 +210,24 @@ export declare abstract class Client<O extends ClientOptions = ClientOptions> {
      * @returns {() => void} A function that, when executed, removes the registered callback.
      */
     on(hook: 'spanEnd', callback: (span: Span) => void): () => void;
+    /**
+     * Register a callback for after a span is ended and the `spanEnd` hook has run.
+     * NOTE: The span cannot be mutated anymore in this callback.
+     */
+    on(hook: 'afterSpanEnd', callback: (immutableSegmentSpan: Readonly<Span>) => void): () => void;
+    /**
+     * Register a callback for after a segment span is ended and the `segmentSpanEnd` hook has run.
+     * NOTE: The segment span cannot be mutated anymore in this callback.
+     */
+    on(hook: 'afterSegmentSpanEnd', callback: (immutableSegmentSpan: Readonly<Span>) => void): () => void;
+    /**
+     * Register a callback for when a span JSON is processed, to add some data to the span JSON.
+     */
+    on(hook: 'processSpan', callback: (streamedSpanJSON: StreamedSpanJSON) => void): () => void;
+    /**
+     * Register a callback for when a segment span JSON is processed, to add some data to the segment span JSON.
+     */
+    on(hook: 'processSegmentSpan', callback: (streamedSpanJSON: StreamedSpanJSON) => void): () => void;
     /**
      * Register a callback for when an idle span is allowed to auto-finish.
      * @returns {() => void} A function that, when executed, removes the registered callback.
@@ -405,6 +423,22 @@ export declare abstract class Client<O extends ClientOptions = ClientOptions> {
     }): void;
     /** Fire a hook whenever a span ends. */
     emit(hook: 'spanEnd', span: Span): void;
+    /**
+     * Fire a hook event after a span ends and the `spanEnd` hook has run.
+     */
+    emit(hook: 'afterSpanEnd', immutableSpan: Readonly<Span>): void;
+    /**
+     * Fire a hook event after a segment span ends and the `spanEnd` hook has run.
+     */
+    emit(hook: 'afterSegmentSpanEnd', immutableSegmentSpan: Readonly<Span>): void;
+    /**
+     * Fire a hook event when a span JSON is processed, to add some data to the span JSON.
+     */
+    emit(hook: 'processSpan', streamedSpanJSON: StreamedSpanJSON): void;
+    /**
+     * Fire a hook event for when a segment span JSON is processed, to add some data to the segment span JSON.
+     */
+    emit(hook: 'processSegmentSpan', streamedSpanJSON: StreamedSpanJSON): void;
     /**
      * Fire a hook indicating that an idle span is allowed to auto finish.
      */

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,7 @@ export { getTraceData } from './utils/traceData';
 export { shouldPropagateTraceForUrl } from './utils/tracePropagationTargets';
 export { getTraceMetaTags } from './utils/meta';
 export { debounce } from './utils/debounce';
+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 +59,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';
@@ -92,7 +97,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 +106,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 +168,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,7 +189,7 @@ 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 { Metric, MetricType, SerializedMetric, SerializedMetricContainer, SerializedMetricAttributeValue, } from './types-hoist/metric';

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

@@ -0,0 +1,75 @@
+/**
+ * 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, ExpressExport, ExpressHandlerOptions, ExpressIntegrationOptions } 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 const patchExpressModule: (options: ExpressIntegrationOptions) => ExpressExport;
+/**
+ * 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(options: 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,154 @@
+/**
+ * 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 = {
+    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