@sentry/core 10.46.0 → 10.48.0

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, StreamedSpanJSON } 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 {@link StreamedSpanJSON} 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 `spanToStreamedSpanJSON(span)` instead.
+     */
+    getStreamedSpanJSON(): StreamedSpanJSON;
     /** @inheritdoc */
     isRecording(): boolean;
     /**

package/build/types-ts3.8/tracing/spans/beforeSendSpan.d.ts

@@ -0,0 +1,35 @@
+import { CoreOptions } from '../../types-hoist/options';
+import { BeforeSendStreamedSpanCallback } from '../../types-hoist/options';
+import { StreamedSpanJSON } from '../../types-hoist/span';
+type StaticBeforeSendSpanCallback = CoreOptions['beforeSendSpan'];
+/**
+ * A wrapper to use the new span format in your `beforeSendSpan` callback.
+ *
+ * When using `traceLifecycle: 'stream'`, wrap your callback with this function
+ * to receive and return {@link StreamedSpanJSON} instead of the standard {@link SpanJSON}.
+ *
+ * @example
+ *
+ * Sentry.init({
+ *   traceLifecycle: 'stream',
+ *   beforeSendSpan: withStreamedSpan((span) => {
+ *     // span is of type StreamedSpanJSON
+ *     return span;
+ *   }),
+ * });
+ *
+ * @param callback - The callback function that receives and returns a {@link StreamedSpanJSON}.
+ * @returns A callback that is compatible with the `beforeSendSpan` option when using `traceLifecycle: 'stream'`.
+ */
+export declare function withStreamedSpan(callback: (span: StreamedSpanJSON) => StreamedSpanJSON): StaticBeforeSendSpanCallback & {
+    _streamed: true;
+};
+/**
+ * Typesafe check to identify if a `beforeSendSpan` callback expects the streamed span JSON format.
+ *
+ * @param callback - The `beforeSendSpan` callback to check.
+ * @returns `true` if the callback was wrapped with {@link withStreamedSpan}.
+ */
+export declare function isStreamedBeforeSendSpanCallback(callback: unknown): callback is BeforeSendStreamedSpanCallback;
+export {};
+//# sourceMappingURL=beforeSendSpan.d.ts.map

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

@@ -0,0 +1,26 @@
+import { RawAttributes } from '../../attributes';
+import { Client } from '../../client';
+import { SerializedStreamedSpan, Span, StreamedSpanJSON } from '../../types-hoist/span';
+export type SerializedStreamedSpanWithSegmentSpan = SerializedStreamedSpan & {
+    _segmentSpan: 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).
+ *
+ * @returns the final serialized span with a reference to its segment span. This reference
+ * is needed later on to compute the DSC for the span envelope.
+ */
+export declare function captureSpan(span: Span, client: Client): SerializedStreamedSpanWithSegmentSpan;
+/**
+ * Apply a user-provided beforeSendSpan callback to a span JSON.
+ */
+export declare function applyBeforeSendSpanCallback(span: StreamedSpanJSON, beforeSendSpan: (span: StreamedSpanJSON) => StreamedSpanJSON): StreamedSpanJSON;
+/**
+ * Safely set attributes on a span JSON.
+ * If an attribute already exists, it will not be overwritten.
+ */
+export declare function safeSetSpanJSONAttributes(spanJSON: StreamedSpanJSON, newAttributes: RawAttributes<Record<string, unknown>>): void;
+//# sourceMappingURL=captureSpan.d.ts.map

package/build/types-ts3.8/tracing/spans/envelope.d.ts

@@ -0,0 +1,8 @@
+import { Client } from '../../client';
+import { DynamicSamplingContext, StreamedSpanEnvelope } from '../../types-hoist/envelope';
+import { SerializedStreamedSpan } from '../../types-hoist/span';
+/**
+ * Creates a span v2 span streaming envelope
+ */
+export declare function createStreamedSpanEnvelope(serializedSpans: Array<SerializedStreamedSpan>, dsc: Partial<DynamicSamplingContext>, client: Client): StreamedSpanEnvelope;
+//# sourceMappingURL=envelope.d.ts.map

