@sentry/profiling-node 8.9.2 → 8.10.0

package/lib/types/core/src/tracing/spanstatus.d.ts

@@ -0,0 +1,17 @@
+import type { Span, SpanStatus } from '@sentry/types';
+export declare const SPAN_STATUS_UNSET = 0;
+export declare const SPAN_STATUS_OK = 1;
+export declare const SPAN_STATUS_ERROR = 2;
+/**
+ * Converts a HTTP status code into a sentry status with a message.
+ *
+ * @param httpStatus The HTTP response status code.
+ * @returns The span status or unknown_error.
+ */
+export declare function getSpanStatusFromHttpCode(httpStatus: number): SpanStatus;
+/**
+ * Sets the Http status attributes on the current span based on the http code.
+ * Additionally, the span's status is updated, depending on the http code.
+ */
+export declare function setHttpStatus(span: Span, httpStatus: number): void;
+//# sourceMappingURL=spanstatus.d.ts.map

package/lib/types/core/src/tracing/spanstatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spanstatus.d.ts","sourceRoot":"","sources":["../../../../../../core/src/tracing/spanstatus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEtD,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,cAAc,IAAI,CAAC;AAChC,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAEnC;;;;;GAKG;AAEH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAwCxE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAOlE"}

package/lib/types/core/src/tracing/trace.d.ts

@@ -0,0 +1,76 @@
+import type { Scope, Span, StartSpanOptions } from '@sentry/types';
+import { propagationContextFromHeaders } from '@sentry/utils';
+/**
+ * Wraps a function with a transaction/span and finishes the span after the function is done.
+ * The created span is the active span and will be used as parent by other spans created inside the function
+ * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.
+ *
+ * If you want to create a span that is not set as active, use {@link startInactiveSpan}.
+ *
+ * You'll always get a span passed to the callback,
+ * it may just be a non-recording span if the span is not sampled or if tracing is disabled.
+ */
+export declare function startSpan<T>(context: StartSpanOptions, callback: (span: Span) => T): T;
+/**
+ * Similar to `Sentry.startSpan`. Wraps a function with a transaction/span, but does not finish the span
+ * after the function is done automatically. You'll have to call `span.end()` manually.
+ *
+ * The created span is the active span and will be used as parent by other spans created inside the function
+ * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.
+ *
+ * You'll always get a span passed to the callback,
+ * it may just be a non-recording span if the span is not sampled or if tracing is disabled.
+ */
+export declare function startSpanManual<T>(context: StartSpanOptions, callback: (span: Span, finish: () => void) => T): T;
+/**
+ * Creates a span. This span is not set as active, so will not get automatic instrumentation spans
+ * as children or be able to be accessed via `Sentry.getActiveSpan()`.
+ *
+ * If you want to create a span that is set as active, use {@link startSpan}.
+ *
+ * This function will always return a span,
+ * it may just be a non-recording span if the span is not sampled or if tracing is disabled.
+ */
+export declare function startInactiveSpan(context: StartSpanOptions): Span;
+/**
+ * Continue a trace from `sentry-trace` and `baggage` values.
+ * These values can be obtained from incoming request headers, or in the browser from `<meta name="sentry-trace">`
+ * and `<meta name="baggage">` HTML tags.
+ *
+ * Spans started with `startSpan`, `startSpanManual` and `startInactiveSpan`, within the callback will automatically
+ * be attached to the incoming trace.
+ */
+export declare const continueTrace: <V>({ sentryTrace, baggage, }: {
+    sentryTrace: Parameters<typeof propagationContextFromHeaders>[0];
+    baggage: Parameters<typeof propagationContextFromHeaders>[1];
+}, callback: () => V) => V;
+/**
+ * Forks the current scope and sets the provided span as active span in the context of the provided callback. Can be
+ * passed `null` to start an entirely new span tree.
+ *
+ * @param span Spans started in the context of the provided callback will be children of this span. If `null` is passed,
+ * spans started within the callback will not be attached to a parent span.
+ * @param callback Execution context in which the provided span will be active. Is passed the newly forked scope.
+ * @returns the value returned from the provided callback function.
+ */
+export declare function withActiveSpan<T>(span: Span | null, callback: (scope: Scope) => T): T;
+/** Suppress tracing in the given callback, ensuring no spans are generated inside of it. */
+export declare function suppressTracing<T>(callback: () => T): T;
+/**
+ * Starts a new trace for the duration of the provided callback. Spans started within the
+ * callback will be part of the new trace instead of a potentially previously started trace.
+ *
+ * Important: Only use this function if you want to override the default trace lifetime and
+ * propagation mechanism of the SDK for the duration and scope of the provided callback.
+ * The newly created trace will also be the root of a new distributed trace, for example if
+ * you make http requests within the callback.
+ * This function might be useful if the operation you want to instrument should not be part
+ * of a potentially ongoing trace.
+ *
+ * Default behavior:
+ * - Server-side: A new trace is started for each incoming request.
+ * - Browser: A new trace is started for each page our route. Navigating to a new route
+ *            or page will automatically create a new trace.
+ */
+export declare function startNewTrace<T>(callback: () => T): T;
+//# sourceMappingURL=trace.d.ts.map

