660 lines
19 KiB
JavaScript
660 lines
19 KiB
JavaScript
// Metro module 6423 (f6424).
|
|
import * as _slicedToArray from "./_slicedToArray";
|
|
import * as _classCallCheck from "./_classCallCheck";
|
|
import * as __createClass from "./_createClass";
|
|
import { makeDsn, dsnToString } from "./dsnFromString_6415";
|
|
import { DEBUG_BUILD } from "./Module6396";
|
|
import { logger } from "./consoleSandbox_6368";
|
|
import { uuid4, checkOrSetAlreadyCaught } from "./Module6379";
|
|
import * as _isInstanceOf from "./isInstanceOf_6375";
|
|
import { isParameterizedString, isPrimitive, isThenable } from "./isInstanceOf_6375";
|
|
import { updateSession } from "./updateSession_6391";
|
|
import { resolvedSyncPromise, SyncPromise, rejectedSyncPromise } from "./SyncPromise_6392";
|
|
import { setupIntegration, afterSetupIntegrations, setupIntegrations } from "./setupIntegration_6424";
|
|
import { createEventEnvelope, createSessionEnvelope } from "./Module6411";
|
|
import { addItemToEnvelope, createAttachmentEnvelopeItem } from "./forEachEnvelopeItem_6412";
|
|
import { getCurrentScope, getIsolationScope, getTraceContextFromScope } from "./Module6395";
|
|
import { prepareEvent } from "./applyClientOptions_6417";
|
|
import { getDynamicSamplingContextFromScope } from "./getDynamicSamplingContextFromSpan_6404";
|
|
import { SentryError } from "./SentryError_6425";
|
|
import { parseSampleRate } from "./Module6408";
|
|
import { createClientReportEnvelope } from "./Module6426";
|
|
import { showSpanDropWarning } from "./spanTimeInputToSeconds";
|
|
let isTransactionEvent, c4121_4;
|
|
let BaseClient;
|
|
let env4121 = {};
|
|
const isErrorEvent = function isErrorEvent(a0) {
|
|
return a0.type === void 0;
|
|
};
|
|
isTransactionEvent = function isTransactionEvent(a0) {
|
|
return a0.type === "transaction";
|
|
};
|
|
c4121_4 = "Not capturing exception because it's already been captured.";
|
|
BaseClient = function BaseClient(a0) {
|
|
"use strict";
|
|
let r26, r27;
|
|
let c25861_1;
|
|
let c25861_0 = a0;
|
|
_classCallCheck(this, BaseClient);
|
|
this._options = a0;
|
|
this._integrations = {};
|
|
this._numProcessing = 0;
|
|
this._outcomes = {};
|
|
this._hooks = {};
|
|
this._eventProcessors = [];
|
|
if (a0.dsn) {
|
|
this._dsn = makeDsn(a0.dsn);
|
|
r26 = dependencyMap;
|
|
r27 = require;
|
|
} else {
|
|
r26 = dependencyMap;
|
|
r27 = require;
|
|
if (DEBUG_BUILD) {
|
|
logger.warn("No DSN provided, client will not send events.");
|
|
r26 = dependencyMap;
|
|
r27 = require;
|
|
}
|
|
}
|
|
if (this._dsn) {
|
|
const envelopeEndpointWithUrlEncodedAuth = r27(r26[6]).getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, a0.tunnel, a0._metadata ? a0._metadata.sdk : void 0);
|
|
this._transport = a0.transport.call(a0, {
|
|
tunnel: this._options.tunnel,
|
|
recordDroppedEvent: this.recordDroppedEvent.bind(this),
|
|
...a0.transportOptions,
|
|
url: envelopeEndpointWithUrlEncodedAuth
|
|
});
|
|
}
|
|
const r58 = ["enableTracing", "tracesSampleRate", "tracesSampler"].find((item) => item in c25861_0 && c25861_0[item] == null);
|
|
c25861_1 = r58;
|
|
if (r58) {
|
|
r27(r26[5]).consoleSandbox(() => {
|
|
console.warn(`[Sentry] Deprecation warning: \`${c25861_1}\` is set to undefined, which leads to tracing being enabled. In v9, a value of \`undefined\` will result in tracing being disabled.`);
|
|
});
|
|
}
|
|
};
|
|
exports.BaseClient = __createClass(BaseClient, [{
|
|
key: "captureException",
|
|
value: function captureException(a0, a1, c25862_1) {
|
|
"use strict";
|
|
const event_id = uuid4();
|
|
if (checkOrSetAlreadyCaught(a0)) {
|
|
if (DEBUG_BUILD) {
|
|
logger.log(c4121_4);
|
|
}
|
|
return event_id;
|
|
}
|
|
const r19 = {
|
|
event_id,
|
|
...a1
|
|
};
|
|
let c25862_0 = r19;
|
|
this._process(this.eventFromException(a0, r19).then((result) => this._captureEvent(result, c25862_0, c25862_1)));
|
|
return r19.event_id;
|
|
}
|
|
}, {
|
|
key: "captureMessage",
|
|
value: function captureMessage(a0, a1, a2, c25863_1) {
|
|
"use strict";
|
|
const r15 = {
|
|
event_id: uuid4(),
|
|
...a2
|
|
};
|
|
let c25863_0 = r15;
|
|
const r21 = isParameterizedString(a0) ? a0 : String(a0);
|
|
this._process((isPrimitive(a0) ? this.eventFromMessage(r21, a1, r15) : this.eventFromException(a0, r15)).then((result) => this._captureEvent(result, c25863_0, c25863_1)));
|
|
return r15.event_id;
|
|
}
|
|
}, {
|
|
key: "captureEvent",
|
|
value: function captureEvent(a0, a1, a2) {
|
|
"use strict";
|
|
const event_id = uuid4();
|
|
if (a1 && a1.originalException && checkOrSetAlreadyCaught(a1.originalException)) {
|
|
if (DEBUG_BUILD) {
|
|
logger.log(c4121_4);
|
|
}
|
|
return event_id;
|
|
}
|
|
const r21 = {
|
|
event_id,
|
|
...a1
|
|
};
|
|
let capturedSpanScope = (a0.sdkProcessingMetadata || {}).capturedSpanScope;
|
|
const _process2 = this._process;
|
|
const _captureEvent2 = this._captureEvent;
|
|
if (!capturedSpanScope) {
|
|
capturedSpanScope = a2;
|
|
}
|
|
_process2.call(this, _captureEvent2.call(this, a0, r21, capturedSpanScope));
|
|
return r21.event_id;
|
|
}
|
|
}, {
|
|
key: "captureSession",
|
|
value: function captureSession(a0) {
|
|
"use strict";
|
|
if (typeof a0.release !== "string") {
|
|
if (DEBUG_BUILD) {
|
|
logger.warn("Discarded session because of missing or non-string release");
|
|
}
|
|
} else {
|
|
this.sendSession(a0);
|
|
updateSession(a0, {
|
|
init: false
|
|
});
|
|
}
|
|
}
|
|
}, {
|
|
key: "getDsn",
|
|
value: function getDsn() {
|
|
"use strict";
|
|
return this._dsn;
|
|
}
|
|
}, {
|
|
key: "getOptions",
|
|
value: function getOptions() {
|
|
"use strict";
|
|
return this._options;
|
|
}
|
|
}, {
|
|
key: "getSdkMetadata",
|
|
value: function getSdkMetadata() {
|
|
"use strict";
|
|
return this._options._metadata;
|
|
}
|
|
}, {
|
|
key: "getTransport",
|
|
value: function getTransport() {
|
|
"use strict";
|
|
return this._transport;
|
|
}
|
|
}, {
|
|
key: "flush",
|
|
value: function flush(a0) {
|
|
"use strict";
|
|
let r13;
|
|
let c25864_0 = a0;
|
|
const _transport = this._transport;
|
|
if (_transport) {
|
|
this.emit("flush");
|
|
r13 = this._isClientDoneProcessing(a0).then((c29768_0) => _transport.flush(c25864_0).then((result) => c29768_0 && result));
|
|
} else {
|
|
r13 = resolvedSyncPromise(true);
|
|
}
|
|
return r13;
|
|
}
|
|
}, {
|
|
key: "close",
|
|
value: function close(a0) {
|
|
"use strict";
|
|
return this.flush(a0).then((result) => {
|
|
this.getOptions().enabled = false;
|
|
this.emit("close");
|
|
return result;
|
|
});
|
|
}
|
|
}, {
|
|
key: "getEventProcessors",
|
|
value: function getEventProcessors() {
|
|
"use strict";
|
|
return this._eventProcessors;
|
|
}
|
|
}, {
|
|
key: "addEventProcessor",
|
|
value: function addEventProcessor(a0) {
|
|
"use strict";
|
|
this._eventProcessors.push(a0);
|
|
}
|
|
}, {
|
|
key: "init",
|
|
value: function init() {
|
|
"use strict";
|
|
if (this._isEnabled() || this._options.integrations.some((integration) => integration.name.startsWith("Spotlight"))) {
|
|
this._setupIntegrations();
|
|
}
|
|
}
|
|
}, {
|
|
key: "getIntegrationByName",
|
|
value: function getIntegrationByName(a0) {
|
|
"use strict";
|
|
return this._integrations[a0];
|
|
}
|
|
}, {
|
|
key: "addIntegration",
|
|
value: function addIntegration(a0) {
|
|
"use strict";
|
|
const r9 = this._integrations[a0.name];
|
|
setupIntegration(this, a0, this._integrations);
|
|
if (!r9) {
|
|
afterSetupIntegrations(this, [a0]);
|
|
}
|
|
}
|
|
}, {
|
|
key: "sendEvent",
|
|
value: function sendEvent(a0) {
|
|
"use strict";
|
|
let c25866_0 = a0;
|
|
let r3 = arguments[1];
|
|
if (r3 === void 0) {
|
|
r3 = {};
|
|
}
|
|
this.emit("beforeSendEvent", a0, r3);
|
|
let r33 = createEventEnvelope(a0, this._dsn, this._options._metadata, this._options.tunnel);
|
|
const r34 = r3.attachments || [];
|
|
for (const item of r34) {
|
|
r33 = addItemToEnvelope(r33, createAttachmentEnvelopeItem(item));
|
|
}
|
|
const r51 = this.sendEnvelope(r33);
|
|
if (r51) {
|
|
r51.then((result) => this.emit("afterSendEvent", c25866_0, result), null);
|
|
}
|
|
}
|
|
}, {
|
|
key: "sendSession",
|
|
value: function sendSession(a0) {
|
|
"use strict";
|
|
this.sendEnvelope(createSessionEnvelope(a0, this._dsn, this._options._metadata, this._options.tunnel));
|
|
}
|
|
}, {
|
|
key: "recordDroppedEvent",
|
|
value: function recordDroppedEvent(a0, a1, a2) {
|
|
"use strict";
|
|
if (this._options.sendClientReports) {
|
|
const r5 = typeof a2 === "number" ? a2 : 1;
|
|
const r16 = `${a0}:${a1}`;
|
|
if (DEBUG_BUILD) {
|
|
logger.log(`Recording outcome: "${r16}"${r5 > 1 ? ` (${r5} times)` : ""}`);
|
|
}
|
|
this._outcomes[r16] = (this._outcomes[r16] || 0) + r5;
|
|
}
|
|
}
|
|
}, {
|
|
key: "on",
|
|
value: function on(a0, a1) {
|
|
"use strict";
|
|
let c25867_0 = a1;
|
|
const _hooks = this._hooks;
|
|
const r6 = this._hooks[a0] || [];
|
|
_hooks[a0] = r6;
|
|
let c25867_1 = r6;
|
|
r6.push(a1);
|
|
return () => {
|
|
const r6 = c25867_1.indexOf(c25867_0);
|
|
if (r6 > -1) {
|
|
c25867_1.splice(r6, 1);
|
|
}
|
|
};
|
|
}
|
|
}, {
|
|
key: "emit",
|
|
value: function emit(a0) {
|
|
"use strict";
|
|
let c25868_0 = Array.prototype.slice.call(arguments, 1);
|
|
const r8 = this._hooks[a0];
|
|
if (r8) {
|
|
r8.forEach((item) => item.apply(void 0, [...c25868_0]));
|
|
}
|
|
}
|
|
}, {
|
|
key: "sendEnvelope",
|
|
value: function sendEnvelope(a0) {
|
|
"use strict";
|
|
let r25;
|
|
this.emit("beforeEnvelope", a0);
|
|
if (this._isEnabled() && this._transport) {
|
|
r25 = this._transport.send(a0).then(null, (a0) => {
|
|
if (DEBUG_BUILD) {
|
|
logger.error("Error while sending envelope:", a0);
|
|
}
|
|
return a0;
|
|
});
|
|
} else {
|
|
if (DEBUG_BUILD) {
|
|
logger.error("Transport disabled");
|
|
}
|
|
r25 = resolvedSyncPromise({});
|
|
}
|
|
return r25;
|
|
}
|
|
}, {
|
|
key: "_setupIntegrations",
|
|
value: function _setupIntegrations() {
|
|
"use strict";
|
|
const integrations = this._options.integrations;
|
|
this._integrations = setupIntegrations(this, integrations);
|
|
afterSetupIntegrations(this, integrations);
|
|
}
|
|
}, {
|
|
key: "_updateSessionFromEvent",
|
|
value: function _updateSessionFromEvent(a0, a1) {
|
|
"use strict";
|
|
let r21;
|
|
let r22 = a1.level === "fatal";
|
|
const r23 = a1.exception && a1.exception.values;
|
|
let r7 = false;
|
|
if (r23) {
|
|
let r26 = r23[Symbol.iterator]();
|
|
const next = r26.next;
|
|
while (true) {
|
|
const r28 = r26 === void 0 ? void 0 : (r21 = next.call(r26)).done ? r26 = void 0 : r21.value;
|
|
const r9 = r26;
|
|
r7 = true;
|
|
if (r9 === void 0) {
|
|
break;
|
|
}
|
|
L9: {
|
|
try {
|
|
const mechanism = r28.mechanism;
|
|
if (!mechanism) {
|
|
continue;
|
|
}
|
|
if (mechanism.handled === false) {
|
|
r22 = true;
|
|
break L9;
|
|
}
|
|
continue;
|
|
} catch (r34) {
|
|
if (r26 !== void 0 && typeof r26.return === "function") {
|
|
try {
|
|
r26.return();
|
|
} catch {}
|
|
}
|
|
throw r34;
|
|
}
|
|
}
|
|
const r33 = r26;
|
|
if (r33 !== void 0 && typeof r33.return === "function") {
|
|
r33.return();
|
|
}
|
|
r7 = true;
|
|
break;
|
|
}
|
|
}
|
|
let r38 = a0.status === "ok";
|
|
let r39 = r38 ? a0.errors === 0 : r38;
|
|
if (!r39) {
|
|
if (r38) {
|
|
r38 = r22;
|
|
}
|
|
r39 = r38;
|
|
}
|
|
if (r39) {
|
|
const r48 = r22 && {
|
|
status: "crashed"
|
|
};
|
|
let errors = a0.errors;
|
|
if (!errors) {
|
|
const r53 = Number;
|
|
if (!r7) {
|
|
r7 = r22;
|
|
}
|
|
errors = r53(r7);
|
|
}
|
|
updateSession(a0, {
|
|
...r48,
|
|
errors
|
|
});
|
|
this.captureSession(a0);
|
|
}
|
|
}
|
|
}, {
|
|
key: "_isClientDoneProcessing",
|
|
value: function _isClientDoneProcessing(c25869_0) {
|
|
"use strict";
|
|
return new SyncPromise((c29769_0) => {
|
|
let c29769_1 = 0;
|
|
let c29769_2 = setInterval(() => {
|
|
if (this._numProcessing == 0) {
|
|
clearInterval(c29769_2);
|
|
c29769_0(true);
|
|
} else {
|
|
const r9 = c29769_1 + 1;
|
|
c29769_1 = r9;
|
|
if (c25869_0 && r9 >= c25869_0) {
|
|
clearInterval(c29769_2);
|
|
c29769_0(false);
|
|
}
|
|
}
|
|
}, 1);
|
|
});
|
|
}
|
|
}, {
|
|
key: "_isEnabled",
|
|
value: function _isEnabled() {
|
|
"use strict";
|
|
return this.getOptions().enabled !== false && this._transport !== void 0;
|
|
}
|
|
}, {
|
|
key: "_prepareEvent",
|
|
value: function _prepareEvent(a0, a1) {
|
|
"use strict";
|
|
let r11 = arguments[2];
|
|
if (r11 === void 0) {
|
|
r11 = getCurrentScope();
|
|
}
|
|
const currentScope = r11;
|
|
let r10 = arguments[3];
|
|
if (r10 === void 0) {
|
|
r10 = getIsolationScope();
|
|
}
|
|
const options2 = this.getOptions();
|
|
const integrations2 = Object.keys(this._integrations);
|
|
const integrations = a1.integrations;
|
|
if (integrations ? !integrations : integrations2.length > 0) {
|
|
a1.integrations = integrations2;
|
|
}
|
|
this.emit("preprocessEvent", a0, a1);
|
|
if (!a0.type) {
|
|
r10.setLastEventId.call(r10, a0.event_id || a1.event_id);
|
|
}
|
|
return prepareEvent(options2, a0, a1, currentScope, this, r10).then((result) => {
|
|
if (result === null) {
|
|
return result;
|
|
}
|
|
result.contexts = {
|
|
trace: getTraceContextFromScope(currentScope),
|
|
...result.contexts
|
|
};
|
|
result.sdkProcessingMetadata = {
|
|
dynamicSamplingContext: getDynamicSamplingContextFromScope(this, currentScope),
|
|
...result.sdkProcessingMetadata
|
|
};
|
|
return result;
|
|
});
|
|
}
|
|
}, {
|
|
key: "_captureEvent",
|
|
value: function _captureEvent(a0) {
|
|
"use strict";
|
|
let r6 = arguments[1];
|
|
if (r6 === void 0) {
|
|
r6 = {};
|
|
}
|
|
return this._processEvent(a0, r6, arguments[2]).then((result) => result.event_id, (a0) => {
|
|
L5: {
|
|
if (DEBUG_BUILD) {
|
|
if (a0 instanceof SentryError && a0.logLevel === "log") {
|
|
logger.log(a0.message);
|
|
break L5;
|
|
}
|
|
logger.warn(a0);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}, {
|
|
key: "_processEvent",
|
|
value: function _processEvent(a0, a1, a2) {
|
|
"use strict";
|
|
const _this = this;
|
|
let c25871_1 = a0;
|
|
let c25871_2 = a1;
|
|
let c25871_3 = a2;
|
|
const options = this.getOptions();
|
|
const sampleRate = options.sampleRate;
|
|
let c25871_5 = a0.type === "transaction";
|
|
const type = a0.type;
|
|
const r6 = a0.type || "error";
|
|
let c25871_6 = `before send for type \`${r6}\``;
|
|
const r27 = sampleRate !== void 0 ? parseSampleRate(sampleRate) : void 0;
|
|
if (type === void 0 && typeof r27 === "number" && Math.random() > r27) {
|
|
this.recordDroppedEvent("sample_rate", "error", a0);
|
|
return rejectedSyncPromise(new SentryError(`Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`, "log"));
|
|
}
|
|
let c25871_0 = r6 !== "replay_event" ? r6 : "replay";
|
|
return this._prepareEvent(a0, a1, a2, (a0.sdkProcessingMetadata || {}).capturedSpanIsolationScope).then((result) => {
|
|
let r38;
|
|
if (result === null) {
|
|
_this.recordDroppedEvent("event_processor", c25871_0, c25871_1);
|
|
throw new SentryError("An event processor returned `null`, will not send event.", "log");
|
|
}
|
|
if (c25871_2.data && c25871_2.data.__sentry__ === true) {
|
|
return result;
|
|
}
|
|
let c29770_0, c29770_1;
|
|
const r20 = (function processBeforeSend(a0, { beforeSend, beforeSendTransaction, beforeSendSpan }, a2, a3) {
|
|
if (isErrorEvent(a2) && beforeSend) {
|
|
return beforeSend(a2, a3);
|
|
}
|
|
if (isTransactionEvent(a2)) {
|
|
if (a2.spans && beforeSendSpan) {
|
|
const spans = [];
|
|
for (const span of a2.spans) {
|
|
const r37 = beforeSendSpan(span);
|
|
if (r37) {
|
|
spans.push(r37);
|
|
} else {
|
|
showSpanDropWarning();
|
|
a0.recordDroppedEvent("before_send", "span");
|
|
}
|
|
}
|
|
a2.spans = spans;
|
|
}
|
|
if (beforeSendTransaction) {
|
|
if (a2.spans) {
|
|
a2.sdkProcessingMetadata = {
|
|
...a2.sdkProcessingMetadata,
|
|
spanCountBeforeProcessing: a2.spans.length
|
|
};
|
|
}
|
|
return beforeSendTransaction(a2, a3);
|
|
}
|
|
}
|
|
return a2;
|
|
})(_this, options, result, c25871_2);
|
|
c29770_0 = c25871_6;
|
|
c29770_1 = void 0;
|
|
const r25 = `${c25871_6} must return \`null\` or a valid event.`;
|
|
c29770_1 = r25;
|
|
if (isThenable(r20)) {
|
|
r38 = r20.then((result) => {
|
|
if (!_isInstanceOf.isPlainObject(result) && result !== null) {
|
|
throw new SentryError(c29770_1);
|
|
}
|
|
return result;
|
|
}, (a0) => {
|
|
throw new SentryError(`${c29770_0} rejected with ${a0}`);
|
|
});
|
|
} else {
|
|
const isPlainObject = _isInstanceOf.isPlainObject(r20);
|
|
r38 = r20;
|
|
if (!isPlainObject) {
|
|
r38 = r20;
|
|
if (r38 !== null) {
|
|
throw new SentryError(r25);
|
|
}
|
|
}
|
|
}
|
|
return r38;
|
|
}).then((result) => {
|
|
if (result === null) {
|
|
_this.recordDroppedEvent("before_send", c25871_0, c25871_1);
|
|
if (c25871_5) {
|
|
_this.recordDroppedEvent("before_send", "span", 1 + (c25871_1.spans || []).length);
|
|
}
|
|
throw new SentryError(`${c25871_6} returned \`null\`, will not send event.`, "log");
|
|
}
|
|
const r6 = c25871_3 && c25871_3.getSession();
|
|
if (c25871_5 ? !c25871_5 : r6) {
|
|
_this._updateSessionFromEvent(r6, result);
|
|
}
|
|
if (c25871_5) {
|
|
const r8 = (result.sdkProcessingMetadata && result.sdkProcessingMetadata.spanCountBeforeProcessing || 0) - (result.spans ? result.spans.length : 0);
|
|
if (r8 > 0) {
|
|
_this.recordDroppedEvent("before_send", "span", r8);
|
|
}
|
|
}
|
|
const transaction_info = result.transaction_info;
|
|
if (c25871_5 && transaction_info && result.transaction !== c25871_1.transaction) {
|
|
result.transaction_info = {
|
|
...transaction_info,
|
|
source: "custom"
|
|
};
|
|
}
|
|
_this.sendEvent(result, c25871_2);
|
|
return result;
|
|
}).then(null, (a0) => {
|
|
if (a0 instanceof SentryError) {
|
|
throw a0;
|
|
}
|
|
_this.captureException(a0, {
|
|
data: {
|
|
__sentry__: true
|
|
},
|
|
originalException: a0
|
|
});
|
|
throw new SentryError(`Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.
|
|
Reason: ${a0}`);
|
|
});
|
|
}
|
|
}, {
|
|
key: "_process",
|
|
value: function _process(a0) {
|
|
"use strict";
|
|
this._numProcessing = this._numProcessing + 1;
|
|
a0.then((result) => {
|
|
this._numProcessing = this._numProcessing - 1;
|
|
return result;
|
|
}, (a0) => {
|
|
this._numProcessing = this._numProcessing - 1;
|
|
return a0;
|
|
});
|
|
}
|
|
}, {
|
|
key: "_clearOutcomes",
|
|
value: function _clearOutcomes() {
|
|
"use strict";
|
|
const _outcomes = this._outcomes;
|
|
this._outcomes = {};
|
|
return Object.entries(_outcomes).map((item) => {
|
|
const [r8, quantity] = item;
|
|
const r32 = _slicedToArray(r8.split(":"), 2);
|
|
return {
|
|
reason: r32[0],
|
|
category: r32[1],
|
|
quantity
|
|
};
|
|
});
|
|
}
|
|
}, {
|
|
key: "_flushOutcomes",
|
|
value: function _flushOutcomes() {
|
|
"use strict";
|
|
if (DEBUG_BUILD) {
|
|
logger.log("Flushing outcomes...");
|
|
}
|
|
const r6 = this._clearOutcomes();
|
|
if (r6.length !== 0) {
|
|
if (this._dsn) {
|
|
if (DEBUG_BUILD) {
|
|
logger.log("Sending outcomes:", r6);
|
|
}
|
|
this.sendEnvelope(createClientReportEnvelope(r6, this._options.tunnel && dsnToString(this._dsn)));
|
|
} else if (DEBUG_BUILD) {
|
|
logger.log("No dsn provided, will not send outcomes");
|
|
}
|
|
} else if (DEBUG_BUILD) {
|
|
logger.log("No outcomes to send");
|
|
}
|
|
}
|
|
}]);
|