@sentry/profiling-node 8.9.2 → 8.10.0

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

@@ -0,0 +1,13 @@
+import { MeasurementUnit, Span } from '@sentry/types';
+import { MetricSummary } from '@sentry/types';
+import { Primitive } from '@sentry/types';
+import { MetricType } from './types';
+/**
+ * Fetches the metric summary if it exists for the passed span
+ */
+export declare function getMetricSummaryJsonForSpan(span: Span): Record<string, Array<MetricSummary>> | undefined;
+/**
+ * Updates the metric summary on a span.
+ */
+export declare function updateMetricSummaryOnSpan(span: Span, metricType: MetricType, sanitizedName: string, value: number, unit: MeasurementUnit, tags: Record<string, Primitive>, bucketKey: string): void;
+//# sourceMappingURL=metric-summary.d.ts.map

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

@@ -0,0 +1,5 @@
+import { MetricBucketItem } from '@sentry/types';
+import { COUNTER_METRIC_TYPE, DISTRIBUTION_METRIC_TYPE, GAUGE_METRIC_TYPE, SET_METRIC_TYPE } from './constants';
+export type MetricType = typeof COUNTER_METRIC_TYPE | typeof GAUGE_METRIC_TYPE | typeof SET_METRIC_TYPE | typeof DISTRIBUTION_METRIC_TYPE;
+export type MetricBucket = Map<string, MetricBucketItem>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,211 @@
+import { Attachment, Breadcrumb, CaptureContext, Client, Context, Contexts, Event, EventHint, EventProcessor, Extra, Extras, Primitive, PropagationContext, RequestSession, Scope as ScopeInterface, ScopeData, Session, SeverityLevel, User } from '@sentry/types';
+/**
+ * Holds additional event information.
+ */
+declare class ScopeClass implements ScopeInterface {
+    /** Flag if notifying is happening. */
+    protected _notifyingListeners: boolean;
+    /** Callback for client to receive scope changes. */
+    protected _scopeListeners: Array<(scope: Scope) => void>;
+    /** Callback list that will be called during event processing. */
+    protected _eventProcessors: EventProcessor[];
+    /** Array of breadcrumbs. */
+    protected _breadcrumbs: Breadcrumb[];
+    /** User */
+    protected _user: User;
+    /** Tags */
+    protected _tags: {
+        [key: string]: Primitive;
+    };
+    /** Extra */
+    protected _extra: Extras;
+    /** Contexts */
+    protected _contexts: Contexts;
+    /** Attachments */
+    protected _attachments: Attachment[];
+    /** Propagation Context for distributed tracing */
+    protected _propagationContext: PropagationContext;
+    /**
+     * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
+     * sent to Sentry
+     */
+    protected _sdkProcessingMetadata: {
+        [key: string]: unknown;
+    };
+    /** Fingerprint */
+    protected _fingerprint?: string[];
+    /** Severity */
+    protected _level?: SeverityLevel;
+    /**
+     * Transaction Name
+     *
+     * IMPORTANT: The transaction name on the scope has nothing to do with root spans/transaction objects.
+     * It's purpose is to assign a transaction to the scope that's added to non-transaction events.
+     */
+    protected _transactionName?: string;
+    /** Session */
+    protected _session?: Session;
+    /** Request Mode Session Status */
+    protected _requestSession?: RequestSession;
+    /** The client on this scope */
+    protected _client?: Client;
+    /** Contains the last event id of a captured event.  */
+    protected _lastEventId?: string;
+    constructor();
+    /**
+     * @inheritDoc
+     */
+    clone(): ScopeClass;
+    /**
+     * @inheritDoc
+     */
+    setClient(client: Client | undefined): void;
+    /**
+     * @inheritDoc
+     */
+    setLastEventId(lastEventId: string | undefined): void;
+    /**
+     * @inheritDoc
+     */
+    getClient<C extends Client>(): C | undefined;
+    /**
+     * @inheritDoc
+     */
+    lastEventId(): string | undefined;
+    /**
+     * @inheritDoc
+     */
+    addScopeListener(callback: (scope: Scope) => void): void;
+    /**
+     * @inheritDoc
+     */
+    addEventProcessor(callback: EventProcessor): this;
+    /**
+     * @inheritDoc
+     */
+    setUser(user: User | null): this;
+    /**
+     * @inheritDoc
+     */
+    getUser(): User | undefined;
+    /**
+     * @inheritDoc
+     */
+    getRequestSession(): RequestSession | undefined;
+    /**
+     * @inheritDoc
+     */
+    setRequestSession(requestSession?: RequestSession): this;
+    /**
+     * @inheritDoc
+     */
+    setTags(tags: {
+        [key: string]: Primitive;
+    }): this;
+    /**
+     * @inheritDoc
+     */
+    setTag(key: string, value: Primitive): this;
+    /**
+     * @inheritDoc
+     */
+    setExtras(extras: Extras): this;
+    /**
+     * @inheritDoc
+     */
+    setExtra(key: string, extra: Extra): this;
+    /**
+     * @inheritDoc
+     */
+    setFingerprint(fingerprint: string[]): this;
+    /**
+     * @inheritDoc
+     */
+    setLevel(level: SeverityLevel): this;
+    /**
+     * @inheritDoc
+     */
+    setTransactionName(name?: string): this;
+    /**
+     * @inheritDoc
+     */
+    setContext(key: string, context: Context | null): this;
+    /**
+     * @inheritDoc
+     */
+    setSession(session?: Session): this;
+    /**
+     * @inheritDoc
+     */
+    getSession(): Session | undefined;
+    /**
+     * @inheritDoc
+     */
+    update(captureContext?: CaptureContext): this;
+    /**
+     * @inheritDoc
+     */
+    clear(): this;
+    /**
+     * @inheritDoc
+     */
+    addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): this;
+    /**
+     * @inheritDoc
+     */
+    getLastBreadcrumb(): Breadcrumb | undefined;
+    /**
+     * @inheritDoc
+     */
+    clearBreadcrumbs(): this;
+    /**
+     * @inheritDoc
+     */
+    addAttachment(attachment: Attachment): this;
+    /**
+     * @inheritDoc
+     */
+    clearAttachments(): this;
+    /** @inheritDoc */
+    getScopeData(): ScopeData;
+    /**
+     * @inheritDoc
+     */
+    setSDKProcessingMetadata(newData: {
+        [key: string]: unknown;
+    }): this;
+    /**
+     * @inheritDoc
+     */
+    setPropagationContext(context: PropagationContext): this;
+    /**
+     * @inheritDoc
+     */
+    getPropagationContext(): PropagationContext;
+    /**
+     * @inheritDoc
+     */
+    captureException(exception: unknown, hint?: EventHint): string;
+    /**
+     * @inheritDoc
+     */
+    captureMessage(message: string, level?: SeverityLevel, hint?: EventHint): string;
+    /**
+     * @inheritDoc
+     */
+    captureEvent(event: Event, hint?: EventHint): string;
+    /**
+     * This will be called on every set call.
+     */
+    protected _notifyScopeListeners(): void;
+}
+/**
+ * Holds additional event information.
+ */
+export declare const Scope: typeof ScopeClass;
+/**
+ * Holds additional event information.
+ */
+export type Scope = ScopeInterface;
+export {};
+//# sourceMappingURL=scope.d.ts.map

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