package/lib/types/core/src/tracing/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../../../../../core/src/tracing/trace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAiB,KAAK,EAAuB,IAAI,EAAiB,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtH,OAAO,EAAsC,6BAA6B,EAAE,MAAM,eAAe,CAAC;AAuBlG;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,CAAC,GAAG,CAAC,CAmCtF;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,IAAI,KAAK,CAAC,GAAG,CAAC,CAsChH;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAuBjE;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;iBAKT,WAAW,oCAAoC,CAAC,CAAC,CAAC,CAAC;aACvD,WAAW,oCAAoC,CAAC,CAAC,CAAC,CAAC;0BAS/D,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,CAAC,GAAG,CAAC,CAUrF;AAED,4FAA4F;AAC5F,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAWvD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAMrD"}

package/lib/types/core/src/tracing/utils.d.ts

@@ -0,0 +1,13 @@
+import type { Span } from '@sentry/types';
+import type { Scope } from '@sentry/types';
+export { stripUrlQueryAndFragment } from '@sentry/utils';
+/** Store the scope & isolation scope for a span, which can the be used when it is finished. */
+export declare function setCapturedScopesOnSpan(span: Span | undefined, scope: Scope, isolationScope: Scope): void;
+/**
+ * Grabs the scope and isolation scope off a span that were active when the span was started.
+ */
+export declare function getCapturedScopesOnSpan(span: Span): {
+    scope?: Scope;
+    isolationScope?: Scope;
+};
+//# sourceMappingURL=utils.d.ts.map

package/lib/types/core/src/tracing/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../core/src/tracing/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAI3C,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC;AAUzD,+FAA+F;AAC/F,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,cAAc,EAAE,KAAK,GAAG,IAAI,CAKzG;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG;IAAE,KAAK,CAAC,EAAE,KAAK,CAAC;IAAC,cAAc,CAAC,EAAE,KAAK,CAAA;CAAE,CAK7F"}

package/lib/types/core/src/utils/handleCallbackErrors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Wrap a callback function with error handling.
+ * If an error is thrown, it will be passed to the `onError` callback and re-thrown.
+ *
+ * If the return value of the function is a promise, it will be handled with `maybeHandlePromiseRejection`.
+ *
+ * If an `onFinally` callback is provided, this will be called when the callback has finished
+ * - so if it returns a promise, once the promise resolved/rejected,
+ * else once the callback has finished executing.
+ * The `onFinally` callback will _always_ be called, no matter if an error was thrown or not.
+ */
+export declare function handleCallbackErrors<Fn extends () => any>(fn: Fn, onError: (error: unknown) => void, onFinally?: () => void): ReturnType<Fn>;
+//# sourceMappingURL=handleCallbackErrors.d.ts.map

package/lib/types/core/src/utils/handleCallbackErrors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleCallbackErrors.d.ts","sourceRoot":"","sources":["../../../../../../core/src/utils/handleCallbackErrors.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAElC,EAAE,SAAS,MAAM,GAAG,EAEpB,EAAE,EAAE,EAAE,EACN,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,EAEjC,SAAS,GAAE,MAAM,IAAe,GAC/B,UAAU,CAAC,EAAE,CAAC,CAWhB"}

package/lib/types/core/src/utils/hasTracingEnabled.d.ts

@@ -0,0 +1,8 @@
+import type { Options } from '@sentry/types';
+/**
+ * Determines if tracing is currently enabled.
+ *
+ * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.
+ */
+export declare function hasTracingEnabled(maybeOptions?: Pick<Options, 'tracesSampleRate' | 'tracesSampler' | 'enableTracing'> | undefined): boolean;
+//# sourceMappingURL=hasTracingEnabled.d.ts.map

