@sentry/core 10.47.0 → 10.49.0

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/types-hoist/view-hierarchy.d.ts

@@ -13,6 +13,7 @@ export type ViewHierarchyWindow = {
 } & Record<string, string | number | boolean>;
 export type ViewHierarchyData = {
     rendering_system: string;
+    positioning?: 'absolute' | 'relative';
     windows: ViewHierarchyWindow[];
 };
 //# sourceMappingURL=view-hierarchy.d.ts.map

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

@@ -19,5 +19,5 @@ export declare function getLocationHref(): string;
  *
  * @returns a string representation of the component for the provided DOM element, or `null` if not found
  */
-export declare function getComponentName(elem: unknown): string | null;
+export declare function getComponentName(elem: unknown, maxTraverseHeight?: number): string | null;
 //# sourceMappingURL=browser.d.ts.map

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

@@ -0,0 +1,34 @@
+/**
+ * Interface representing a weak reference to an object.
+ * This matches the standard WeakRef interface but is defined here
+ * because WeakRef is not available in ES2020 type definitions.
+ */
+interface WeakRefLike<T extends object> {
+    deref(): T | undefined;
+}
+/**
+ * A wrapper type that represents either a WeakRef-like object or a direct reference.
+ * Used for optional weak referencing in environments where WeakRef may not be available.
+ */
+export type MaybeWeakRef<T extends object> = WeakRefLike<T> | T;
+/**
+ * Creates a weak reference to an object if WeakRef is available,
+ * otherwise returns the object directly.
+ *
+ * This is useful for breaking circular references while maintaining
+ * compatibility with environments that don't support WeakRef (e.g., older browsers).
+ *
+ * @param value - The object to create a weak reference to
+ * @returns A WeakRef wrapper if available, or the original object as fallback
+ */
+export declare function makeWeakRef<T extends object>(value: T): MaybeWeakRef<T>;
+/**
+ * Resolves a potentially weak reference, returning the underlying object
+ * or undefined if the reference has been garbage collected.
+ *
+ * @param ref - A MaybeWeakRef or undefined
+ * @returns The referenced object, or undefined if GC'd or ref was undefined
+ */
+export declare function derefWeakRef<T extends object>(ref: MaybeWeakRef<T> | undefined): T | undefined;
+export {};
+//# sourceMappingURL=weakRef.d.ts.map

package/package.json

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