@sentry/core 10.30.0 → 10.32.0-alpha.0

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

@@ -6,7 +6,7 @@ export { ServerRuntimeClientOptions } from './server-runtime-client';
 export { IntegrationIndex } from './integration';
 export * from './tracing';
 export * from './semanticAttributes';
-export { createEventEnvelope, createSessionEnvelope, createSpanEnvelope } from './envelope';
+export { createEventEnvelope, createSessionEnvelope, createSpanEnvelope, createSpanV2Envelope } from './envelope';
 export { captureCheckIn, withMonitor, captureException, captureEvent, captureMessage, lastEventId, close, flush, setContext, setExtra, setExtras, setTag, setTags, setUser, isInitialized, isEnabled, startSession, endSession, captureSession, addEventProcessor, } from './exports';
 export { getCurrentScope, getIsolationScope, getGlobalScope, withScope, withIsolationScope, getClient, getTraceContextFromScope, } from './currentScopes';
 export { getDefaultCurrentScope, getDefaultIsolationScope } from './defaultScopes';
@@ -27,6 +27,7 @@ export { getIntegrationsToSetup, addIntegration, defineIntegration, installedInt
 export { _INTERNAL_skipAiProviderWrapping, _INTERNAL_shouldSkipAiProviderWrapping, _INTERNAL_clearAiProviderSkips, } from './utils/ai/providerSkip';
 export { applyScopeDataToEvent, mergeScopeData } from './utils/applyScopeDataToEvent';
 export { prepareEvent } from './utils/prepareEvent';
+export { ExclusiveEventHintOrCaptureContext } from './utils/prepareEvent';
 export { createCheckInEnvelope } from './checkin';
 export { hasSpansEnabled } from './utils/hasSpansEnabled';
 export { isSentryRequestUrl } from './utils/isSentryRequestUrl';
@@ -34,7 +35,10 @@ export { handleCallbackErrors } from './utils/handleCallbackErrors';
 export { parameterize, fmt } from './utils/parameterize';
 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, spanIsSampled, spanToTraceContext, getSpanDescendants, getStatusMessage, getRootSpan, INTERNAL_getSegmentSpan, getActiveSpan, addChildSpanToSpan, spanTimeInputToSeconds, updateSpanName, spanToV2JSON, showSpanDropWarning, } from './utils/spanUtils';
+export { captureSpan } from './spans/captureSpan';
+export { safeSetSpanJSONAttributes } from './spans/spanFirstUtils';
+export { SpanBuffer, SpanBufferOptions } from './spans/spanBuffer';
 export { _setSpanForScope as _INTERNAL_setSpanForScope } from './utils/spanOnScope';
 export { parseSampleRate } from './utils/parseSampleRate';
 export { applySdkMetadata } from './utils/sdkMetadata';
@@ -60,6 +64,7 @@ export { thirdPartyErrorFilterIntegration } from './integrations/third-party-err
 export { consoleIntegration } from './integrations/console';
 export { featureFlagsIntegration, FeatureFlagsIntegration } from './integrations/featureFlags';
 export { growthbookIntegration } from './integrations/featureFlags';
+export { serverSpanStreamingIntegration } from './integrations/serverSpanStreaming';
 export { profiler } from './profiling';
 export { instrumentFetchRequest } from './fetch';
 export { trpcMiddleware } from './trpc';