package/lib/types/core/src/utils/hasTracingEnabled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasTracingEnabled.d.ts","sourceRoot":"","sources":["../../../../../../core/src/utils/hasTracingEnabled.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAM7C;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,CAAC,EAAE,IAAI,CAAC,OAAO,EAAE,kBAAkB,GAAG,eAAe,GAAG,eAAe,CAAC,GAAG,SAAS,GAC/F,OAAO,CAOT"}

package/lib/types/core/src/utils/parseSampleRate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parse a sample rate from a given value.
+ * This will either return a boolean or number sample rate, if the sample rate is valid (between 0 and 1).
+ * If a string is passed, we try to convert it to a number.
+ *
+ * Any invalid sample rate will return `undefined`.
+ */
+export declare function parseSampleRate(sampleRate: unknown): number | undefined;
+//# sourceMappingURL=parseSampleRate.d.ts.map

package/lib/types/core/src/utils/parseSampleRate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseSampleRate.d.ts","sourceRoot":"","sources":["../../../../../../core/src/utils/parseSampleRate.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAiBvE"}

package/lib/types/core/src/utils/spanOnScope.d.ts

@@ -0,0 +1,17 @@
+import type { Scope, Span } from '@sentry/types';
+declare const SCOPE_SPAN_FIELD = "_sentrySpan";
+type ScopeWithMaybeSpan = Scope & {
+    [SCOPE_SPAN_FIELD]?: Span;
+};
+/**
+ * Set the active span for a given scope.
+ * NOTE: This should NOT be used directly, but is only used internally by the trace methods.
+ */
+export declare function _setSpanForScope(scope: Scope, span: Span | undefined): void;
+/**
+ * Get the active span for a given scope.
+ * NOTE: This should NOT be used directly, but is only used internally by the trace methods.
+ */
+export declare function _getSpanForScope(scope: ScopeWithMaybeSpan): Span | undefined;
+export {};
+//# sourceMappingURL=spanOnScope.d.ts.map

package/lib/types/core/src/utils/spanOnScope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spanOnScope.d.ts","sourceRoot":"","sources":["../../../../../../core/src/utils/spanOnScope.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAGjD,QAAA,MAAM,gBAAgB,gBAAgB,CAAC;AAEvC,KAAK,kBAAkB,GAAG,KAAK,GAAG;IAChC,CAAC,gBAAgB,CAAC,CAAC,EAAE,IAAI,CAAC;CAC3B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,IAAI,CAO3E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,CAE5E"}

package/lib/types/core/src/utils/spanUtils.d.ts

@@ -0,0 +1,74 @@
+import type { MeasurementUnit, Primitive, Span, SpanAttributes, SpanJSON, SpanStatus, SpanTimeInput, TraceContext } from '@sentry/types';
+import type { MetricType } from '../metrics/types';
+export declare const TRACE_FLAG_NONE = 0;
+export declare const TRACE_FLAG_SAMPLED = 1;
+/**
+ * Convert a span to a trace context, which can be sent as the `trace` context in an event.
+ * By default, this will only include trace_id, span_id & parent_span_id.
+ * If `includeAllData` is true, it will also include data, op, status & origin.
+ */
+export declare function spanToTransactionTraceContext(span: Span): TraceContext;
+/**
+ * Convert a span to a trace context, which can be sent as the `trace` context in a non-transaction event.
+ */
+export declare function spanToTraceContext(span: Span): TraceContext;
+/**
+ * Convert a Span to a Sentry trace header.
+ */
+export declare function spanToTraceHeader(span: Span): string;
+/**
+ * Convert a span time input intp a timestamp in seconds.
+ */
+export declare function spanTimeInputToSeconds(input: SpanTimeInput | undefined): number;
+/**
+ * Convert a span to a JSON representation.
+ */
+export declare function spanToJSON(span: Span): Partial<SpanJSON>;
+/** Exported only for tests. */
+export interface OpenTelemetrySdkTraceBaseSpan extends Span {
+    attributes: SpanAttributes;
+    startTime: SpanTimeInput;
+    name: string;
+    status: SpanStatus;
+    endTime: SpanTimeInput;
+    parentSpanId?: string;
+}
+/**
+ * Returns true if a span is sampled.
+ * In most cases, you should just use `span.isRecording()` instead.
+ * However, this has a slightly different semantic, as it also returns false if the span is finished.
+ * So in the case where this distinction is important, use this method.
+ */
+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;
+declare const CHILD_SPANS_FIELD = "_sentryChildSpans";
+declare const ROOT_SPAN_FIELD = "_sentryRootSpan";
+type SpanWithPotentialChildren = Span & {
+    [CHILD_SPANS_FIELD]?: Set<Span>;
+    [ROOT_SPAN_FIELD]?: Span;
+};
+/**
+ * Adds an opaque child span reference to a span.
+ */
+export declare function addChildSpanToSpan(span: SpanWithPotentialChildren, childSpan: Span): void;
+/** This is only used internally by Idle Spans. */
+export declare function removeChildSpanFromSpan(span: SpanWithPotentialChildren, childSpan: Span): void;
+/**
+ * Returns an array of the given span and all of its descendants.
+ */
+export declare function getSpanDescendants(span: SpanWithPotentialChildren): Span[];
+/**
+ * Returns the root span of a given span.
+ */
+export declare function getRootSpan(span: SpanWithPotentialChildren): Span;
+/**
+ * Returns the currently active span.
+ */
+export declare function getActiveSpan(): Span | undefined;
+/**
+ * Updates the metric summary on the currently active span
+ */
+export declare function updateMetricSummaryOnActiveSpan(metricType: MetricType, sanitizedName: string, value: number, unit: MeasurementUnit, tags: Record<string, Primitive>, bucketKey: string): void;
+export {};
+//# sourceMappingURL=spanUtils.d.ts.map

