@sentry/core 10.46.0 → 10.48.0

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

@@ -1,6 +1,7 @@
 import { ReportDialogOptions } from './report-dialog';
 import { DsnComponents, DsnLike } from './types-hoist/dsn';
 import { SdkInfo } from './types-hoist/sdkinfo';
+export declare const SENTRY_API_VERSION = "7";
 /**
  * Returns the envelope endpoint URL with auth in the query string.
  *

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

@@ -1,6 +1,6 @@
 import { Scope } from '../scope';
 import { getTraceData } from '../utils/traceData';
-import { continueTrace, startInactiveSpan, startSpan, startSpanManual, suppressTracing, withActiveSpan } from './../tracing/trace';
+import { continueTrace, startInactiveSpan, startNewTrace, startSpan, startSpanManual, suppressTracing, withActiveSpan } from './../tracing/trace';
 import { getActiveSpan } from './../utils/spanUtils';
 /**
  * @private Private API with no semver guarantees!
@@ -52,5 +52,7 @@ export interface AsyncContextStrategy {
      * and `<meta name="baggage">` HTML tags.
      */
     continueTrace?: typeof continueTrace;
+    /** Start a new trace, ensuring all spans in the callback share the same traceId. */
+    startNewTrace?: typeof startNewTrace;
 }
 //# sourceMappingURL=types.d.ts.map

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/currentScopes.d.ts

@@ -1,6 +1,26 @@
 import { Client } from './client';
 import { Scope } from './scope';
 import { TraceContext } from './types-hoist/context';
+/**
+ * Register an external propagation context provider function.
+ * When registered, trace context will be read from the external source (e.g. OpenTelemetry)
+ * instead of from the Sentry scope's propagation context.
+ */
+export declare function registerExternalPropagationContext(fn: () => {
+    traceId: string;
+    spanId: string;
+} | undefined): void;
+/**
+ * Get the external propagation context, if a provider has been registered.
+ */
+export declare function getExternalPropagationContext(): {
+    traceId: string;
+    spanId: string;
+} | undefined;
+/**
+ * Check if an external propagation context provider has been registered.
+ */
+export declare function hasExternalPropagationContext(): boolean;
 /**
  * Get the currently active scope.
  */

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

@@ -8,7 +8,7 @@ export * from './tracing';
 export * from './semanticAttributes';
 export { createEventEnvelope, createSessionEnvelope, createSpanEnvelope } from './envelope';
 export { captureCheckIn, withMonitor, captureException, captureEvent, captureMessage, lastEventId, close, flush, setContext, setExtra, setExtras, setTag, setTags, setUser, setConversationId, isInitialized, isEnabled, startSession, endSession, captureSession, addEventProcessor, } from './exports';
-export { getCurrentScope, getIsolationScope, getGlobalScope, withScope, withIsolationScope, getClient, getTraceContextFromScope, } from './currentScopes';
+export { getCurrentScope, getIsolationScope, getGlobalScope, withScope, withIsolationScope, getClient, getTraceContextFromScope, registerExternalPropagationContext, getExternalPropagationContext, hasExternalPropagationContext, } from './currentScopes';
 export { getDefaultCurrentScope, getDefaultIsolationScope } from './defaultScopes';
 export { setAsyncContextStrategy } from './asyncContext';
 export { getGlobalSingleton, getMainCarrier } from './carrier';
@@ -16,7 +16,7 @@ export { makeSession, closeSession, updateSession } from './session';
 export { Scope } from './scope';
 export { CaptureContext, ScopeContext, ScopeData } from './scope';
 export { notifyEventProcessors } from './eventProcessors';
-export { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint } from './api';
+export { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint, SENTRY_API_VERSION } from './api';
 export { Client } from './client';
 export { ServerRuntimeClient } from './server-runtime-client';
 export { initAndBind, setCurrentClient } from './sdk';
@@ -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';
@@ -208,4 +216,5 @@ export { LegacyCSPReport } from './types-hoist/csp';
 export { SerializedLog, SerializedLogContainer } from './types-hoist/log';
 export { BuildTimeOptionsBase, UnstableVitePluginOptions, UnstableRollupPluginOptions, UnstableWebpackPluginOptions, } from './build-time-plugins/buildTimeOptionsBase';
 export { withRandomSafeContext as _INTERNAL_withRandomSafeContext, RandomSafeContextRunner as _INTERNAL_RandomSafeContextRunner, safeMathRandom as _INTERNAL_safeMathRandom, safeDateNow as _INTERNAL_safeDateNow } from './utils/randomSafeContext';
+export { safeUnref as _INTERNAL_safeUnref } from './utils/timer';
 //# sourceMappingURL=index.d.ts.map

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