@@ -0,0 +1,33 @@
+/**
+ * Use this attribute to represent the source of a span.
+ * Should be one of: custom, url, route, view, component, task, unknown
+ *
+ */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = "sentry.source";
+/**
+ * Use this attribute to represent the sample rate used for a span.
+ */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE = "sentry.sample_rate";
+/**
+ * Use this attribute to represent the operation of a span.
+ */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_OP = "sentry.op";
+/**
+ * Use this attribute to represent the origin of a span.
+ */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = "sentry.origin";
+/** The reason why an idle span finished. */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON = "sentry.idle_span_finish_reason";
+/** The unit of a measurement, which may be stored as a TimedEvent. */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT = "sentry.measurement_unit";
+/** The value of a measurement, which may be stored as a TimedEvent. */
+export declare const SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE = "sentry.measurement_value";
+/**
+ * The id of the profile that this span occured in.
+ */
+export declare const SEMANTIC_ATTRIBUTE_PROFILE_ID = "sentry.profile_id";
+export declare const SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME = "sentry.exclusive_time";
+export declare const SEMANTIC_ATTRIBUTE_CACHE_HIT = "cache.hit";
+export declare const SEMANTIC_ATTRIBUTE_CACHE_KEY = "cache.key";
+export declare const SEMANTIC_ATTRIBUTE_CACHE_ITEM_SIZE = "cache.item_size";
+//# sourceMappingURL=semanticAttributes.d.ts.map

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