package/build/types-ts3.8/tracing/spans/estimateSize.d.ts

@@ -0,0 +1,12 @@
+import { SerializedStreamedSpan } from '../../types-hoist/span';
+/**
+ * Estimates the serialized byte size of a {@link SerializedStreamedSpan}.
+ *
+ * Uses 2 bytes per character as a UTF-16 approximation, and 8 bytes per number.
+ * The estimate is intentionally conservative and may be slightly lower than the
+ * actual byte size on the wire.
+ * We compensate for this by setting the span buffers internal limit well below the limit
+ * of how large an actual span v2 envelope may be.
+ */
+export declare function estimateSerializedSpanSizeInBytes(span: SerializedStreamedSpan): number;
+//# sourceMappingURL=estimateSize.d.ts.map

package/build/types-ts3.8/tracing/spans/hasSpanStreamingEnabled.d.ts

@@ -0,0 +1,6 @@
+import { Client } from '../../client';
+/**
+ * Determines if span streaming is enabled for the given client
+ */
+export declare function hasSpanStreamingEnabled(client: Client): boolean;
+//# sourceMappingURL=hasSpanStreamingEnabled.d.ts.map

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

@@ -0,0 +1,60 @@
+import { Client } from '../../client';
+import { SerializedStreamedSpanWithSegmentSpan } from './captureSpan';
+export interface SpanBufferOptions {
+    /**
+     * Max spans per trace before auto-flush
+     * Must not exceed 1000.
+     *
+     * @default 1_000
+     */
+    maxSpanLimit?: number;
+    /**
+     * Per-trace flush timeout in ms. A timeout is started when a trace bucket is first created
+     * and fires flush() for that specific trace when it expires.
+     * Must be greater than 0.
+     *
+     * @default 5_000
+     */
+    flushInterval?: number;
+    /**
+     * Max accumulated byte weight of spans per trace before auto-flush.
+     * Size is estimated, not exact. Uses 2 bytes per character for strings (UTF-16).
+     *
+     * @default 5_000_000 (5 MB)
+     */
+    maxTraceWeightInBytes?: number;
+}
+/**
+ * A buffer for serialized streamed span JSON objects that flushes them to Sentry in Span v2 envelopes.
+ * Handles per-trace timeout-based flushing, size thresholds, and graceful shutdown.
+ * Also handles computation of the Dynamic Sampling Context (DSC) for the trace, if it wasn't yet
+ * frozen onto the segment span.
+ *
+ * For this, we need the reference to the segment span instance, from
+ * which we compute the DSC. Doing this in the buffer ensures that we compute the DSC as late as possible,
+ * allowing span name and data updates up to this point. Worth noting here that the segment span is likely
+ * still active and modifyable when child spans are added to the buffer.
+ */
+export declare class SpanBuffer {
+    private _traceBuckets;
+    private _client;
+    private _maxSpanLimit;
+    private _flushInterval;
+    private _maxTraceWeight;
+    constructor(client: Client, options?: SpanBufferOptions);
+    /**
+     * Add a span to the buffer.
+     */
+    add(spanJSON: SerializedStreamedSpanWithSegmentSpan): void;
+    /**
+     * Drain and flush all buffered traces.
+     */
+    drain(): void;
+    /**
+     * Flush spans of a specific trace.
+     * In contrast to {@link SpanBuffer.drain}, this method does not flush all traces, but only the one with the given traceId.
+     */
+    flush(traceId: string): void;
+    private _removeTrace;
+}
+//# sourceMappingURL=spanBuffer.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 { SerializedStreamedSpanContainer, 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, SerializedStreamedSpanContainer>;
 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 StreamedSpanEnvelopeHeaders = 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 StreamedSpanEnvelope = BaseEnvelope<StreamedSpanEnvelopeHeaders, 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 | StreamedSpanEnvelope | RawSecurityEnvelope | LogEnvelope | MetricEnvelope;
 export type EnvelopeItem = Envelope[1][number];
 export {};
 //# sourceMappingURL=envelope.d.ts.map

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