@@ -126,7 +131,7 @@ export { isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, trunca
 export { isNativeFunction, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsHistory, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver, } from './utils/supports';
 export { SyncPromise, rejectedSyncPromise, resolvedSyncPromise } from './utils/syncpromise';
 export { browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds } from './utils/time';
-export { TRACEPARENT_REGEXP, extractTraceparentData, generateSentryTraceHeader, propagationContextFromHeaders, shouldContinueTrace, } from './utils/tracing';
+export { TRACEPARENT_REGEXP, extractTraceparentData, generateSentryTraceHeader, propagationContextFromHeaders, shouldContinueTrace, generateTraceparentHeader, } from './utils/tracing';
 export { getSDKSource, isBrowserBundle } from './utils/env';
 export { SdkSource } from './utils/env';
 export { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, createEventEnvelopeHeaders, createSpanEnvelopeItem, envelopeContainsItemType, envelopeItemTypeToDataCategory, forEachEnvelopeItem, getSdkMetadataForEnvelopeHeader, parseEnvelope, serializeEnvelope, } from './utils/envelope';
@@ -144,6 +149,8 @@ export { flushIfServerless } from './utils/flushIfServerless';
 export { SDK_VERSION } from './utils/version';
 export { getDebugImagesForResources, getFilenameToDebugIdMap } from './utils/debug-ids';
 export { escapeStringForRegex } from './vendor/escapeStringForRegex';
+export { isV2BeforeSendSpanCallback, withStreamSpan } from './utils/beforeSendSpan';
+export { shouldIgnoreSpan, reparentChildSpans } from './utils/should-ignore-span';
 export { Attachment } from './types-hoist/attachment';
 export { Breadcrumb, BreadcrumbHint, FetchBreadcrumbData, XhrBreadcrumbData, FetchBreadcrumbHint, XhrBreadcrumbHint, } from './types-hoist/breadcrumb';
 export { ClientReport, Outcome, EventDropReason } from './types-hoist/clientreport';
@@ -151,7 +158,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, SpanV2Envelope, 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';
@@ -172,7 +179,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, SpanV2JSON, SpanV2JSONWithSegmentRef, } 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/mcp-server/correlation.d.ts

@@ -16,10 +16,10 @@ import { MCPTransport, RequestId } from './types';
  */
 export declare function storeSpanForRequest(transport: MCPTransport, requestId: RequestId, span: Span, method: string): void;
 /**
- * Completes span with tool results and cleans up correlation
+ * Completes span with results and cleans up correlation
  * @param transport - MCP transport instance
  * @param requestId - Request identifier
- * @param result - Tool execution result for attribute extraction
+ * @param result - Execution result for attribute extraction
  */
 export declare function completeSpanWithResults(transport: MCPTransport, requestId: RequestId, result: unknown): void;
 /**

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

@@ -3,7 +3,7 @@
  *
  * Handles extraction of client/server info and session data from MCP messages.
  */
-import { ExtraHandlerData, JsonRpcRequest, MCPTransport, SessionData } from './types';
+import { ExtraHandlerData, JsonRpcRequest, MCPTransport, PartyInfo, SessionData } from './types';
 /**
  * Extracts session data from "initialize" requests
  * @param request - JSON-RPC "initialize" request containing client info and protocol version
@@ -22,12 +22,24 @@ export declare function extractSessionDataFromInitializeResponse(result: unknown
  * @returns Client attributes for span instrumentation
  */
 export declare function getClientAttributes(transport: MCPTransport): Record<string, string>;
+/**
+ * Build client attributes from PartyInfo directly
+ * @param clientInfo - Client party info
+ * @returns Client attributes for span instrumentation
+ */
+export declare function buildClientAttributesFromInfo(clientInfo?: PartyInfo): Record<string, string>;
 /**
  * Build server attributes from stored server info
  * @param transport - MCP transport instance
  * @returns Server attributes for span instrumentation
  */
 export declare function getServerAttributes(transport: MCPTransport): Record<string, string>;
+/**
+ * Build server attributes from PartyInfo directly
+ * @param serverInfo - Server party info
+ * @returns Server attributes for span instrumentation
+ */
+export declare function buildServerAttributesFromInfo(serverInfo?: PartyInfo): Record<string, string>;
 /**
  * Extracts client connection info from extra handler data
  * @param extra - Extra handler data containing connection info

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

@@ -0,0 +1,8 @@
+export interface ServerSpanStreamingOptions {
+    /** Max spans per envelope batch (default: 1000) */
+    maxSpanLimit?: number;
+    /** Flush interval in ms (default: 5000) */
+    flushInterval?: number;
+}
+export declare const serverSpanStreamingIntegration: (options?: ServerSpanStreamingOptions | undefined) => import("../types-hoist/integration").Integration;
+//# sourceMappingURL=serverSpanStreaming.d.ts.map

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

@@ -51,6 +51,7 @@ export declare const SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE = "cache.item_size";
 /** TODO: Remove these once we update to latest semantic conventions */
 export declare const SEMANTIC_ATTRIBUTE_HTTP_REQUEST_METHOD = "http.request.method";
 export declare const SEMANTIC_ATTRIBUTE_URL_FULL = "url.full";