@@ -0,0 +1,35 @@
+import { Session, SessionContext, SessionStatus } from '@sentry/types';
+/**
+ * Creates a new `Session` object by setting certain default parameters. If optional @param context
+ * is passed, the passed properties are applied to the session object.
+ *
+ * @param context (optional) additional properties to be applied to the returned session object
+ *
+ * @returns a new `Session` object
+ */
+export declare function makeSession(context?: Pick<SessionContext, Exclude<keyof SessionContext, 'started' | 'status'>>): Session;
+/**
+ * Updates a session object with the properties passed in the context.
+ *
+ * Note that this function mutates the passed object and returns void.
+ * (Had to do this instead of returning a new and updated session because closing and sending a session
+ * makes an update to the session after it was passed to the sending logic.
+ * @see BaseClient.captureSession )
+ *
+ * @param session the `Session` to update
+ * @param context the `SessionContext` holding the properties that should be updated in @param session
+ */
+export declare function updateSession(session: Session, context?: SessionContext): void;
+/**
+ * Closes a session by setting its status and updating the session object with it.
+ * Internally calls `updateSession` to update the passed session object.
+ *
+ * Note that this function mutates the passed session (@see updateSession for explanation).
+ *
+ * @param session the `Session` object to be closed
+ * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,
+ *               this function will keep the previously set status, unless it was `'ok'` in which case
+ *               it is changed to `'exited'`.
+ */
+export declare function closeSession(session: Session, status?: Exclude<SessionStatus, 'ok'>): void;
+//# sourceMappingURL=session.d.ts.map

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

@@ -0,0 +1,24 @@
+import { Client, DynamicSamplingContext, Span } from '@sentry/types';
+/**
+ * Freeze the given DSC on the given span.
+ */
+export declare function freezeDscOnSpan(span: Span, dsc: Partial<DynamicSamplingContext>): void;
+/**
+ * Creates a dynamic sampling context from a client.
+ *
+ * Dispatches the `createDsc` lifecycle hook as a side effect.
+ */
+export declare function getDynamicSamplingContextFromClient(trace_id: string, client: Client): DynamicSamplingContext;
+/**
+ * Creates a dynamic sampling context from a span (and client and scope)
+ *
+ * @param span the span from which a few values like the root span name and sample rate are extracted.
+ *
+ * @returns a dynamic sampling context
+ */
+export declare function getDynamicSamplingContextFromSpan(span: Span): Readonly<Partial<DynamicSamplingContext>>;
+/**
+ * Convert a Span to a baggage header.
+ */
+export declare function spanToBaggageHeader(span: Span): string | undefined;
+//# sourceMappingURL=dynamicSamplingContext.d.ts.map

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

@@ -0,0 +1,10 @@
+import { Span } from '@sentry/types';
+/**
+ * Print a log message for a started span.
+ */
+export declare function logSpanStart(span: Span): void;
+/**
+ * Print a log message for an ended span.
+ */
+export declare function logSpanEnd(span: Span): void;
+//# sourceMappingURL=logSpans.d.ts.map

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

@@ -0,0 +1,10 @@
+import { MeasurementUnit, Measurements, TimedEvent } from '@sentry/types';
+/**
+ * Adds a measurement to the current active transaction.
+ */
+export declare function setMeasurement(name: string, value: number, unit: MeasurementUnit): void;
+/**
+ * Convert timed events to measurements.
+ */
+export declare function timedEventsToMeasurements(events: TimedEvent[]): Measurements | undefined;
+//# sourceMappingURL=measurement.d.ts.map

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

@@ -0,0 +1,12 @@
+import { Options, SamplingContext } from '@sentry/types';
+/**
+ * Makes a sampling decision for the given options.
+ *
+ * Called every time a root span is created. Only root spans which emerge with a `sampled` value of `true` will be
+ * sent to Sentry.
+ */
+export declare function sampleSpan(options: Pick<Options, 'tracesSampleRate' | 'tracesSampler' | 'enableTracing'>, samplingContext: SamplingContext): [
+    /*sampled*/ boolean,
+    /*sampleRate*/ number
+];
+//# sourceMappingURL=sampling.d.ts.map

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