@@ -11,6 +11,14 @@ export interface Integration {
      * It does not receives any arguments, and should only use for e.g. global monkey patching and similar things.
      */
     setupOnce?(): void;
+    /**
+     * Called before the `setup` hook of any integration is called.
+     * This is useful if an integration needs to e.g. modify client options prior to other integrations
+     * reading client options.
+     *
+     * @param client
+     */
+    beforeSetup?(client: Client): void;
     /**
      * Set up an integration for the given client.
      * Receives the client as argument.

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, StreamedSpanJSON } from './span';
 import { StackLineParser, StackParser } from './stacktrace';
 import { TracePropagationTargets } from './tracing';
 import { BaseTransportOptions, Transport } from './transport';
@@ -450,6 +450,13 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
      * @default false
      */
     strictTraceContinuation?: boolean;
+    /**
+     * The trace lifecycle, determining whether spans are sent statically when the entire local span tree is complete,
+     * or streamed in batches, following interval- and action-based triggers.
+     *
+     * @default 'static'
+     */
+    traceLifecycle?: 'static' | 'stream';
     /**
      * The organization ID for your Sentry project.
      *
@@ -522,11 +529,16 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
     /**
      * This function can be defined to modify a child span before it's sent.
      *
+     * When using `traceLifecycle: 'stream'`, wrap your callback with {@link withStreamedSpan}
+     * to receive and return {@link StreamedSpanJSON} instead.
+     *
      * @param span The span generated by the SDK.
      *
      * @returns The modified span payload that will be sent.
      */
-    beforeSendSpan?: (span: SpanJSON) => SpanJSON;
+    beforeSendSpan?: ((span: SpanJSON) => SpanJSON) & {
+        _streamed?: true;
+    };
     /**
      * 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.
@@ -552,6 +564,18 @@ export interface ClientOptions<TO extends BaseTransportOptions = BaseTransportOp
      */
     beforeBreadcrumb?: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => Breadcrumb | null;
 }