+export declare const SEMANTIC_ATTRIBUTE_URL_QUERY = "url.query";
 /**
  * A span link attribute to mark the link as a special span link.
  *
@@ -62,4 +63,24 @@ export declare const SEMANTIC_ATTRIBUTE_URL_FULL = "url.full";
  * @see https://develop.sentry.dev/sdk/telemetry/traces/span-links/#link-types
  */
 export declare const SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE = "sentry.link.type";
+/** The release version of the application */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_RELEASE = "sentry.release";
+/** The environment name (e.g., "production", "staging", "development") */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_ENVIRONMENT = "sentry.environment";
+/** The segment name (e.g., "GET /users") */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_NAME = "sentry.segment.name";
+/** The id of the segment that this span belongs to. */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_SEGMENT_ID = "sentry.segment.id";
+/** The user ID (gated by sendDefaultPii) */
+export declare const SEMANTIC_ATTRIBUTE_USER_ID = "user.id";
+/** The user email (gated by sendDefaultPii) */
+export declare const SEMANTIC_ATTRIBUTE_USER_EMAIL = "user.email";
+/** The user IP address (gated by sendDefaultPii) */
+export declare const SEMANTIC_ATTRIBUTE_USER_IP_ADDRESS = "user.ip_address";
+/** The user username (gated by sendDefaultPii) */
+export declare const SEMANTIC_ATTRIBUTE_USER_USERNAME = "user.name";
+/** The name of the Sentry SDK (e.g., "sentry.php", "sentry.javascript") */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_SDK_NAME = "sentry.sdk.name";
+/** The version of the Sentry SDK */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_SDK_VERSION = "sentry.sdk.version";
 //# sourceMappingURL=semanticAttributes.d.ts.map

package/build/types-ts3.8/spans/captureSpan.d.ts

@@ -0,0 +1,10 @@
+import { Client } from '../client';
+import { Span } from '../types-hoist/span';
+/**
+ * Captures a span and returns a JSON representation to be enqueued for sending.
+ *
+ * IMPORTANT: This function converts the span to JSON immediately to avoid writing
+ * to an already-ended OTel span instance (which is blocked by the OTel Span class).
+ */
+export declare function captureSpan(span: Span, client?: Client<import("..").ClientOptions<import("..").BaseTransportOptions>> | undefined): void;
+//# sourceMappingURL=captureSpan.d.ts.map

package/build/types-ts3.8/spans/spanBuffer.d.ts

@@ -0,0 +1,31 @@
+import { Client } from '../client';
+import { SpanV2JSONWithSegmentRef } from '../types-hoist/span';
+export interface SpanBufferOptions {
+    /** Max spans per trace before auto-flush (default: 1000) */
+    maxSpanLimit?: number;
+    /** Flush interval in ms (default: 5000) */
+    flushInterval?: number;
+}
+/**
+ * A buffer for span JSON objects that flushes them to Sentry in Span v2 envelopes.
+ * Handles interval-based flushing, size thresholds, and graceful shutdown.
+ */
+export declare class SpanBuffer {
+    private _spanTreeMap;
+    private _flushIntervalId;
+    private _client;
+    private _maxSpanLimit;
+    private _flushInterval;
+    constructor(client: Client, options?: SpanBufferOptions);
+    /**
+     * Add a span to the buffer.
+     */
+    addSpan(spanJSON: SpanV2JSONWithSegmentRef): void;
+    /**
+     * Flush all buffered traces.
+     */
+    flush(): void;
+    private _flushTrace;
+    private _debounceFlushInterval;
+}
+//# sourceMappingURL=spanBuffer.d.ts.map

package/build/types-ts3.8/spans/spanFirstUtils.d.ts

@@ -0,0 +1,20 @@
+import { RawAttributes } from '../attributes';
+import { Contexts } from '../types-hoist/context';
+import { SpanV2JSON } from '../types-hoist/span';
+/**
+ * Only set a span JSON attribute if it is not already set.
+ * This is used to safely set attributes on JSON objects without mutating already-ended span instances.
+ */
+export declare function safeSetSpanJSONAttributes(spanJSON: SpanV2JSON, newAttributes: RawAttributes<Record<string, unknown>>): void;
+/**
+ * Apply a user-provided beforeSendSpan callback to a span JSON.
+ */
+export declare function applyBeforeSendSpanCallback(span: SpanV2JSON, beforeSendSpan: (span: SpanV2JSON) => SpanV2JSON): SpanV2JSON;
+/**
+ * Converts a context object to a set of attributes.
+ * Only includes attributes that are primitives (for now).
+ * @param contexts - The context object to convert.
+ * @returns The attributes object.
+ */
+export declare function contextsToAttributes(contexts: Contexts): RawAttributes<Record<string, unknown>>;
+//# sourceMappingURL=spanFirstUtils.d.ts.map

