sdk.js
No OneTemporary
Actions

Size

8 KB

Subscribers

None

sdk.js
View Options

	import { Integrations, getIntegrationsToSetup, initAndBind, getCurrentHub, getReportDialogEndpoint } from '@sentry/core';
	import { getGlobalObject, stackParserFromStackParserOptions, supportsFetch, logger, resolvedSyncPromise, addInstrumentationHandler } from '@sentry/utils';
	import { BrowserClient } from './client.js';
	import { wrap as wrap$1 } from './helpers.js';
	import './integrations/index.js';
	import { defaultStackParser } from './stack-parsers.js';
	import './transports/index.js';
	import { TryCatch } from './integrations/trycatch.js';
	import { Breadcrumbs } from './integrations/breadcrumbs.js';
	import { GlobalHandlers } from './integrations/globalhandlers.js';
	import { LinkedErrors } from './integrations/linkederrors.js';
	import { Dedupe } from './integrations/dedupe.js';
	import { HttpContext } from './integrations/httpcontext.js';
	import { makeFetchTransport } from './transports/fetch.js';
	import { makeXHRTransport } from './transports/xhr.js';

	var defaultIntegrations = [
	new Integrations.InboundFilters(),
	new Integrations.FunctionToString(),
	new TryCatch(),
	new Breadcrumbs(),
	new GlobalHandlers(),
	new LinkedErrors(),
	new Dedupe(),
	new HttpContext(),
	];

	/**
	* The Sentry Browser SDK Client.
	*
	* To use this SDK, call the {@link init} function as early as possible when
	* loading the web page. To set context information or send manual events, use
	* the provided methods.
	*
	* @example
	*
	* ```
	*
	* import { init } from '@sentry/browser';
	*
	* init({
	* dsn: '__DSN__',
	* // ...
	* });
	* ```
	*
	* @example
	* ```
	*
	* import { configureScope } from '@sentry/browser';
	* configureScope((scope: Scope) => {
	* scope.setExtra({ battery: 0.7 });
	* scope.setTag({ user_mode: 'admin' });
	* scope.setUser({ id: '4711' });
	* });
	* ```
	*
	* @example
	* ```
	*
	* import { addBreadcrumb } from '@sentry/browser';
	* addBreadcrumb({
	* message: 'My Breadcrumb',
	* // ...
	* });
	* ```
	*
	* @example
	*
	* ```
	*
	* import * as Sentry from '@sentry/browser';
	* Sentry.captureMessage('Hello, world!');
	* Sentry.captureException(new Error('Good bye'));
	* Sentry.captureEvent({
	* message: 'Manual',
	* stacktrace: [
	* // ...
	* ],
	* });
	* ```
	*
	* @see {@link BrowserOptions} for documentation on configuration options.
	*/
	function init(options = {}) {
	if (options.defaultIntegrations === undefined) {
	options.defaultIntegrations = defaultIntegrations;
	}
	if (options.release === undefined) {
	var window = getGlobalObject();
	// This supports the variable that sentry-webpack-plugin injects
	if (window.SENTRY_RELEASE && window.SENTRY_RELEASE.id) {
	options.release = window.SENTRY_RELEASE.id;
	}
	}
	if (options.autoSessionTracking === undefined) {
	options.autoSessionTracking = true;
	}
	if (options.sendClientReports === undefined) {
	options.sendClientReports = true;
	}

	var clientOptions = {
	...options,
	stackParser: stackParserFromStackParserOptions(options.stackParser \|\| defaultStackParser),
	integrations: getIntegrationsToSetup(options),
	transport: options.transport \|\| (supportsFetch() ? makeFetchTransport : makeXHRTransport),
	};

	initAndBind(BrowserClient, clientOptions);

	if (options.autoSessionTracking) {
	startSessionTracking();
	}
	}

	/**
	* Present the user with a report dialog.
	*
	* @param options Everything is optional, we try to fetch all info need from the global scope.
	*/
	function showReportDialog(options = {}, hub = getCurrentHub()) {
	// doesn't work without a document (React Native)
	var global = getGlobalObject();
	if (!global.document) {
	(typeof __SENTRY_DEBUG__ === 'undefined' \|\| __SENTRY_DEBUG__) && logger.error('Global document not defined in showReportDialog call');
	return;
	}

	const { client, scope } = hub.getStackTop();
	var dsn = options.dsn \|\| (client && client.getDsn());
	if (!dsn) {
	(typeof __SENTRY_DEBUG__ === 'undefined' \|\| __SENTRY_DEBUG__) && logger.error('DSN not configured for showReportDialog call');
	return;
	}

	if (scope) {
	options.user = {
	...scope.getUser(),
	...options.user,
	};
	}

	if (!options.eventId) {
	options.eventId = hub.lastEventId();
	}

	var script = global.document.createElement('script');
	script.async = true;
	script.src = getReportDialogEndpoint(dsn, options);

	if (options.onLoad) {
	script.onload = options.onLoad;
	}

	var injectionPoint = global.document.head \|\| global.document.body;
	if (injectionPoint) {
	injectionPoint.appendChild(script);
	} else {
	(typeof __SENTRY_DEBUG__ === 'undefined' \|\| __SENTRY_DEBUG__) && logger.error('Not injecting report dialog. No injection point found in HTML');
	}
	}

	/**
	* This is the getter for lastEventId.
	*
	* @returns The last event id of a captured event.
	*/
	function lastEventId() {
	return getCurrentHub().lastEventId();
	}

	/**
	* This function is here to be API compatible with the loader.
	* @hidden
	*/
	function forceLoad() {
	// Noop
	}

	/**
	* This function is here to be API compatible with the loader.
	* @hidden
	*/
	function onLoad(callback) {
	callback();
	}

	/**
	* Call `flush()` on the current client, if there is one. See {@link Client.flush}.
	*
	* @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause
	* the client to wait until all events are sent before resolving the promise.
	* @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it
	* doesn't (or if there's no client defined).
	*/
	function flush(timeout) {
	var client = getCurrentHub().getClient();
	if (client) {
	return client.flush(timeout);
	}
	(typeof __SENTRY_DEBUG__ === 'undefined' \|\| __SENTRY_DEBUG__) && logger.warn('Cannot flush events. No client defined.');
	return resolvedSyncPromise(false);
	}

	/**
	* Call `close()` on the current client, if there is one. See {@link Client.close}.
	*
	* @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this
	* parameter will cause the client to wait until all events are sent before disabling itself.
	* @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it
	* doesn't (or if there's no client defined).
	*/
	function close(timeout) {
	var client = getCurrentHub().getClient();
	if (client) {
	return client.close(timeout);
	}
	(typeof __SENTRY_DEBUG__ === 'undefined' \|\| __SENTRY_DEBUG__) && logger.warn('Cannot flush events and disable SDK. No client defined.');
	return resolvedSyncPromise(false);
	}

	/**
	* Wrap code within a try/catch block so the SDK is able to capture errors.
	*
	* @param fn A function to wrap.
	*
	* @returns The result of wrapped function call.
	*/
	function wrap(fn) {
	return wrap$1(fn)();
	}

	function startSessionOnHub(hub) {
	hub.startSession({ ignoreDuration: true });
	hub.captureSession();
	}

	/**
	* Enable automatic Session Tracking for the initial page load.
	*/
	function startSessionTracking() {
	var window = getGlobalObject();
	var document = window.document;

	if (typeof document === 'undefined') {
	(typeof __SENTRY_DEBUG__ === 'undefined' \|\| __SENTRY_DEBUG__) &&
	logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');
	return;
	}

	var hub = getCurrentHub();

	// The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and
	// @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are
	// pinned at the same version in package.json, but there are edge cases where it's possible. See
	// https://github.com/getsentry/sentry-javascript/issues/3207 and
	// https://github.com/getsentry/sentry-javascript/issues/3234 and
	// https://github.com/getsentry/sentry-javascript/issues/3278.
	if (!hub.captureSession) {
	return;
	}

	// The session duration for browser sessions does not track a meaningful
	// concept that can be used as a metric.
	// Automatically captured sessions are akin to page views, and thus we
	// discard their duration.
	startSessionOnHub(hub);

	// We want to create a session for every navigation as well
	addInstrumentationHandler('history', ({ from, to }) => {
	// Don't create an additional session for the initial route or if the location did not change
	if (!(from === undefined \|\| from === to)) {
	startSessionOnHub(getCurrentHub());
	}
	});
	}

	export { close, defaultIntegrations, flush, forceLoad, init, lastEventId, onLoad, showReportDialog, wrap };
	//# sourceMappingURL=sdk.js.map

File Metadata

Mime Type: text/x-java
Expires: Jun 4 2025, 6:55 PM (12 w, 4 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 3297226

sdk.jsNo OneTemporaryActions

sdk.jsView Options

File Metadata

Event Timeline

sdk.js
No OneTemporary
Actions

sdk.js
View Options