package/lib/types/core/src/utils/spanUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spanUtils.d.ts","sourceRoot":"","sources":["../../../../../../core/src/utils/spanUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,SAAS,EACT,IAAI,EACJ,cAAc,EACd,QAAQ,EAER,UAAU,EACV,aAAa,EACb,YAAY,EACb,MAAM,eAAe,CAAC;AAWvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAOnD,eAAO,MAAM,eAAe,IAAM,CAAC;AACnC,eAAO,MAAM,kBAAkB,IAAM,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,IAAI,GAAG,YAAY,CAatE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,YAAY,CAK3D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAIpD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,aAAa,GAAG,SAAS,GAAG,MAAM,CAe/E;AAUD;;GAEG;AAIH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,QAAQ,CAAC,CAoCxD;AAOD,+BAA+B;AAC/B,MAAM,WAAW,6BAA8B,SAAQ,IAAI;IACzD,UAAU,EAAE,cAAc,CAAC;IAC3B,SAAS,EAAE,aAAa,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,aAAa,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAUD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAKjD;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAUnF;AAED,QAAA,MAAM,iBAAiB,sBAAsB,CAAC;AAC9C,QAAA,MAAM,eAAe,oBAAoB,CAAC;AAE1C,KAAK,yBAAyB,GAAG,IAAI,GAAG;IACtC,CAAC,iBAAiB,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC,eAAe,CAAC,CAAC,EAAE,IAAI,CAAC;CAC1B,CAAC;AAEF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,yBAAyB,EAAE,SAAS,EAAE,IAAI,GAAG,IAAI,CAazF;AAED,kDAAkD;AAClD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,yBAAyB,EAAE,SAAS,EAAE,IAAI,GAAG,IAAI,CAI9F;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,yBAAyB,GAAG,IAAI,EAAE,CAoB1E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,yBAAyB,GAAG,IAAI,CAEjE;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,IAAI,GAAG,SAAS,CAQhD;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EAC/B,SAAS,EAAE,MAAM,GAChB,IAAI,CAKN"}

package/lib/types/profiling-node/src/cpu_profiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpu_profiler.d.ts","sourceRoot":"","sources":["../../../../src/cpu_profiler.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EACV,4BAA4B,EAC5B,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAU7C;;GAEG;AAEH,wBAAgB,uBAAuB,IAAI,4BAA4B,CA+HtE;AAED,QAAA,MAAM,0BAA0B,EAAE,4BAAwD,CAAC;AAE3F,cAAM,QAAS,YAAW,qBAAqB;IACtC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IASlC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,mBAAmB,GAAG,IAAI;IACrF,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,KAAK,GAAG,kBAAkB,GAAG,IAAI;CAkB3F;AAED,QAAA,MAAM,mBAAmB,UAAiB,CAAC;AAE3C,OAAO,EAAE,0BAA0B,EAAE,CAAC;AACtC,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/lib/types/profiling-node/src/debug-build.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.
+ *
+ * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.
+ */
+export declare const DEBUG_BUILD: boolean;
+//# sourceMappingURL=debug-build.d.ts.map

package/lib/types/profiling-node/src/debug-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-build.d.ts","sourceRoot":"","sources":["../../../../src/debug-build.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,WAAW,SAAkB,CAAC"}

package/lib/types/profiling-node/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,eAAe,CAAC"}

package/lib/types/{integration.d.ts → profiling-node/src/integration.d.ts}