package/build/types-ts3.8/tracing/ai/messageTruncation.d.ts

@@ -3,26 +3,6 @@
  * Messages exceeding this limit will be truncated.
  */
 export declare const DEFAULT_GEN_AI_MESSAGES_BYTE_LIMIT = 20000;
-/**
- * Truncate an array of messages to fit within a byte limit.
- *
- * Strategy:
- * - Keeps the newest messages (from the end of the array)
- * - Uses O(n) algorithm: precompute sizes once, then find largest suffix under budget
- * - If no complete messages fit, attempts to truncate the newest single message
- *
- * @param messages - Array of messages to truncate
- * @param maxBytes - Maximum total byte limit for all messages
- * @returns Truncated array of messages
- *
- * @example
- * ```ts
- * const messages = [msg1, msg2, msg3, msg4]; // newest is msg4
- * const truncated = truncateMessagesByBytes(messages, 10000);
- * // Returns [msg3, msg4] if they fit, or [msg4] if only it fits, etc.
- * ```
- */
-export declare function truncateMessagesByBytes(messages: unknown[], maxBytes: number): unknown[];
 /**
  * Truncate GenAI messages using the default byte limit.
  *

package/build/types-ts3.8/tracing/google-genai/utils.d.ts

@@ -7,4 +7,29 @@ export declare function shouldInstrument(methodPath: string): methodPath is Goog
  * Check if a method is a streaming method
  */
 export declare function isStreamingMethod(methodPath: string): boolean;
+export type ContentListUnion = Content | Content[] | PartListUnion;
+export type ContentUnion = Content | PartUnion[] | PartUnion;
+export type Content = {
+    parts?: Part[];
+    role?: string;
+};
+export type PartUnion = Part | string;
+export type Part = Record<string, unknown> & {
+    inlineData?: {
+        data?: string;
+        displayName?: string;
+        mimeType?: string;
+    };
+    text?: string;
+};
+export type PartListUnion = PartUnion[] | PartUnion;
+export type Message = Record<string, unknown> & {
+    role: string;
+    content?: PartListUnion;
+    parts?: PartListUnion;
+};
+/**
+ *
+ */
+export declare function contentUnionToMessages(content: ContentListUnion, role?: string): Message[];
 //# sourceMappingURL=utils.d.ts.map

package/build/types-ts3.8/tracing/sentrySpan.d.ts

@@ -1,5 +1,5 @@
 import { SpanLink } from '../types-hoist/link';
-import { SentrySpanArguments, Span, SpanAttributes, SpanAttributeValue, SpanContextData, SpanJSON, SpanTimeInput } from '../types-hoist/span';
+import { SentrySpanArguments, Span, SpanAttributes, SpanAttributeValue, SpanContextData, SpanJSON, SpanTimeInput, SpanV2JSON } from '../types-hoist/span';
 import { SpanStatus } from '../types-hoist/spanStatus';
 import { TimedEvent } from '../types-hoist/timedEvent';
 /**
@@ -77,6 +77,15 @@ export declare class SentrySpan implements Span {
      * use `spanToJSON(span)` instead.
      */
     getSpanJSON(): SpanJSON;