@@ -0,0 +1,26 @@
+import { SentrySpanArguments, Span, SpanAttributeValue, SpanAttributes, SpanContextData, SpanStatus, SpanTimeInput } from '@sentry/types';
+/**
+ * A Sentry Span that is non-recording, meaning it will not be sent to Sentry.
+ */
+export declare class SentryNonRecordingSpan implements Span {
+    private _traceId;
+    private _spanId;
+    constructor(spanContext?: SentrySpanArguments);
+    /** @inheritdoc */
+    spanContext(): SpanContextData;
+    /** @inheritdoc */
+    end(_timestamp?: SpanTimeInput): void;
+    /** @inheritdoc */
+    setAttribute(_key: string, _value: SpanAttributeValue | undefined): this;
+    /** @inheritdoc */
+    setAttributes(_values: SpanAttributes): this;
+    /** @inheritdoc */
+    setStatus(_status: SpanStatus): this;
+    /** @inheritdoc */
+    updateName(_name: string): this;
+    /** @inheritdoc */
+    isRecording(): boolean;
+    /** @inheritdoc */
+    addEvent(_name: string, _attributesOrStartTime?: SpanAttributes | SpanTimeInput, _startTime?: SpanTimeInput): this;
+}
+//# sourceMappingURL=sentryNonRecordingSpan.d.ts.map

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

@@ -0,0 +1,86 @@
+import { SentrySpanArguments, Span, SpanAttributeValue, SpanAttributes, SpanContextData, SpanJSON, SpanStatus, SpanTimeInput, TimedEvent } from '@sentry/types';
+/**
+ * Span contains all data about a span
+ */
+export declare class SentrySpan implements Span {
+    protected _traceId: string;
+    protected _spanId: string;
+    protected _parentSpanId?: string | undefined;
+    protected _sampled: boolean | undefined;
+    protected _name?: string | undefined;
+    protected _attributes: SpanAttributes;
+    /** Epoch timestamp in seconds when the span started. */
+    protected _startTime: number;
+    /** Epoch timestamp in seconds when the span ended. */
+    protected _endTime?: number | undefined;
+    /** Internal keeper of the status */
+    protected _status?: SpanStatus;
+    /** The timed events added to this span. */
+    protected _events: TimedEvent[];
+    /** if true, treat span as a standalone span (not part of a transaction) */
+    private _isStandaloneSpan?;
+    /**
+     * You should never call the constructor manually, always use `Sentry.startSpan()`
+     * or other span methods.
+     * @internal
+     * @hideconstructor
+     * @hidden
+     */
+    constructor(spanContext?: SentrySpanArguments);
+    /** @inheritdoc */
+    spanContext(): SpanContextData;
+    /** @inheritdoc */
+    setAttribute(key: string, value: SpanAttributeValue | undefined): void;
+    /** @inheritdoc */
+    setAttributes(attributes: SpanAttributes): void;
+    /**
+     * This should generally not be used,
+     * but we need it for browser tracing where we want to adjust the start time afterwards.
+     * USE THIS WITH CAUTION!
+     *
+     * @hidden
+     * @internal
+     */
+    updateStartTime(timeInput: SpanTimeInput): void;
+    /**
+     * @inheritDoc
+     */
+    setStatus(value: SpanStatus): this;
+    /**
+     * @inheritDoc
+     */
+    updateName(name: string): this;
+    /** @inheritdoc */
+    end(endTimestamp?: SpanTimeInput): void;
+    /**
+     * Get JSON 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 `spanToJSON(span)` instead.
+     */
+    getSpanJSON(): SpanJSON;
+    /** @inheritdoc */
+    isRecording(): boolean;
+    /**
+     * @inheritdoc
+     */
+    addEvent(name: string, attributesOrStartTime?: SpanAttributes | SpanTimeInput, startTime?: SpanTimeInput): this;
+    /**
+     * This method should generally not be used,
+     * but for now we need a way to publicly check if the `_isStandaloneSpan` flag is set.
+     * USE THIS WITH CAUTION!
+     * @internal
+     * @hidden
+     * @experimental
+     */
+    isStandaloneSpan(): boolean;
+    /** Emit `spanEnd` when the span is ended. */
+    private _onSpanEnded;
+    /**
+     * Finish the transaction & prepare the event to send to Sentry.
+     */
+    private _convertSpanToTransaction;
+}
+//# sourceMappingURL=sentrySpan.d.ts.map

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

@@ -0,0 +1,17 @@
+import { 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-ts3.8/core/src/tracing/trace.d.ts

@@ -0,0 +1,76 @@
+import { 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-ts3.8/core/src/tracing/utils.d.ts

@@ -0,0 +1,13 @@
+import { Span } from '@sentry/types';
+import { 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-ts3.8/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-ts3.8/core/src/utils/hasTracingEnabled.d.ts

@@ -0,0 +1,8 @@
+import { 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-ts3.8/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-ts3.8/core/src/utils/spanOnScope.d.ts

@@ -0,0 +1,17 @@
+import { 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