+/**
+ * A callback for processing streamed spans before they are sent.
+ *
+ * @see {@link StreamedSpanJSON} for the streamed span format used with `traceLifecycle: 'stream'`
+ */
+export type BeforeSendStreamedSpanCallback = ((span: StreamedSpanJSON) => StreamedSpanJSON) & {
+    /**
+     * When true, indicates this callback is designed to handle the {@link StreamedSpanJSON} format
+     * used with `traceLifecycle: 'stream'`. Set this by wrapping your callback with `withStreamedSpan`.
+     */
+    _streamed?: 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 { Attributes, RawAttributes } from '../attributes';
 import { SpanLink, SpanLinkJSON } from './link';
 import { Measurements } from './measurement';
 import { HrTime } from './opentelemetry';
@@ -17,6 +18,40 @@ export type SpanAttributes = Partial<{
 }> & Record<string, SpanAttributeValue | undefined>;
 /** This type is aligned with the OpenTelemetry TimeInput type. */
 export type SpanTimeInput = HrTime | number | Date;
+/**
+ * Intermediate JSON reporesentation of a v2 span, which users and our SDK integrations will interact with.
+ * This is NOT the final serialized JSON span, but an intermediate step still holding raw attributes.
+ * The final, serialized span is a {@link SerializedStreamedSpan}.
+ * Main reason: Make it easier and safer for users to work with attributes.
+ */
+export interface StreamedSpanJSON {
+    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?: RawAttributes<Record<string, unknown>>;
+    links?: SpanLinkJSON<RawAttributes<Record<string, unknown>>>[];
+}
+/**
+ * Serialized span item.
+ * This is the final, serialized span format that is sent to Sentry.
+ * The intermediate representation is {@link StreamedSpanJSON}.
+ * Main difference: Attributes are converted to {@link Attributes}, thus including the `type` annotation.
+ */
+export type SerializedStreamedSpan = Pick<StreamedSpanJSON, Exclude<keyof StreamedSpanJSON, 'attributes' | 'links'>> & {
+    attributes?: Attributes;
+    links?: SpanLinkJSON<Attributes>[];
+};
+/**
+ * Envelope span item container.
+ */
+export type SerializedStreamedSpanContainer = {
+    items: Array<SerializedStreamedSpan>;
+};
 /** A JSON representation of a span. */
 export interface SpanJSON {
     data: SpanAttributes;

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

@@ -31,6 +31,16 @@ export declare function addNonEnumerableProperty(obj: object, name: string, valu
  * @param original the original function that gets wrapped
  */
 export declare function markFunctionWrapped(wrapped: WrappedFunction, original: WrappedFunction): void;
+/**
+ * Wrap a method on an object by name, only if it is not already wrapped.
+ *
+ * Note: to set the wrapped method as a non-enumerable property, pass
+ * false as the `enumerable` argument. This could be detected, but only
+ * by either walking up the prototype chain, or iterating over all fields
+ * in a `for(in)` loop. Neither are an acceptable performance impact for
+ * the rare case where we might patch a non-enumerable method.
+ */
+export declare function wrapMethod<O extends {}, T extends string & keyof O>(obj: O, field: T, wrapped: WrappedFunction, enumerable?: boolean): void;
 /**
  * This extracts the original function if available.  See
  * `markFunctionWrapped` for more information.

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

@@ -1,6 +1,7 @@
+import { RawAttributes } 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 { SerializedStreamedSpan, Span, SpanAttributes, SpanJSON, SpanTimeInput, StreamedSpanJSON } 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;
+/**
+ * Converts the span links array to a flattened version with serialized attributes for V2 spans.
+ *
+ * If the links array is empty, it returns `undefined` so the empty value can be dropped before it's sent.
+ */
+export declare function getStreamedSpanLinks(links?: SpanLink[]): SpanLinkJSON<RawAttributes<Record<string, unknown>>>[] | undefined;
 /**
  * Convert a span time input into a timestamp in seconds.
  */
@@ -36,6 +43,16 @@ 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 the intermediate {@link StreamedSpanJSON} representation.
+ */
+export declare function spanToStreamedSpanJSON(span: Span): StreamedSpanJSON;
+/**
+ * Converts a {@link StreamedSpanJSON} to a {@link SerializedSpan}.
+ * This is the final serialized span format that is sent to Sentry.
+ * The returned serilaized spans must not be consumed by users or SDK integrations.
+ */
+export declare function streamedSpanJsonToSerializedSpan(spanJson: StreamedSpanJSON): SerializedStreamedSpan;
 /** Exported only for tests. */
 export interface OpenTelemetrySdkTraceBaseSpan extends Span {
     attributes: SpanAttributes;
@@ -55,6 +72,10 @@ 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 simple onces expected by Sentry for steamed spans ('ok' is default).
+ */
+export declare function getSimpleStatusMessage(status: SpanStatus | undefined): 'ok' | 'error';
 declare const CHILD_SPANS_FIELD = "_sentryChildSpans";
 declare const ROOT_SPAN_FIELD = "_sentryRootSpan";
 type SpanWithPotentialChildren = Span & {
@@ -74,7 +95,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/build/types-ts3.8/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-ts3.8/utils/traceData.d.ts

@@ -10,6 +10,10 @@ import { SerializedTraceData } from '../types-hoist/tracing';
  * This function also applies some validation to the generated sentry-trace and baggage values to ensure that
  * only valid strings are returned.
  *
+ * When an external propagation context is registered (e.g. via the OTLP integration) and there is no active
+ * Sentry span, this function returns an empty object to defer outgoing request propagation to the external
+ * propagator (e.g. an OpenTelemetry propagator).
+ *
  * If (@param options.propagateTraceparent) is `true`, the function will also generate a `traceparent` value,
  * following the W3C traceparent header format.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/core",
-  "version": "10.46.0",
+  "version": "10.48.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",