+    /**
+     * Get SpanV2JSON representation of this span.
+     *
+     * @hidden
+     * @internal This method is purely for internal purposes and should not be used outside
+     * of SDK code. If you need to get a JSON representation of a span,
+     * use `spanToV2JSON(span)` instead.
+     */
+    getSpanV2JSON(): SpanV2JSON;
     /** @inheritdoc */
     isRecording(): boolean;
     /**

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

@@ -0,0 +1,19 @@
+import { AttributeUnit } from '../attributes';
+export type SerializedAttributes = Record<string, SerializedAttribute>;
+export type SerializedAttribute = ({
+    type: 'string';
+    value: string;
+} | {
+    type: 'integer';
+    value: number;
+} | {
+    type: 'double';
+    value: number;
+} | {
+    type: 'boolean';
+    value: boolean;
+}) & {
+    unit?: AttributeUnit;
+};
+export type SerializedAttributeType = 'string' | 'integer' | 'double' | 'boolean';
+//# sourceMappingURL=attributes.d.ts.map

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

@@ -11,7 +11,7 @@ import { Profile, ProfileChunk } from './profiling';
 import { ReplayEvent, ReplayRecordingData } from './replay';
 import { SdkInfo } from './sdkinfo';
 import { SerializedSession, SessionAggregates } from './session';
-import { SpanJSON } from './span';
+import { SerializedSpanContainer, SpanJSON } from './span';
 export type DynamicSamplingContext = {
     trace_id: string;
     public_key: DsnComponents['publicKey'];
@@ -87,6 +87,21 @@ type ProfileChunkItemHeaders = {
 type SpanItemHeaders = {
     type: 'span';
 };
+type SpanContainerItemHeaders = {
+    /**
+     * Same as v1 span item type but this envelope is distinguished by {@link SpanContainerItemHeaders.content_type}.
+     */
+    type: 'span';
+    /**
+     * The number of span items in the container. This must be the same as the number of span items in the payload.
+     */
+    item_count: number;
+    /**
+     * The content type of the span items. This must be `application/vnd.sentry.items.span.v2+json`.
+     * (the presence of this field also distinguishes the span item from the v1 span item)
+     */
+    content_type: 'application/vnd.sentry.items.span.v2+json';
+};
 type LogContainerItemHeaders = {
     type: 'log';
     /**
@@ -120,6 +135,7 @@ export type FeedbackItem = BaseEnvelopeItem<FeedbackItemHeaders, FeedbackEvent>;
 export type ProfileItem = BaseEnvelopeItem<ProfileItemHeaders, Profile>;
 export type ProfileChunkItem = BaseEnvelopeItem<ProfileChunkItemHeaders, ProfileChunk>;
 export type SpanItem = BaseEnvelopeItem<SpanItemHeaders, Partial<SpanJSON>>;
+export type SpanContainerItem = BaseEnvelopeItem<SpanContainerItemHeaders, SerializedSpanContainer>;
 export type LogContainerItem = BaseEnvelopeItem<LogContainerItemHeaders, SerializedLogContainer>;
 export type MetricContainerItem = BaseEnvelopeItem<MetricContainerItemHeaders, SerializedMetricContainer>;
 export type RawSecurityItem = BaseEnvelopeItem<RawSecurityHeaders, LegacyCSPReport>;
@@ -139,6 +155,9 @@ type ReplayEnvelopeHeaders = BaseEnvelopeHeaders;
 type SpanEnvelopeHeaders = BaseEnvelopeHeaders & {
     trace?: DynamicSamplingContext;
 };
+type SpanV2EnvelopeHeaders = BaseEnvelopeHeaders & {
+    trace?: DynamicSamplingContext;
+};
 type LogEnvelopeHeaders = BaseEnvelopeHeaders;
 type MetricEnvelopeHeaders = BaseEnvelopeHeaders;
 export type EventEnvelope = BaseEnvelope<EventEnvelopeHeaders, EventItem | AttachmentItem | UserFeedbackItem | FeedbackItem | ProfileItem>;
@@ -153,11 +172,12 @@ export type ReplayEnvelope = [
 ];
 export type CheckInEnvelope = BaseEnvelope<CheckInEnvelopeHeaders, CheckInItem>;
 export type SpanEnvelope = BaseEnvelope<SpanEnvelopeHeaders, SpanItem>;
+export type SpanV2Envelope = BaseEnvelope<SpanV2EnvelopeHeaders, SpanContainerItem>;
 export type ProfileChunkEnvelope = BaseEnvelope<BaseEnvelopeHeaders, ProfileChunkItem>;
 export type RawSecurityEnvelope = BaseEnvelope<BaseEnvelopeHeaders, RawSecurityItem>;
 export type LogEnvelope = BaseEnvelope<LogEnvelopeHeaders, LogContainerItem>;
 export type MetricEnvelope = BaseEnvelope<MetricEnvelopeHeaders, MetricContainerItem>;
-export type Envelope = EventEnvelope | SessionEnvelope | ClientReportEnvelope | ProfileChunkEnvelope | ReplayEnvelope | CheckInEnvelope | SpanEnvelope | RawSecurityEnvelope | LogEnvelope | MetricEnvelope;
+export type Envelope = EventEnvelope | SessionEnvelope | ClientReportEnvelope | ProfileChunkEnvelope | ReplayEnvelope | CheckInEnvelope | SpanEnvelope | SpanV2Envelope | RawSecurityEnvelope | LogEnvelope | MetricEnvelope;
 export type EnvelopeItem = Envelope[1][number];
 export {};
 //# sourceMappingURL=envelope.d.ts.map

package/build/types-ts3.8/types-hoist/link.d.ts

@@ -19,11 +19,11 @@ export interface SpanLink {
  * Link interface for the event envelope item. It's a flattened representation of `SpanLink`.
  * Can include additional fields defined by OTel.
  */
-export interface SpanLinkJSON extends Record<string, unknown> {
+export interface SpanLinkJSON<TAttributes = SpanLinkAttributes> extends Record<string, unknown> {
     span_id: string;
     trace_id: string;
     sampled?: boolean;
-    attributes?: SpanLinkAttributes;
+    attributes?: TAttributes;
 }
 export {};
 //# sourceMappingURL=link.d.ts.map

package/build/types-ts3.8/types-hoist/options.d.ts

@@ -6,7 +6,7 @@ import { Log } from './log';
 import { Metric } from './metric';
 import { TracesSamplerSamplingContext } from './samplingcontext';
 import { SdkMetadata } from './sdkmetadata';
-import { SpanJSON } from './span';
+import { SpanJSON, SpanV2JSON } from './span';
 import { StackLineParser, StackParser } from './stacktrace';
 import { TracePropagationTargets } from './tracing';
 import { BaseTransportOptions, Transport } from './transport';
@@ -331,6 +331,19 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
      *   - Tracing headers will be attached because the request URL matches the string `'https://external-api.com'`.
      */
     tracePropagationTargets?: TracePropagationTargets;
+    /**
+     * If set to `true`, the SDK propagates the W3C `traceparent` header to any outgoing requests,
+     * in addition to the `sentry-trace` and `baggage` headers. Use the {@link CoreOptions.tracePropagationTargets}
+     * option to control to which outgoing requests the header will be attached.
+     *
+     * **Important:** If you set this option to `true`, make sure that you configured your servers'
+     * CORS settings to allow the `traceparent` header. Otherwise, requests might get blocked.
+     *
+     * @see https://www.w3.org/TR/trace-context/
+     *
+     * @default false
+     */
+    propagateTraceparent?: boolean;
     /**
      * If set to `true`, the SDK will only continue a trace if the `organization ID` of the incoming trace found in the
      * `baggage` header matches the `organization ID` of the current Sentry client.
@@ -343,6 +356,15 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
      * @default false
      */
     strictTraceContinuation?: boolean;
+    /**
+     * [Experimental] The trace lifecycle, determining whether spans are sent statically when the entire local span tree is complete, or
+     * in batches, following interval- and action-based triggers.
+     *
+     * @experimental this option is currently still experimental and its type, name, or entire presence is subject to break and change at any time.
+     *
+     * @default 'static'
+     */
+    traceLifecycle?: 'static' | 'stream';
     /**
      * The organization ID for your Sentry project.
      *
@@ -419,7 +441,7 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
      *
      * @returns The modified span payload that will be sent.
      */
-    beforeSendSpan?: (span: SpanJSON) => SpanJSON;
+    beforeSendSpan?: ((span: SpanJSON) => SpanJSON) | SpanV2CompatibleBeforeSendSpanCallback;
     /**
      * An event-processing callback for transaction events, guaranteed to be invoked after all other event
      * processors. This allows an event to be modified or dropped before it's sent.
@@ -445,6 +467,13 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
      */
     beforeBreadcrumb?: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => Breadcrumb | null;
 }
+/**
+ * A callback that is known to be compatible with actually receiving and returning a span v2 JSON object.
+ * Only useful in conjunction with the {@link CoreOptions.traceLifecycle} option.
+ */
+export type SpanV2CompatibleBeforeSendSpanCallback = ((span: SpanV2JSON) => SpanV2JSON) & {
+    _v2: true;
+};
 /** Base configuration options for every SDK. */
 export interface CoreOptions<TO extends BaseTransportOptions = BaseTransportOptions> extends Pick<Partial<ClientOptions<TO>>, Exclude<keyof Partial<ClientOptions<TO>>, 'integrations' | 'transport' | 'stackParser'>> {
     /**

package/build/types-ts3.8/types-hoist/span.d.ts

@@ -1,3 +1,4 @@
+import { TypedAttributes } from '../attributes';
 import { SpanLink, SpanLinkJSON } from './link';
 import { Measurements } from './measurement';
 import { HrTime } from './opentelemetry';
@@ -17,6 +18,32 @@ export type SpanAttributes = Partial<{
 }> & Record<string, SpanAttributeValue | undefined>;
 /** This type is aligned with the OpenTelemetry TimeInput type. */
 export type SpanTimeInput = HrTime | number | Date;
+/**
+ * JSON representation of a v2 span, as it should be sent to Sentry.
+ */
+export interface SpanV2JSON {
+    trace_id: string;
+    parent_span_id?: string;
+    span_id: string;
+    name: string;
+    start_timestamp: number;
+    end_timestamp: number;
+    status: 'ok' | 'error';
+    is_segment: boolean;
+    attributes?: TypedAttributes;
+    links?: SpanLinkJSON<TypedAttributes>[];
+}
+/**
+ * A SpanV2JSON with an attached reference to the segment span.
+ * This reference is used to compute dynamic sampling context before sending.
+ * The reference MUST be removed before sending the span envelope.
+ */
+export interface SpanV2JSONWithSegmentRef extends SpanV2JSON {
+    _segmentSpan: Span;
+}
+export type SerializedSpanContainer = {
+    items: Array<SpanV2JSON>;
+};
 /** A JSON representation of a span. */
 export interface SpanJSON {
     data: SpanAttributes;

package/build/types-ts3.8/utils/beforeSendSpan.d.ts

@@ -0,0 +1,22 @@
+import { ClientOptions, SpanV2CompatibleBeforeSendSpanCallback } from '../types-hoist/options';
+import { SpanV2JSON } from '../types-hoist/span';
+/**
+ * A wrapper to use the new span format in your `beforeSendSpan` callback.
+ *
+ * @example
+ *
+ * Sentry.init({
+ *   beforeSendSpan: withStreamSpan((span) => {
+ *     return span;
+ *   }),
+ * });
+ *
+ * @param callback
+ * @returns
+ */
+export declare function withStreamSpan(callback: (span: SpanV2JSON) => SpanV2JSON): SpanV2CompatibleBeforeSendSpanCallback;
+/**
+ * Typesafe check to identify the expected span json format of the `beforeSendSpan` callback.
+ */
+export declare function isV2BeforeSendSpanCallback(callback: ClientOptions['beforeSendSpan']): callback is SpanV2CompatibleBeforeSendSpanCallback;
+//# sourceMappingURL=beforeSendSpan.d.ts.map

package/build/types-ts3.8/utils/request.d.ts

@@ -37,7 +37,7 @@ export declare function httpRequestToRequestData(request: {
  *
  * @see https://opentelemetry.io/docs/specs/semconv/registry/attributes/http/#http-request-header
  */
-export declare function httpHeadersToSpanAttributes(headers: Record<string, string | string[] | undefined>): Record<string, string>;
+export declare function httpHeadersToSpanAttributes(headers: Record<string, string | string[] | undefined>, sendDefaultPii?: boolean): Record<string, string>;
 /** Extract the query params from an URL. */
 export declare function extractQueryParamsFromUrl(url: string): string | undefined;
 //# sourceMappingURL=request.d.ts.map

package/build/types-ts3.8/utils/should-ignore-span.d.ts

@@ -1,12 +1,12 @@
 import { ClientOptions } from '../types-hoist/options';
-import { SpanJSON } from '../types-hoist/span';
+import { SpanJSON, SpanV2JSON } from '../types-hoist/span';
 /**
  * Check if a span should be ignored based on the ignoreSpans configuration.
  */
-export declare function shouldIgnoreSpan(span: Pick<SpanJSON, 'description' | 'op'>, ignoreSpans: Required<ClientOptions>['ignoreSpans']): boolean;
+export declare function shouldIgnoreSpan(span: Pick<SpanJSON, 'description' | 'op'> | Pick<SpanV2JSON, 'name' | 'attributes'>, ignoreSpans: Required<ClientOptions>['ignoreSpans']): boolean;
 /**
  * Takes a list of spans, and a span that was dropped, and re-parents the child spans of the dropped span to the parent of the dropped span, if possible.
  * This mutates the spans array in place!
  */
-export declare function reparentChildSpans(spans: SpanJSON[], dropSpan: SpanJSON): void;
+export declare function reparentChildSpans(spans: Pick<SpanV2JSON, 'parent_span_id' | 'span_id'>[], dropSpan: Pick<SpanV2JSON, 'parent_span_id' | 'span_id'>): void;
 //# sourceMappingURL=should-ignore-span.d.ts.map

package/build/types-ts3.8/utils/spanUtils.d.ts

@@ -1,6 +1,7 @@
+import { TypedAttributes } from '../attributes';
 import { TraceContext } from '../types-hoist/context';
 import { SpanLink, SpanLinkJSON } from '../types-hoist/link';
-import { Span, SpanAttributes, SpanJSON, SpanTimeInput } from '../types-hoist/span';
+import { Span, SpanAttributes, SpanJSON, SpanTimeInput, SpanV2JSON } from '../types-hoist/span';
 import { SpanStatus } from '../types-hoist/spanStatus';
 export declare const TRACE_FLAG_NONE = 0;
 export declare const TRACE_FLAG_SAMPLED = 1;
@@ -28,6 +29,12 @@ export declare function spanToTraceparentHeader(span: Span): string;
  *  If the links array is empty, it returns `undefined` so the empty value can be dropped before it's sent.
  */
 export declare function convertSpanLinksForEnvelope(links?: SpanLink[]): SpanLinkJSON[] | undefined;
+/**
+ *
+ * @param links
+ * @returns
+ */
+export declare function getV2SpanLinks(links?: SpanLink[]): SpanLinkJSON<TypedAttributes>[] | undefined;
 /**
  * Convert a span time input into a timestamp in seconds.
  */
@@ -36,6 +43,11 @@ export declare function spanTimeInputToSeconds(input: SpanTimeInput | undefined)
  * Convert a span to a JSON representation.
  */
 export declare function spanToJSON(span: Span): SpanJSON;
+/**
+ * Convert a span to a SpanV2JSON representation.
+ * @returns
+ */
+export declare function spanToV2JSON(span: Span): SpanV2JSON;
 /** Exported only for tests. */
 export interface OpenTelemetrySdkTraceBaseSpan extends Span {
     attributes: SpanAttributes;
@@ -55,6 +67,14 @@ export interface OpenTelemetrySdkTraceBaseSpan extends Span {
 export declare function spanIsSampled(span: Span): boolean;
 /** Get the status message to use for a JSON representation of a span. */
 export declare function getStatusMessage(status: SpanStatus | undefined): string | undefined;
+/**
+ * Convert the various statuses to the ones expected by Sentry ('ok' is default)
+ */
+export declare function getV2StatusMessage(status: SpanStatus | undefined): 'ok' | 'error';
+/**
+ * Convert the attributes to the ones expected by Sentry, including the type annotation
+ */
+export declare function getV2Attributes(attributes: SpanAttributes): TypedAttributes;
 declare const CHILD_SPANS_FIELD = "_sentryChildSpans";
 declare const ROOT_SPAN_FIELD = "_sentryRootSpan";
 type SpanWithPotentialChildren = Span & {
@@ -74,7 +94,11 @@ export declare function getSpanDescendants(span: SpanWithPotentialChildren): Spa
 /**
  * Returns the root span of a given span.
  */
-export declare function getRootSpan(span: SpanWithPotentialChildren): Span;
+export declare const getRootSpan: typeof INTERNAL_getSegmentSpan;
+/**
+ * Returns the segment span of a given span.
+ */
+export declare function INTERNAL_getSegmentSpan(span: SpanWithPotentialChildren): Span;
 /**
  * Returns the currently active span.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/core",
-  "version": "10.30.0",
+  "version": "10.32.0-alpha.0",
   "description": "Base implementation for all Sentry JavaScript SDKs",
   "repository": "git://github.com/getsentry/sentry-javascript.git",
   "homepage": "https://github.com/getsentry/sentry-javascript/tree/master/packages/core",