@@ -27,15 +27,33 @@ declare class ContinuousProfiler {
      * @param chunk
      */
     private _flush;
+    /**
+     * Stops the profile and clears chunk instrumentation from global scope
+     * @returns void
+     */
+    private _stopChunkProfiling;
     /**
      * Starts the profiler and registers the flush timer for a given chunk.
      * @param chunk
      */
     private _startChunkProfiling;
+    /**
+     * Attaches profiling information to spans that were started
+     * during a profiling session.
+     */
+    private _setupSpanChunkInstrumentation;
+    /**
+     * Clear profiling information from global context when a profile is not running.
+     */
+    private _teardownSpanChunkInstrumentation;
     /**
      * Initializes new profile chunk metadata
      */
     private _initializeChunk;
+    /**
+     * Assigns thread_id and thread name context to a profiled event.
+     */
+    private _assignThreadIdContext;
     /**
      * Resets the current chunk state.
      */

package/lib/types/profiling-node/src/integration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integration.d.ts","sourceRoot":"","sources":["../../../../src/integration.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAS,WAAW,EAA8C,MAAM,eAAe,CAAC;AAuJpG,cAAM,kBAAkB;IACtB,OAAO,CAAC,WAAW,CAAW;IAC9B,OAAO,CAAC,OAAO,CAAqC;IACpD,OAAO,CAAC,UAAU,CAAoC;IAEtD;;;;OAIG;IACI,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAI3C;;;;;OAKG;IACI,KAAK,IAAI,IAAI;IAsBpB;;;OAGG;IACI,IAAI,IAAI,IAAI;IAgDnB;;;OAGG;IACH,OAAO,CAAC,MAAM;IAuBd;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAK3B;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAgB5B;;;OAGG;IACH,OAAO,CAAC,8BAA8B;IActC;;OAEG;IACH,OAAO,CAAC,iCAAiC;IAKzC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAQxB;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAqB9B;;OAEG;IACH,OAAO,CAAC,MAAM;CAGf;AAED,MAAM,WAAW,oBAAqB,SAAQ,WAAW;IACvD,SAAS,EAAE,kBAAkB,CAAC;CAC/B;AAED,+BAA+B;AAC/B,eAAO,MAAM,yBAAyB,QAAQ,oBAwCpB,CAAC;AAE3B;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,mBAA+C,CAAC"}

package/lib/types/profiling-node/src/nodeVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodeVersion.d.ts","sourceRoot":"","sources":["../../../../src/nodeVersion.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;WAAkD,MAAM;WAAS,MAAM;WAAS,MAAM;CAAE,CAAC;AAClH,eAAO,MAAM,UAAU,QAAqB,CAAC"}

package/lib/types/profiling-node/src/spanProfileUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spanProfileUtils.d.ts","sourceRoot":"","sources":["../../../../src/spanProfileUtils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAKjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAGnD,eAAO,MAAM,uBAAuB,QAAY,CAAC;AAEjD;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,UAAU,GAAG,SAAS,EAC9B,IAAI,EAAE,IAAI,EACV,qBAAqB,CAAC,EAAE,qBAAqB,GAC5C,MAAM,GAAG,SAAS,CAkFpB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,GAAG,mBAAmB,GAAG,IAAI,CAsBtG"}

package/lib/types/profiling-node/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE3C,UAAU,MAAM;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAED,UAAU,WAAW;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,KAAK,KAAK,GAAG;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE;QACN,sBAAsB,EAAE,MAAM,CAAC;QAC/B,KAAK,EAAE,MAAM,CAAC;KACf,EAAE,CAAC;CACL;AAID,MAAM,WAAW,aAAc,SAAQ,KAAK;IAC1C,qBAAqB,EAAE;QACrB,OAAO,CAAC,EAAE,mBAAmB,CAAC;KAC/B,CAAC;CACH;AAED,UAAU,WAAW;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,qBAAqB,EAAE,OAAO,GAAG,MAAM,CAAC;IACxC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;CAC3C;AACD,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,4BAA4B;IAC3C,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAEnC,aAAa,CACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,CAAC,MAAM,EAC5B,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,OAAO,GACxB,mBAAmB,GAAG,IAAI,CAAC;IAC9B,aAAa,CACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,aAAa,CAAC,KAAK,EAC3B,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,OAAO,GACxB,kBAAkB,GAAG,IAAI,CAAC;IAG7B,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1C;AAED,oBAAY,aAAa;IACvB,MAAM,IAAI;IACV,KAAK,IAAI;CACV;AAED,MAAM,WAAW,qBAAqB;IACpC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAEnC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,MAAM,GAAG,mBAAmB,GAAG,IAAI,CAAC;IACtF,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,KAAK,GAAG,kBAAkB,GAAG,IAAI,CAAC;CACrF"}

package/lib/types/{utils.d.ts → profiling-node/src/utils.d.ts}

@@ -1,5 +1,7 @@
 import type { Client, ContinuousThreadCpuProfile, DebugImage, DsnComponents, Envelope, Event, EventEnvelopeHeaders, Profile, ProfileChunk, ProfileChunkEnvelope, SdkInfo, ThreadCpuProfile } from '@sentry/types';
 import type { RawChunkCpuProfile, RawThreadCpuProfile } from './types';
+export declare const PROFILER_THREAD_ID_STRING: string;
+export declare const PROFILER_THREAD_NAME: string;
 /**
  * Enriches the profile with threadId of the current thread.
  * This is done in node as we seem to not be able to get the info from C native code.
@@ -18,7 +20,7 @@ export declare function createProfilingEvent(client: Client, profile: RawThreadC
 /**
  * Creates a profiling chunk envelope item, if the profile does not pass validation, returns null.
  */
-export declare function createProfilingChunkEvent(start_timestamp: number, client: Client, options: {
+export declare function createProfilingChunkEvent(client: Client, options: {
     release?: string;
     environment?: string;
 }, profile: RawChunkCpuProfile, identifiers: {

package/lib/types/profiling-node/src/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,MAAM,EAEN,0BAA0B,EAC1B,UAAU,EACV,aAAa,EACb,QAAQ,EACR,KAAK,EACL,oBAAoB,EACpB,OAAO,EACP,YAAY,EACZ,oBAAoB,EAEpB,OAAO,EAGP,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAOvB,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAIvE,eAAO,MAAM,yBAAyB,QAAmB,CAAC;AAC1D,eAAO,MAAM,oBAAoB,QAAmC,CAAC;AA2BrE;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,gBAAgB,GAAG,mBAAmB,GAAG,0BAA0B,GAAG,kBAAkB,GAChG,gBAAgB,GAAG,0BAA0B,CAe/C;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,GAAG,IAAI,CAc/G;AA8HD;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,EACnD,OAAO,EAAE,kBAAkB,EAC3B,WAAW,EAAE;IAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACnF,YAAY,GAAG,IAAI,CAYrB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAuBxD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,IAAI,mBAAmB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAepH;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,IAAI,kBAAkB,CAW9F;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,QAAQ,CAUvF;AAED;;;;GAIG;AACH,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,EAAE,CA2BhF;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,GAAG,CAAC,EAAE,aAAa,GAClB,oBAAoB,CAOtB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,GAAG,CAAC,EAAE,aAAa,GAClB,oBAAoB,CAQtB;AAID;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,UAAU,EAAE,CA0DtG"}

package/lib/types-ts3.8/core/src/asyncContext/index.d.ts

@@ -0,0 +1,14 @@
+import { Carrier } from './../carrier';
+import { AsyncContextStrategy } from './types';
+/**
+ * @private Private API with no semver guarantees!
+ *
+ * Sets the global async context strategy
+ */
+export declare function setAsyncContextStrategy(strategy: AsyncContextStrategy | undefined): void;
+/**
+ * Get the current async context strategy.
+ * If none has been setup, the default will be used.
+ */
+export declare function getAsyncContextStrategy(carrier: Carrier): AsyncContextStrategy;
+//# sourceMappingURL=index.d.ts.map

package/lib/types-ts3.8/core/src/asyncContext/stackStrategy.d.ts

@@ -0,0 +1,52 @@
+import { Client, Scope as ScopeInterface } from '@sentry/types';
+import { AsyncContextStrategy } from './types';
+interface Layer {
+    client?: Client;
+    scope: ScopeInterface;
+}
+/**
+ * This is an object that holds a stack of scopes.
+ */
+export declare class AsyncContextStack {
+    private readonly _stack;
+    private _isolationScope;
+    constructor(scope?: ScopeInterface, isolationScope?: ScopeInterface);
+    /**
+     * Fork a scope for the stack.
+     */
+    withScope<T>(callback: (scope: ScopeInterface) => T): T;
+    /**
+     * Get the client of the stack.
+     */
+    getClient<C extends Client>(): C | undefined;
+    /**
+     * Returns the scope of the top stack.
+     */
+    getScope(): ScopeInterface;
+    /**
+     * Get the isolation scope for the stack.
+     */
+    getIsolationScope(): ScopeInterface;
+    /**
+     * Returns the scope stack for domains or the process.
+     */
+    getStack(): Layer[];
+    /**
+     * Returns the topmost scope layer in the order domain > local > process.
+     */
+    getStackTop(): Layer;
+    /**
+     * Push a scope to the stack.
+     */
+    private _pushScope;
+    /**
+     * Pop a scope from the stack.
+     */
+    private _popScope;
+}
+/**
+ * Get the stack-based async context strategy.
+ */
+export declare function getStackAsyncContextStrategy(): AsyncContextStrategy;
+export {};
+//# sourceMappingURL=stackStrategy.d.ts.map

package/lib/types-ts3.8/core/src/asyncContext/types.d.ts

@@ -0,0 +1,47 @@
+import { Scope } from '@sentry/types';
+import { startInactiveSpan, startSpan, startSpanManual, suppressTracing, withActiveSpan } from './../tracing/trace';
+import { getActiveSpan } from './../utils/spanUtils';
+/**
+ * @private Private API with no semver guarantees!
+ *
+ * Strategy used to track async context.
+ */
+export interface AsyncContextStrategy {
+    /**
+     * Fork the isolation scope inside of the provided callback.
+     */
+    withIsolationScope: <T>(callback: (isolationScope: Scope) => T) => T;
+    /**
+     * Fork the current scope inside of the provided callback.
+     */
+    withScope: <T>(callback: (isolationScope: Scope) => T) => T;
+    /**
+     * Set the provided scope as the current scope inside of the provided callback.
+     */
+    withSetScope: <T>(scope: Scope, callback: (scope: Scope) => T) => T;
+    /**
+     * Set the provided isolation as the current isolation scope inside of the provided callback.
+     */
+    withSetIsolationScope: <T>(isolationScope: Scope, callback: (isolationScope: Scope) => T) => T;
+    /**
+     * Get the currently active scope.
+     */
+    getCurrentScope: () => Scope;
+    /**
+     * Get the currently active isolation scope.
+     */
+    getIsolationScope: () => Scope;
+    /** Start an active span. */
+    startSpan?: typeof startSpan;
+    /** Start an inactive span. */
+    startInactiveSpan?: typeof startInactiveSpan;
+    /** Start an active manual span. */
+    startSpanManual?: typeof startSpanManual;
+    /** Get the currently active span. */
+    getActiveSpan?: typeof getActiveSpan;
+    /** Make a span the active span in the context of the callback. */
+    withActiveSpan?: typeof withActiveSpan;
+    /** Suppress tracing in the given callback, ensuring no spans are generated inside of it.  */
+    suppressTracing?: typeof suppressTracing;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types-ts3.8/core/src/carrier.d.ts

@@ -0,0 +1,37 @@
+import { Client, Integration, MetricsAggregator, Scope } from '@sentry/types';
+import { AsyncContextStack } from './asyncContext/stackStrategy';
+import { AsyncContextStrategy } from './asyncContext/types';
+/**
+ * An object that contains globally accessible properties and maintains a scope stack.
+ * @hidden
+ */
+export interface Carrier {
+    __SENTRY__?: VersionedCarrier;
+}
+type VersionedCarrier = {
+    version?: string;
+} & Record<Exclude<string, 'version'>, SentryCarrier>;
+interface SentryCarrier {
+    acs?: AsyncContextStrategy;
+    stack?: AsyncContextStack;
+    globalScope?: Scope;
+    defaultIsolationScope?: Scope;
+    defaultCurrentScope?: Scope;
+    globalMetricsAggregators?: WeakMap<Client, MetricsAggregator> | undefined;
+    integrations?: Integration[];
+    extensions?: {
+        [key: string]: Function;
+    };
+}
+/**
+ * Returns the global shim registry.
+ *
+ * FIXME: This function is problematic, because despite always returning a valid Carrier,
+ * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check
+ * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.
+ **/
+export declare function getMainCarrier(): Carrier;
+/** Will either get the existing sentry carrier, or create a new one. */
+export declare function getSentryCarrier(carrier: Carrier): SentryCarrier;
+export {};
+//# sourceMappingURL=carrier.d.ts.map

package/lib/types-ts3.8/core/src/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ENVIRONMENT = "production";
+//# sourceMappingURL=constants.d.ts.map

package/lib/types-ts3.8/core/src/currentScopes.d.ts

@@ -0,0 +1,55 @@
+import { Scope } from '@sentry/types';
+import { Client } from '@sentry/types';
+/**
+ * Get the currently active scope.
+ */
+export declare function getCurrentScope(): Scope;
+/**
+ * Get the currently active isolation scope.
+ * The isolation scope is active for the current exection context.
+ */
+export declare function getIsolationScope(): Scope;
+/**
+ * Get the global scope.
+ * This scope is applied to _all_ events.
+ */
+export declare function getGlobalScope(): Scope;
+/**
+ * Creates a new scope with and executes the given operation within.
+ * The scope is automatically removed once the operation
+ * finishes or throws.
+ */
+export declare function withScope<T>(callback: (scope: Scope) => T): T;
+/**
+ * Set the given scope as the active scope in the callback.
+ */
+export declare function withScope<T>(scope: Scope | undefined, callback: (scope: Scope) => T): T;
+/**
+ * Attempts to fork the current isolation scope and the current scope based on the current async context strategy. If no
+ * async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the
+ * case, for example, in the browser).
+ *
+ * Usage of this function in environments without async context strategy is discouraged and may lead to unexpected behaviour.
+ *
+ * This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in "normal"
+ * applications directly because it comes with pitfalls. Use at your own risk!
+ */
+export declare function withIsolationScope<T>(callback: (isolationScope: Scope) => T): T;
+/**
+ * Set the provided isolation scope as active in the given callback. If no
+ * async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the
+ * case, for example, in the browser).
+ *
+ * Usage of this function in environments without async context strategy is discouraged and may lead to unexpected behaviour.
+ *
+ * This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in "normal"
+ * applications directly because it comes with pitfalls. Use at your own risk!
+ *
+ * If you pass in `undefined` as a scope, it will fork a new isolation scope, the same as if no scope is passed.
+ */
+export declare function withIsolationScope<T>(isolationScope: Scope | undefined, callback: (isolationScope: Scope) => T): T;
+/**
+ * Get the currently active client.
+ */
+export declare function getClient<C extends Client>(): C | undefined;
+//# sourceMappingURL=currentScopes.d.ts.map

package/lib/types-ts3.8/core/src/defaultScopes.d.ts

@@ -0,0 +1,6 @@
+import { Scope } from '@sentry/types';
+/** Get the default current scope. */
+export declare function getDefaultCurrentScope(): Scope;
+/** Get the default isolation scope. */
+export declare function getDefaultIsolationScope(): Scope;
+//# sourceMappingURL=defaultScopes.d.ts.map

package/lib/types-ts3.8/core/src/envelope.d.ts

@@ -0,0 +1,18 @@
+import { Client, DsnComponents, Event, EventEnvelope, SdkMetadata, Session, SessionAggregates, SessionEnvelope, SpanEnvelope } from '@sentry/types';
+import { SentrySpan } from './tracing/sentrySpan';
+/** Creates an envelope from a Session */
+export declare function createSessionEnvelope(session: Session | SessionAggregates, dsn?: DsnComponents, metadata?: SdkMetadata, tunnel?: string): SessionEnvelope;
+/**
+ * Create an Envelope from an event.
+ */
+export declare function createEventEnvelope(event: Event, dsn?: DsnComponents, metadata?: SdkMetadata, tunnel?: string): EventEnvelope;
+/**
+ * Create envelope from Span item.
+ *
+ * Takes an optional client and runs spans through `beforeSendSpan` if available.
+ */
+export declare function createSpanEnvelope(spans: [
+    SentrySpan,
+    ...SentrySpan[]
+], client?: Client): SpanEnvelope;
+//# sourceMappingURL=envelope.d.ts.map

package/lib/types-ts3.8/core/src/metrics/constants.d.ts

@@ -0,0 +1,19 @@
+export declare const COUNTER_METRIC_TYPE: "c";
+export declare const GAUGE_METRIC_TYPE: "g";
+export declare const SET_METRIC_TYPE: "s";
+export declare const DISTRIBUTION_METRIC_TYPE: "d";
+/**
+ * This does not match spec in https://develop.sentry.dev/sdk/metrics
+ * but was chosen to optimize for the most common case in browser environments.
+ */
+export declare const DEFAULT_BROWSER_FLUSH_INTERVAL = 5000;
+/**
+ * SDKs are required to bucket into 10 second intervals (rollup in seconds)
+ * which is the current lower bound of metric accuracy.
+ */
+export declare const DEFAULT_FLUSH_INTERVAL = 10000;
+/**
+ * The maximum number of metrics that should be stored in memory.
+ */
+export declare const MAX_WEIGHT = 10000;
+//# sourceMappingURL=constants.d.ts.map