@sentry/profiling-node 8.10.0 → 8.12.0-beta.0

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

@@ -1,18 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

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

@@ -1,13 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,211 +0,0 @@
-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

@@ -1,33 +0,0 @@
-/**
- * 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

@@ -1,35 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

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

@@ -1,76 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,13 +0,0 @@
-/**
- * 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

@@ -1,8 +0,0 @@
-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

@@ -1,9 +0,0 @@
-/**
- * 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