e510164e6b
Skipped 1 file(s) >100MB (GitHub limit): source/__polyfill/04xxx/module_4759.js (118.4 MB)
1454 lines
44 KiB
JavaScript
1454 lines
44 KiB
JavaScript
// Module ID: 741
|
|
// Function ID: 742
|
|
// Dependencies: [32, 5, 41, 42, 742, 743, 702, 688, 689, 740, 745, 750, 695, 692, 710, 752, 728, 729, 723, 735, 713, 722, 753, 701, 696, 738, 754, 755, 724, 684, 711]
|
|
|
|
// Module 741
|
|
import "module_32";
|
|
import asyncGeneratorStep from "asyncGeneratorStep" /* 5 */;
|
|
import "_classCallCheck";
|
|
import _createClass from "_createClass" /* 42 */;
|
|
|
|
function isErrorEvent(type) {
|
|
return undefined === type.type;
|
|
}
|
|
function isTransactionEvent(type) {
|
|
return "transaction" === type.type;
|
|
}
|
|
function estimateMetricSizeInBytes(name) {
|
|
let num = 0;
|
|
if (name.name) {
|
|
num = 2 * name.name.length;
|
|
}
|
|
const attributes = name.attributes;
|
|
c0 = undefined;
|
|
let num3 = 0;
|
|
if (attributes) {
|
|
c0 = 0;
|
|
const _Object = Object;
|
|
const values = Object.values(attributes);
|
|
const item = values.forEach((item) => {
|
|
if (Array.isArray(item)) {
|
|
let first = item[0];
|
|
if (typeof first === "string") {
|
|
first = first.length;
|
|
let num4 = 2 * first;
|
|
} else {
|
|
num4 = 8;
|
|
if (typeof first !== "number") {
|
|
let num7 = 0;
|
|
if (typeof first === "boolean") {
|
|
num7 = 4;
|
|
}
|
|
num4 = num7;
|
|
}
|
|
}
|
|
closure_0 = closure_0 + item.length * num4;
|
|
} else if (obj.isPrimitive(item)) {
|
|
if (typeof item === "string") {
|
|
let num2 = 2 * item.length;
|
|
} else {
|
|
num2 = 8;
|
|
if (typeof item !== "number") {
|
|
let num6 = 0;
|
|
if (typeof item === "boolean") {
|
|
num6 = 4;
|
|
}
|
|
num2 = num6;
|
|
}
|
|
}
|
|
closure_0 = tmp3 + num2;
|
|
} else {
|
|
closure_0 = tmp3 + 100;
|
|
}
|
|
});
|
|
num3 = c0;
|
|
}
|
|
return num + 8 + num3;
|
|
}
|
|
function estimateLogSizeInBytes(message) {
|
|
let num = 0;
|
|
if (message.message) {
|
|
num = 2 * message.message.length;
|
|
}
|
|
const attributes = message.attributes;
|
|
closure_0 = undefined;
|
|
let num3 = 0;
|
|
if (attributes) {
|
|
closure_0 = 0;
|
|
const _Object = Object;
|
|
const values = Object.values(attributes);
|
|
const item = values.forEach((item) => {
|
|
if (Array.isArray(item)) {
|
|
let first = item[0];
|
|
if (typeof first === "string") {
|
|
first = first.length;
|
|
let num4 = 2 * first;
|
|
} else {
|
|
num4 = 8;
|
|
if (typeof first !== "number") {
|
|
let num7 = 0;
|
|
if (typeof first === "boolean") {
|
|
num7 = 4;
|
|
}
|
|
num4 = num7;
|
|
}
|
|
}
|
|
closure_0 = closure_0 + item.length * num4;
|
|
} else if (obj.isPrimitive(item)) {
|
|
if (typeof item === "string") {
|
|
let num2 = 2 * item.length;
|
|
} else {
|
|
num2 = 8;
|
|
if (typeof item !== "number") {
|
|
let num6 = 0;
|
|
if (typeof item === "boolean") {
|
|
num6 = 4;
|
|
}
|
|
num2 = num6;
|
|
}
|
|
}
|
|
closure_0 = tmp3 + num2;
|
|
} else {
|
|
closure_0 = tmp3 + 100;
|
|
}
|
|
});
|
|
num3 = closure_0;
|
|
}
|
|
return num + num3;
|
|
}
|
|
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
|
|
const Client = "Not capturing exception because it's already been captured.";
|
|
let c5 = "Discarded session because of missing or non-string release";
|
|
let closure_6 = Symbol.for("SentryInternalError");
|
|
let closure_7 = Symbol.for("SentryDoNotSendEventError");
|
|
let React;
|
|
let dependencyMap;
|
|
let _slicedToArray;
|
|
let _classCallCheck;
|
|
class Client {
|
|
constructor(arg0) {
|
|
self = this;
|
|
tmp = closure_3(this, Client);
|
|
this._options = global;
|
|
this._integrations = {};
|
|
this._numProcessing = 0;
|
|
this._outcomes = {};
|
|
this._hooks = {};
|
|
this._eventProcessors = [];
|
|
tmp2 = closure_0;
|
|
tmp3 = closure_1;
|
|
obj = closure_0(closure_1[4]);
|
|
transportOptions = global.transportOptions;
|
|
bufferSize = undefined;
|
|
if (transportOptions != null) {
|
|
bufferSize = transportOptions.bufferSize;
|
|
}
|
|
if (bufferSize == null) {
|
|
bufferSize = tmp2(tmp3[5]).DEFAULT_TRANSPORT_BUFFER_SIZE;
|
|
}
|
|
self._promiseBuffer = obj.makePromiseBuffer(bufferSize);
|
|
if (global.dsn) {
|
|
tmp2Result = tmp2(tmp3[6]);
|
|
self._dsn = tmp2Result.makeDsn(global.dsn);
|
|
} else if (tmp2(tmp3[7]).DEBUG_BUILD) {
|
|
debug = tmp2(tmp3[8]).debug;
|
|
str = "No DSN provided, client will not send events.";
|
|
warnResult = debug.warn("No DSN provided, client will not send events.");
|
|
}
|
|
if (self._dsn) {
|
|
tmp2Result1 = tmp2(tmp3[9]);
|
|
sdk = undefined;
|
|
if (global._metadata) {
|
|
sdk = global._metadata.sdk;
|
|
}
|
|
obj1 = { tunnel: null, recordDroppedEvent: null };
|
|
obj1.tunnel = self._options.tunnel;
|
|
recordDroppedEvent = self.recordDroppedEvent;
|
|
envelopeEndpointWithUrlEncodedAuth = tmp2Result1.getEnvelopeEndpointWithUrlEncodedAuth(self._dsn, global.tunnel, sdk);
|
|
obj1.recordDroppedEvent = recordDroppedEvent.bind(self);
|
|
tmp8 = obj1;
|
|
merged = Object.assign(global.transportOptions);
|
|
obj1.url = envelopeEndpointWithUrlEncodedAuth;
|
|
self._transport = global.transport(obj1);
|
|
}
|
|
enableLogs = self._options.enableLogs;
|
|
if (enableLogs == null) {
|
|
_experiments = self._options._experiments;
|
|
enableLogs1 = undefined;
|
|
if (_experiments != null) {
|
|
enableLogs1 = _experiments.enableLogs;
|
|
}
|
|
enableLogs = enableLogs1;
|
|
}
|
|
self._options.enableLogs = enableLogs;
|
|
if (self._options.enableLogs) {
|
|
tmp11 = closure_11;
|
|
closure_1 = closure_11;
|
|
closure_2 = tmp2(tmp3[10])._INTERNAL_flushLogsBuffer;
|
|
c3 = undefined;
|
|
c4 = 0;
|
|
flag = false;
|
|
c5 = false;
|
|
str2 = "flushLogs";
|
|
onResult = self.on("flushLogs", () => {
|
|
c4 = 0;
|
|
clearTimeout(closure_3);
|
|
c5 = false;
|
|
});
|
|
str3 = "afterCaptureLog";
|
|
onResult1 = self.on("afterCaptureLog", (arg0) => {
|
|
const sum = c4 + closure_1(arg0);
|
|
c4 = sum;
|
|
if (sum >= 800000) {
|
|
closure_2(self);
|
|
} else if (!c5) {
|
|
c5 = true;
|
|
const _setTimeout = setTimeout;
|
|
const timeout = setTimeout(() => {
|
|
closure_1_2(self);
|
|
}, 5000);
|
|
}
|
|
});
|
|
str4 = "flush";
|
|
onResult2 = self.on("flush", () => {
|
|
closure_2(self);
|
|
});
|
|
}
|
|
flag2 = self._options.enableMetrics;
|
|
if (flag2 == null) {
|
|
_experiments2 = self._options._experiments;
|
|
enableMetrics = undefined;
|
|
if (_experiments2 != null) {
|
|
enableMetrics = _experiments2.enableMetrics;
|
|
}
|
|
flag2 = enableMetrics;
|
|
}
|
|
if (flag2 == null) {
|
|
flag2 = true;
|
|
}
|
|
if (flag2) {
|
|
tmp16 = c10;
|
|
closure_1 = c10;
|
|
closure_2 = tmp2(tmp3[11])._INTERNAL_flushMetricsBuffer;
|
|
c3 = undefined;
|
|
c4 = 0;
|
|
flag3 = false;
|
|
c5 = false;
|
|
str5 = "flushMetrics";
|
|
onResult3 = self.on("flushMetrics", () => {
|
|
c4 = 0;
|
|
clearTimeout(closure_3);
|
|
c5 = false;
|
|
});
|
|
str6 = "afterCaptureMetric";
|
|
onResult4 = self.on("afterCaptureMetric", (arg0) => {
|
|
const sum = c4 + closure_1(arg0);
|
|
c4 = sum;
|
|
if (sum >= 800000) {
|
|
closure_2(self);
|
|
} else if (!c5) {
|
|
c5 = true;
|
|
const _setTimeout = setTimeout;
|
|
const timeout = setTimeout(() => {
|
|
closure_1_2(self);
|
|
}, 5000);
|
|
}
|
|
});
|
|
str7 = "flush";
|
|
onResult5 = self.on("flush", () => {
|
|
closure_2(self);
|
|
});
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
const entry = {
|
|
key: "captureException",
|
|
value: function captureException(arg0, arg1, arg2) {
|
|
const self = this;
|
|
dependencyMap = arg0;
|
|
closure_2 = arg2;
|
|
const uuid4Result = closure_0(695).uuid4();
|
|
const obj = closure_0(695);
|
|
if (obj2.checkOrSetAlreadyCaught(arg0)) {
|
|
if (tmp(688).DEBUG_BUILD) {
|
|
const debug = tmp(689).debug;
|
|
debug.log(Client);
|
|
}
|
|
return uuid4Result;
|
|
} else {
|
|
const obj3 = { event_id: uuid4Result };
|
|
const merged = Object.assign(arg1);
|
|
self._process(() => {
|
|
const eventFromExceptionResult = self.eventFromException(closure_1, obj3);
|
|
return self.eventFromException(closure_1, obj3).then((result) => self._captureEvent(result, obj3, closure_1_2)).then((result) => result);
|
|
}, "error");
|
|
return obj3.event_id;
|
|
}
|
|
obj2 = closure_0(695);
|
|
}
|
|
};
|
|
let items = [
|
|
entry,
|
|
{
|
|
key: "captureMessage",
|
|
value: function captureMessage(arg0, arg1, arg2, arg3) {
|
|
const self = this;
|
|
dependencyMap = arg3;
|
|
const obj = { event_id: closure_0(695).uuid4() };
|
|
const merged = Object.assign(arg2);
|
|
const obj2 = closure_0(695);
|
|
const tmp = closure_0;
|
|
let StringResult = arg0;
|
|
if (!obj3.isParameterizedString(arg0)) {
|
|
const _String = String;
|
|
StringResult = String(arg0);
|
|
}
|
|
obj3 = closure_0(692);
|
|
const isPrimitiveResult = tmp(692).isPrimitive(arg0);
|
|
if (isPrimitiveResult) {
|
|
let eventFromMessageResult = self.eventFromMessage(StringResult, arg1, obj);
|
|
} else {
|
|
eventFromMessageResult = self.eventFromException(arg0, obj);
|
|
}
|
|
let str = "error";
|
|
if (isPrimitiveResult) {
|
|
str = "unknown";
|
|
}
|
|
self._process(() => eventFromMessageResult.then((result) => self._captureEvent(result, obj, closure_1_1)), str);
|
|
return obj.event_id;
|
|
}
|
|
},
|
|
{
|
|
key: "captureEvent",
|
|
value: function captureEvent(sdkProcessingMetadata, originalException, arg2) {
|
|
const self = this;
|
|
dependencyMap = sdkProcessingMetadata;
|
|
closure_2 = arg2;
|
|
const uuid4Result = closure_0(695).uuid4();
|
|
originalException = undefined;
|
|
if (originalException != null) {
|
|
originalException = originalException.originalException;
|
|
}
|
|
if (originalException) {
|
|
if (tmpResult.checkOrSetAlreadyCaught(originalException.originalException)) {
|
|
if (tmp(688).DEBUG_BUILD) {
|
|
const debug = tmp(689).debug;
|
|
debug.log(Client);
|
|
}
|
|
return uuid4Result;
|
|
}
|
|
tmpResult = tmp(695);
|
|
}
|
|
const obj2 = { event_id: uuid4Result };
|
|
const merged = Object.assign(originalException);
|
|
({ capturedSpanScope: Client, capturedSpanIsolationScope: closure_0 } = sdkProcessingMetadata.sdkProcessingMetadata || {});
|
|
let str = sdkProcessingMetadata.type;
|
|
let str2 = "replay";
|
|
if ("replay_event" !== str) {
|
|
if (!str) {
|
|
str = "error";
|
|
}
|
|
str2 = str;
|
|
}
|
|
self._process(() => {
|
|
let tmp4 = Client;
|
|
if (!Client) {
|
|
tmp4 = closure_2;
|
|
}
|
|
return self._captureEvent(closure_1, obj2, tmp4, closure_1_0);
|
|
}, str2);
|
|
return obj2.event_id;
|
|
}
|
|
},
|
|
{
|
|
key: "captureSession",
|
|
value: function captureSession(arg0) {
|
|
this.sendSession(arg0);
|
|
closure_0(710).updateSession(arg0, { init: false });
|
|
}
|
|
},
|
|
{
|
|
key: "getDsn",
|
|
value: function getDsn() {
|
|
return this._dsn;
|
|
}
|
|
},
|
|
{
|
|
key: "getOptions",
|
|
value: function getOptions() {
|
|
return this._options;
|
|
}
|
|
},
|
|
{
|
|
key: "getSdkMetadata",
|
|
value: function getSdkMetadata() {
|
|
return this._options._metadata;
|
|
}
|
|
},
|
|
{
|
|
key: "getTransport",
|
|
value: function getTransport() {
|
|
return this._transport;
|
|
}
|
|
},
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
,
|
|
|
|
];
|
|
const entry1 = { key: "flush", value: null };
|
|
_classCallCheck = asyncGeneratorStep(async function(arg0) {
|
|
const self = this;
|
|
closure_1 = arg0;
|
|
c3 = 0;
|
|
c4 = 0;
|
|
return (async (arg0) => {
|
|
closure_2 = tmp2;
|
|
closure_130_0 = closure_1;
|
|
const _transport = self._transport;
|
|
closure_130_1 = _transport;
|
|
if (!_transport) {
|
|
return true;
|
|
}
|
|
obj8.emit("flush");
|
|
closure_130_2 = await obj8._isClientDoneProcessing(tmp17);
|
|
closure_130_3 = await closure_130_1.flush(closure_130_0);
|
|
let tmp7 = closure_130_2;
|
|
if (closure_130_2) {
|
|
tmp7 = closure_130_3;
|
|
}
|
|
return tmp7;
|
|
})();
|
|
});
|
|
entry1.value = function flush(arg0) {
|
|
const self = this;
|
|
const apply = _classCallCheck.apply;
|
|
if (typeof apply === "unknown") {
|
|
let applyArgumentsResult = HermesBuiltin.applyArguments(self);
|
|
} else {
|
|
applyArgumentsResult = apply(self, arguments);
|
|
}
|
|
return applyArgumentsResult;
|
|
};
|
|
items[8] = entry1;
|
|
const entry2 = { key: "close", value: null };
|
|
_slicedToArray = asyncGeneratorStep(async function(arg0) {
|
|
const self = this;
|
|
closure_1 = arg0;
|
|
c4 = 0;
|
|
c5 = 0;
|
|
return (async (arg0) => {
|
|
closure_3 = self;
|
|
closure_2 = tmp2;
|
|
closure_130_0 = await self.flush(closure_1);
|
|
closure_3.getOptions().enabled = false;
|
|
closure_3.emit("close");
|
|
return closure_130_0;
|
|
})();
|
|
});
|
|
entry2.value = function close(arg0) {
|
|
const self = this;
|
|
const apply = _slicedToArray.apply;
|
|
if (typeof apply === "unknown") {
|
|
let applyArgumentsResult = HermesBuiltin.applyArguments(self);
|
|
} else {
|
|
applyArgumentsResult = apply(self, arguments);
|
|
}
|
|
return applyArgumentsResult;
|
|
};
|
|
items[9] = entry2;
|
|
items[10] = {
|
|
key: "getEventProcessors",
|
|
value: function getEventProcessors() {
|
|
return this._eventProcessors;
|
|
}
|
|
};
|
|
items[11] = {
|
|
key: "addEventProcessor",
|
|
value: function addEventProcessor(arg0) {
|
|
const _eventProcessors = this._eventProcessors;
|
|
_eventProcessors.push(arg0);
|
|
}
|
|
};
|
|
items[12] = {
|
|
key: "init",
|
|
value: function init() {
|
|
const self = this;
|
|
let _isEnabledResult = this._isEnabled();
|
|
if (!_isEnabledResult) {
|
|
const integrations = self._options.integrations;
|
|
_isEnabledResult = integrations.some((name) => {
|
|
name = name.name;
|
|
return name.startsWith("Spotlight");
|
|
});
|
|
}
|
|
if (_isEnabledResult) {
|
|
self._setupIntegrations();
|
|
}
|
|
}
|
|
};
|
|
items[13] = {
|
|
key: "getIntegrationByName",
|
|
value: function getIntegrationByName(arg0) {
|
|
return this._integrations[arg0];
|
|
}
|
|
};
|
|
items[14] = {
|
|
key: "addIntegration",
|
|
value: function addIntegration(arg0) {
|
|
closure_0(752).setupIntegration(this, arg0, this._integrations);
|
|
if (!this._integrations[arg0.name]) {
|
|
const items = [arg0];
|
|
const result = closure_0(752).afterSetupIntegrations(this, items);
|
|
const tmpResult = closure_0(752);
|
|
}
|
|
}
|
|
};
|
|
items[15] = {
|
|
key: "sendEvent",
|
|
value: function sendEvent(arg0) {
|
|
const self = this;
|
|
closure_0 = arg0;
|
|
let obj = arg1;
|
|
if (arg1 === undefined) {
|
|
obj = {};
|
|
}
|
|
self.emit("beforeSendEvent", arg0, obj);
|
|
let eventEnvelope = closure_0(728).createEventEnvelope(arg0, self._dsn, self._options._metadata, self._options.tunnel);
|
|
for (const item10025 of tmp3) {
|
|
let obj3 = closure_0(729);
|
|
let obj4 = closure_0(729);
|
|
eventEnvelope = obj3.addItemToEnvelope(eventEnvelope, obj4.createAttachmentEnvelopeItem(item10025));
|
|
continue;
|
|
}
|
|
const obj2 = closure_0(728);
|
|
const tmp3 = obj.attachments || [];
|
|
self.sendEnvelope(eventEnvelope).then((result) => self.emit("afterSendEvent", closure_0, result));
|
|
}
|
|
};
|
|
items[16] = {
|
|
key: "sendSession",
|
|
value: function sendSession(attrs) {
|
|
const self = this;
|
|
({ release, environment } = this._options);
|
|
if (undefined === environment) {
|
|
environment = closure_0(723).DEFAULT_ENVIRONMENT;
|
|
}
|
|
if ("aggregates" in attrs) {
|
|
const tmp7 = attrs.attrs || {};
|
|
if (!tmp7.release) {
|
|
if (!release) {
|
|
if (closure_0(688).DEBUG_BUILD) {
|
|
const debug2 = closure_0(689).debug;
|
|
debug2.warn(c5);
|
|
}
|
|
}
|
|
}
|
|
tmp7.release = tmp7.release || release;
|
|
tmp7.environment = tmp7.environment || environment;
|
|
attrs.attrs = tmp7;
|
|
} else {
|
|
if (!attrs.release) {
|
|
if (!release) {
|
|
if (closure_0(688).DEBUG_BUILD) {
|
|
const debug = closure_0(689).debug;
|
|
debug.warn(c5);
|
|
}
|
|
}
|
|
}
|
|
attrs.release = attrs.release || release;
|
|
attrs.environment = attrs.environment || environment;
|
|
}
|
|
self.emit("beforeSendSession", attrs);
|
|
self.sendEnvelope(closure_0(728).createSessionEnvelope(attrs, self._dsn, self._options._metadata, self._options.tunnel));
|
|
}
|
|
};
|
|
items[17] = {
|
|
key: "recordDroppedEvent",
|
|
value: function recordDroppedEvent(arg0, arg1) {
|
|
let num = arg2;
|
|
if (arg2 === undefined) {
|
|
num = 1;
|
|
}
|
|
const self = this;
|
|
if (this._options.sendClientReports) {
|
|
const _HermesInternal = HermesInternal;
|
|
const combined = "" + arg0 + ":" + arg1;
|
|
if (closure_0(688).DEBUG_BUILD) {
|
|
const debug = tmp5(689).debug;
|
|
let str3 = "";
|
|
if (num > 1) {
|
|
const _HermesInternal2 = HermesInternal;
|
|
str3 = " (" + num + " times)";
|
|
}
|
|
const _HermesInternal3 = HermesInternal;
|
|
debug.log("Recording outcome: \"" + combined + "\"" + str3);
|
|
}
|
|
let num3 = self._outcomes[combined];
|
|
if (!num3) {
|
|
num3 = 0;
|
|
}
|
|
self._outcomes[combined] = num3 + num;
|
|
tmp5 = closure_0;
|
|
}
|
|
}
|
|
};
|
|
items[18] = {
|
|
key: "on",
|
|
value: function on(arg0, arg1) {
|
|
closure_0 = arg1;
|
|
let set = this._hooks[arg0];
|
|
if (!set) {
|
|
const _Set = Set;
|
|
set = new Set();
|
|
}
|
|
this._hooks[arg0] = set;
|
|
function uniqueCallback() {
|
|
return closure_0(...HermesBuiltin.copyRestArgs());
|
|
}
|
|
set.add(uniqueCallback);
|
|
return () => {
|
|
set.delete(uniqueCallback);
|
|
};
|
|
}
|
|
};
|
|
items[19] = {
|
|
key: "emit",
|
|
value: function emit(arg0) {
|
|
const args = [...arguments].slice();
|
|
if (this._hooks[arg0]) {
|
|
const item = arr.forEach((fn) => fn(...closure_0));
|
|
}
|
|
}
|
|
};
|
|
const entry3 = { key: "sendEnvelope", value: null };
|
|
dependencyMap = asyncGeneratorStep(async function(arg0) {
|
|
const self = this;
|
|
dependencyMap = arg0;
|
|
c6 = 0;
|
|
c7 = 0;
|
|
c5 = 0;
|
|
return (async (arg0, value) => {
|
|
if (c7 === 2) {
|
|
c7 = 3;
|
|
throw new TypeError("Generator functions may not be called on executing generators");
|
|
} else if (tmp7 === 3) {
|
|
if (arg0 === 1) {
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
const obj2 = { value, done: true };
|
|
return obj2;
|
|
} else {
|
|
return { value: "HermesInternal", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c7 = 2;
|
|
if (0 === c6) {
|
|
if (arg0 === 1) {
|
|
c7 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c7 = 3;
|
|
const obj3 = { value, done: true };
|
|
return obj3;
|
|
} else {
|
|
closure_3 = tmp3;
|
|
closure_2 = tmp5;
|
|
self.emit("beforeEnvelope", dependencyMap);
|
|
if (self._isEnabled()) {
|
|
if (tmp33._transport) {
|
|
c5 = 1;
|
|
const _transport = tmp33._transport;
|
|
c6 = 2;
|
|
c7 = 1;
|
|
const obj4 = { value: _transport.send(dependencyMap), done: false };
|
|
return obj4;
|
|
}
|
|
}
|
|
if (self(688).DEBUG_BUILD) {
|
|
const debug2 = self(689).debug;
|
|
debug2.error("Transport disabled");
|
|
}
|
|
c7 = 3;
|
|
const obj5 = { value: {}, done: true };
|
|
return obj5;
|
|
}
|
|
} else if (1 === tmp8) {
|
|
c5 = 0;
|
|
closure_130_0 = closure_4;
|
|
if (self(688).DEBUG_BUILD) {
|
|
const debug = self(689).debug;
|
|
debug.error("Error while sending envelope:", closure_130_0);
|
|
}
|
|
c7 = 3;
|
|
const obj6 = { value: {}, done: true };
|
|
return obj6;
|
|
} else if (arg0 === 1) {
|
|
c7 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c5 = 0;
|
|
c7 = 3;
|
|
const obj7 = { value, done: true };
|
|
return obj7;
|
|
} else {
|
|
c5 = 0;
|
|
c7 = 3;
|
|
const obj = { value, done: true };
|
|
return obj;
|
|
}
|
|
} catch (tmp26) {
|
|
closure_4 = tmp26;
|
|
if (tmp4 === c5) {
|
|
c7 = tmp2;
|
|
throw tmp26;
|
|
} else {
|
|
c6 = tmp;
|
|
}
|
|
}
|
|
}
|
|
})();
|
|
});
|
|
entry3.value = function sendEnvelope(arg0) {
|
|
const self = this;
|
|
const apply = closure_1.apply;
|
|
if (typeof apply === "unknown") {
|
|
let applyArgumentsResult = HermesBuiltin.applyArguments(self);
|
|
} else {
|
|
applyArgumentsResult = apply(self, arguments);
|
|
}
|
|
return applyArgumentsResult;
|
|
};
|
|
items[20] = entry3;
|
|
items[21] = {
|
|
key: "_setupIntegrations",
|
|
value: function _setupIntegrations() {
|
|
const integrations = this._options.integrations;
|
|
this._integrations = closure_0(752).setupIntegrations(this, integrations);
|
|
const obj = closure_0(752);
|
|
const result = closure_0(752).afterSetupIntegrations(this, integrations);
|
|
}
|
|
};
|
|
items[22] = {
|
|
key: "_updateSessionFromEvent",
|
|
value: function _updateSessionFromEvent(status, level) {
|
|
let flag = "fatal" === level.level;
|
|
const exception = level.exception;
|
|
let values;
|
|
if (exception != null) {
|
|
values = exception.values;
|
|
}
|
|
let flag2 = false;
|
|
if (values) {
|
|
flag = false;
|
|
const iter = values[Symbol.iterator]();
|
|
flag2 = true;
|
|
while (iter !== undefined) {
|
|
let mechanism = iter.next().mechanism;
|
|
let handled;
|
|
if (mechanism != null) {
|
|
handled = mechanism.handled;
|
|
}
|
|
if (false === handled) {
|
|
flag = true;
|
|
iter.return();
|
|
flag2 = true;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
let tmp7 = "ok" === status.status;
|
|
let tmp8 = tmp7;
|
|
if (tmp7) {
|
|
tmp8 = 0 === status.errors;
|
|
}
|
|
if (!tmp8) {
|
|
if (tmp7) {
|
|
tmp7 = flag;
|
|
}
|
|
tmp8 = tmp7;
|
|
}
|
|
if (tmp8) {
|
|
let obj2 = flag;
|
|
if (flag) {
|
|
obj2 = { status: "crashed" };
|
|
}
|
|
const obj3 = {};
|
|
const merged = Object.assign(obj2);
|
|
let errors = status.errors;
|
|
if (!errors) {
|
|
if (!flag2) {
|
|
flag2 = flag;
|
|
}
|
|
errors = Number(flag2);
|
|
}
|
|
const self = this;
|
|
obj3.errors = errors;
|
|
closure_0(710).updateSession(status, obj3);
|
|
this.captureSession(status);
|
|
const obj = closure_0(710);
|
|
}
|
|
}
|
|
};
|
|
const entry4 = { key: "_isClientDoneProcessing", value: null };
|
|
React = asyncGeneratorStep(async function(arg0) {
|
|
const self = this;
|
|
closure_1 = arg0;
|
|
c4 = 0;
|
|
c5 = 0;
|
|
return (async (arg0, value) => {
|
|
if (c5 === 2) {
|
|
c5 = 3;
|
|
throw new TypeError("Generator functions may not be called on executing generators");
|
|
} else if (tmp3 === 3) {
|
|
if (arg0 === 1) {
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
const obj2 = { value, done: true };
|
|
return obj2;
|
|
} else {
|
|
return { value: "HermesInternal", done: null };
|
|
}
|
|
} else {
|
|
try {
|
|
c5 = 2;
|
|
if (0 === c4) {
|
|
if (arg0 === 1) {
|
|
c5 = 3;
|
|
throw value;
|
|
} else if (arg0 === 2) {
|
|
c5 = 3;
|
|
const obj3 = { value, done: true };
|
|
return obj3;
|
|
} else {
|
|
_numProcessing = self;
|
|
closure_2 = self;
|
|
closure_130_0 = closure_1;
|
|
closure_130_1 = 0;
|
|
if (closure_1) {
|
|
if (closure_130_1 >= tmp23) {
|
|
c5 = 3;
|
|
}
|
|
}
|
|
const promise = new Promise((arg0) => setTimeout(arg0, 1));
|
|
c4 = 1;
|
|
c5 = 1;
|
|
const obj4 = { value: promise, done: false };
|
|
return obj4;
|
|
}
|
|
} else if (arg0 === 1) {
|
|
c5 = 3;
|
|
throw value;
|
|
} else if (arg0 !== 2) {
|
|
if (_numProcessing._numProcessing) {
|
|
closure_130_1 = closure_130_1 + 1;
|
|
} else {
|
|
c5 = 3;
|
|
return { value: true, done: true };
|
|
}
|
|
}
|
|
c5 = 3;
|
|
const obj = { value, done: true };
|
|
return obj;
|
|
} catch (tmp17) {
|
|
c5 = tmp;
|
|
throw tmp17;
|
|
}
|
|
}
|
|
})();
|
|
});
|
|
entry4.value = function _isClientDoneProcessing(arg0) {
|
|
const self = this;
|
|
const apply = closure_0.apply;
|
|
if (typeof apply === "unknown") {
|
|
let applyArgumentsResult = HermesBuiltin.applyArguments(self);
|
|
} else {
|
|
applyArgumentsResult = apply(self, arguments);
|
|
}
|
|
return applyArgumentsResult;
|
|
};
|
|
items[23] = entry4;
|
|
items[24] = {
|
|
key: "_isEnabled",
|
|
value: function _isEnabled() {
|
|
let tmp = false !== this.getOptions().enabled;
|
|
if (tmp) {
|
|
tmp = undefined !== this._transport;
|
|
}
|
|
return tmp;
|
|
}
|
|
};
|
|
items[25] = {
|
|
key: "_prepareEvent",
|
|
value: function _prepareEvent(type, integrations, arg2, setLastEventId) {
|
|
const self = this;
|
|
dependencyMap = integrations;
|
|
closure_0 = arg2;
|
|
const options = this.getOptions();
|
|
const keys = Object.keys(this._integrations);
|
|
integrations = integrations.integrations;
|
|
let tmp2 = !integrations;
|
|
if (!integrations) {
|
|
let length;
|
|
if (keys != null) {
|
|
length = keys.length;
|
|
}
|
|
tmp2 = length;
|
|
}
|
|
if (tmp2) {
|
|
integrations.integrations = keys;
|
|
}
|
|
self.emit("preprocessEvent", type, integrations);
|
|
if (!type.type) {
|
|
let event_id = type.event_id;
|
|
if (!event_id) {
|
|
event_id = integrations.event_id;
|
|
}
|
|
setLastEventId.setLastEventId(event_id);
|
|
}
|
|
let obj = closure_0(735);
|
|
return closure_0(735).prepareEvent(options, type, integrations, arg2, self, setLastEventId).then((contexts) => {
|
|
if (null === contexts) {
|
|
return contexts;
|
|
} else {
|
|
self.emit("postprocessEvent", contexts, integrations);
|
|
const obj = { trace: closure_0(integrations[20]).getTraceContextFromScope(closure_0) };
|
|
const merged = Object.assign(contexts.contexts);
|
|
contexts.contexts = obj;
|
|
const obj2 = closure_0(integrations[20]);
|
|
const obj4 = { dynamicSamplingContext: closure_0(integrations[21]).getDynamicSamplingContextFromScope(self, closure_0) };
|
|
const merged1 = Object.assign(contexts.sdkProcessingMetadata);
|
|
contexts.sdkProcessingMetadata = obj4;
|
|
return contexts;
|
|
}
|
|
});
|
|
}
|
|
};
|
|
items[26] = {
|
|
key: "_captureEvent",
|
|
value: function _captureEvent(type) {
|
|
let obj = arg1;
|
|
if (arg1 === undefined) {
|
|
obj = {};
|
|
}
|
|
let currentScope = arg2;
|
|
if (arg2 === undefined) {
|
|
currentScope = closure_0(713).getCurrentScope();
|
|
const obj2 = closure_0(713);
|
|
}
|
|
let isolationScope = arg3;
|
|
if (arg3 === undefined) {
|
|
isolationScope = closure_0(713).getIsolationScope();
|
|
const obj3 = closure_0(713);
|
|
}
|
|
if (tmp9) {
|
|
let debug = tmp7(689).debug;
|
|
const tmp7Result = tmp7(753);
|
|
const _HermesInternal = HermesInternal;
|
|
debug.log("Captured error event `" + tmp7(753).getPossibleEventMessages(type)[0] || "<unknown>" + "`");
|
|
const tmp10 = tmp7(753).getPossibleEventMessages(type)[0] || "<unknown>";
|
|
}
|
|
tmp9 = closure_0(688).DEBUG_BUILD && undefined === type.type;
|
|
return this._processEvent(type, obj, currentScope, isolationScope).then((event_id) => event_id.event_id, (message) => {
|
|
if (closure_1_0(dependencyMap[7]).DEBUG_BUILD) {
|
|
let tmp4 = message && typeof message === "object";
|
|
if (tmp4) {
|
|
tmp4 = closure_1_7 in message;
|
|
}
|
|
if (tmp4) {
|
|
const debug2 = tmp(tmp2[8]).debug;
|
|
debug2.log(message.message);
|
|
} else {
|
|
let tmp6 = message && typeof message === "object";
|
|
if (tmp6) {
|
|
tmp6 = closure_1_6 in message;
|
|
}
|
|
const debug = tmp(tmp2[8]).debug;
|
|
const warn = debug.warn;
|
|
if (tmp6) {
|
|
warn(message.message);
|
|
} else {
|
|
warn(message);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
items[27] = {
|
|
key: "_processEvent",
|
|
value: function _processEvent(type, arg1, arg2, arg3) {
|
|
const self = this;
|
|
dependencyMap = type;
|
|
const data = arg1;
|
|
let session = arg2;
|
|
const session2 = arg3;
|
|
const options = this.getOptions();
|
|
const sampleRate = options.sampleRate;
|
|
closure_6 = "transaction" === type.type;
|
|
closure_7 = tmp2;
|
|
closure_8 = "before send for type `" + type.type || "error" + "`";
|
|
if (undefined !== sampleRate) {
|
|
const parseSampleRateResult = str2(701).parseSampleRate(sampleRate);
|
|
let obj = str2(701);
|
|
}
|
|
if (undefined === type.type) {
|
|
if (typeof parseSampleRateResult === "number") {
|
|
if (obj4.safeMathRandom() > parseSampleRateResult) {
|
|
self.recordDroppedEvent("sample_rate", "error");
|
|
let _HermesInternal = HermesInternal;
|
|
let obj2 = { message: "Discarding event because it's not included in the random sample (sampling rate = " + sampleRate + ")" };
|
|
obj2[closure_7] = true;
|
|
return tmp9(738).rejectedSyncPromise(obj2);
|
|
}
|
|
obj4 = str2(696);
|
|
tmp9 = str2;
|
|
}
|
|
}
|
|
let str = type.type;
|
|
str2 = "replay";
|
|
if ("replay_event" !== str) {
|
|
if (!str) {
|
|
str = "error";
|
|
}
|
|
str2 = str;
|
|
}
|
|
const _prepareEventResult = self._prepareEvent(type, arg1, arg2, arg3);
|
|
let tmp3 = type.type || "error";
|
|
let nextPromise = self._prepareEvent(type, arg1, arg2, arg3).then((result) => {
|
|
if (null === result) {
|
|
self.recordDroppedEvent("event_processor", str2);
|
|
let obj2 = { message: "An event processor returned `null`, will not send event." };
|
|
obj2[closure_7] = true;
|
|
throw obj2;
|
|
} else {
|
|
if (data.data) {
|
|
if (true === tmp16.data.__sentry__) {
|
|
return result;
|
|
}
|
|
}
|
|
const promise = (function processBeforeSend(self, options, sdkProcessingMetadata, arg3) {
|
|
({ beforeSend, beforeSendTransaction, beforeSendSpan, ignoreSpans } = options);
|
|
if (closure_1_8(sdkProcessingMetadata)) {
|
|
if (beforeSend) {
|
|
return beforeSend(sdkProcessingMetadata, arg3);
|
|
}
|
|
}
|
|
let tmp = sdkProcessingMetadata;
|
|
if (self(sdkProcessingMetadata)) {
|
|
if (beforeSendSpan) {
|
|
const result = closure_0(combined[27]).convertTransactionEventToSpanJson(sdkProcessingMetadata);
|
|
let length;
|
|
if (ignoreSpans != null) {
|
|
length = ignoreSpans.length;
|
|
}
|
|
if (length) {
|
|
if (tmp4Result.shouldIgnoreSpan(result, ignoreSpans)) {
|
|
return null;
|
|
}
|
|
tmp4Result = tmp4(tmp6[28]);
|
|
}
|
|
let mergeResult = sdkProcessingMetadata;
|
|
if (beforeSendSpan) {
|
|
const beforeSendSpanResult = beforeSendSpan(result);
|
|
if (beforeSendSpanResult) {
|
|
const tmp4Result4 = tmp4(tmp6[30]);
|
|
mergeResult = tmp4Result4.merge(sdkProcessingMetadata, tmp4(tmp6[27]).convertSpanJsonToTransactionEvent(beforeSendSpanResult));
|
|
const tmp4Result5 = tmp4(tmp6[27]);
|
|
} else {
|
|
tmp4(tmp6[29]).showSpanDropWarning();
|
|
mergeResult = sdkProcessingMetadata;
|
|
const tmp4Result6 = tmp4(tmp6[29]);
|
|
}
|
|
}
|
|
let tmp2 = mergeResult;
|
|
if (mergeResult.spans) {
|
|
const items = [];
|
|
const spans = mergeResult.spans;
|
|
for (const item10054 of spans) {
|
|
let tmp19 = item10054;
|
|
let length1;
|
|
if (ignoreSpans != null) {
|
|
length1 = ignoreSpans.length;
|
|
}
|
|
if (length1) {
|
|
let tmp22 = closure_0;
|
|
let tmp24 = combined;
|
|
let obj6 = closure_0(combined[28]);
|
|
if (obj6.shouldIgnoreSpan(tmp19, ignoreSpans)) {
|
|
let tmp22Result = tmp22(tmp24[28]);
|
|
let reparentChildSpansResult = tmp22Result.reparentChildSpans(spans, tmp19);
|
|
continue;
|
|
}
|
|
}
|
|
if (beforeSendSpan) {
|
|
let beforeSendSpanResult1 = beforeSendSpan(tmp19);
|
|
if (beforeSendSpanResult1) {
|
|
let arr = items.push(tmp30);
|
|
} else {
|
|
let obj7 = closure_0(combined[29]);
|
|
let showSpanDropWarningResult1 = obj7.showSpanDropWarning();
|
|
let arr4 = items.push(tmp19);
|
|
}
|
|
} else {
|
|
let arr5 = items.push(tmp19);
|
|
}
|
|
}
|
|
const diff = mergeResult.spans.length - items.length;
|
|
if (diff) {
|
|
self.recordDroppedEvent("before_send", "span", diff);
|
|
}
|
|
mergeResult.spans = items;
|
|
tmp2 = mergeResult;
|
|
}
|
|
const obj = closure_0(combined[27]);
|
|
} else {
|
|
tmp2 = sdkProcessingMetadata;
|
|
}
|
|
tmp = tmp2;
|
|
if (beforeSendTransaction) {
|
|
if (tmp2.spans) {
|
|
const obj2 = {};
|
|
const merged = Object.assign(sdkProcessingMetadata.sdkProcessingMetadata);
|
|
obj2.spanCountBeforeProcessing = tmp2.spans.length;
|
|
tmp2.sdkProcessingMetadata = obj2;
|
|
}
|
|
return beforeSendTransaction(tmp2, arg3);
|
|
}
|
|
}
|
|
return tmp;
|
|
})(self, options, result, data);
|
|
const _HermesInternal = HermesInternal;
|
|
str2 = "";
|
|
const combined = "" + closure_8 + " must return `null` or a valid event.";
|
|
if (obj.isThenable(promise)) {
|
|
let nextPromise = promise.then((result) => {
|
|
if (!obj.isPlainObject(result)) {
|
|
if (null !== result) {
|
|
const obj2 = { message: combined };
|
|
obj2[closure_6] = true;
|
|
throw obj2;
|
|
}
|
|
}
|
|
return result;
|
|
}, (arg0) => {
|
|
const obj = { message: "" + closure_0 + " rejected with " + arg0 };
|
|
obj[closure_6] = true;
|
|
throw obj;
|
|
});
|
|
} else {
|
|
nextPromise = promise;
|
|
if (!tmp8Result.isPlainObject(promise)) {
|
|
nextPromise = promise;
|
|
if (null !== promise) {
|
|
const obj3 = { message: combined };
|
|
obj3[closure_6] = true;
|
|
throw obj3;
|
|
}
|
|
}
|
|
tmp8Result = str2(type[13]);
|
|
}
|
|
return nextPromise;
|
|
}
|
|
});
|
|
return self._prepareEvent(type, arg1, arg2, arg3).then((result) => {
|
|
if (null === result) {
|
|
self.recordDroppedEvent("event_processor", str2);
|
|
let obj2 = { message: "An event processor returned `null`, will not send event." };
|
|
obj2[closure_7] = true;
|
|
throw obj2;
|
|
} else {
|
|
if (data.data) {
|
|
if (true === tmp16.data.__sentry__) {
|
|
return result;
|
|
}
|
|
}
|
|
const promise = (function processBeforeSend(self, options, sdkProcessingMetadata, arg3) {
|
|
({ beforeSend, beforeSendTransaction, beforeSendSpan, ignoreSpans } = options);
|
|
if (closure_1_8(sdkProcessingMetadata)) {
|
|
if (beforeSend) {
|
|
return beforeSend(sdkProcessingMetadata, arg3);
|
|
}
|
|
}
|
|
let tmp = sdkProcessingMetadata;
|
|
if (self(sdkProcessingMetadata)) {
|
|
if (beforeSendSpan) {
|
|
const result = closure_0(combined[27]).convertTransactionEventToSpanJson(sdkProcessingMetadata);
|
|
let length;
|
|
if (ignoreSpans != null) {
|
|
length = ignoreSpans.length;
|
|
}
|
|
if (length) {
|
|
if (tmp4Result.shouldIgnoreSpan(result, ignoreSpans)) {
|
|
return null;
|
|
}
|
|
tmp4Result = tmp4(tmp6[28]);
|
|
}
|
|
let mergeResult = sdkProcessingMetadata;
|
|
if (beforeSendSpan) {
|
|
const beforeSendSpanResult = beforeSendSpan(result);
|
|
if (beforeSendSpanResult) {
|
|
const tmp4Result4 = tmp4(tmp6[30]);
|
|
mergeResult = tmp4Result4.merge(sdkProcessingMetadata, tmp4(tmp6[27]).convertSpanJsonToTransactionEvent(beforeSendSpanResult));
|
|
const tmp4Result5 = tmp4(tmp6[27]);
|
|
} else {
|
|
tmp4(tmp6[29]).showSpanDropWarning();
|
|
mergeResult = sdkProcessingMetadata;
|
|
const tmp4Result6 = tmp4(tmp6[29]);
|
|
}
|
|
}
|
|
let tmp2 = mergeResult;
|
|
if (mergeResult.spans) {
|
|
const items = [];
|
|
const spans = mergeResult.spans;
|
|
for (const item10054 of spans) {
|
|
let tmp19 = item10054;
|
|
let length1;
|
|
if (ignoreSpans != null) {
|
|
length1 = ignoreSpans.length;
|
|
}
|
|
if (length1) {
|
|
let tmp22 = closure_0;
|
|
let tmp24 = combined;
|
|
let obj6 = closure_0(combined[28]);
|
|
if (obj6.shouldIgnoreSpan(tmp19, ignoreSpans)) {
|
|
let tmp22Result = tmp22(tmp24[28]);
|
|
let reparentChildSpansResult = tmp22Result.reparentChildSpans(spans, tmp19);
|
|
continue;
|
|
}
|
|
}
|
|
if (beforeSendSpan) {
|
|
let beforeSendSpanResult1 = beforeSendSpan(tmp19);
|
|
if (beforeSendSpanResult1) {
|
|
let arr = items.push(tmp30);
|
|
} else {
|
|
let obj7 = closure_0(combined[29]);
|
|
let showSpanDropWarningResult1 = obj7.showSpanDropWarning();
|
|
let arr4 = items.push(tmp19);
|
|
}
|
|
} else {
|
|
let arr5 = items.push(tmp19);
|
|
}
|
|
}
|
|
const diff = mergeResult.spans.length - items.length;
|
|
if (diff) {
|
|
self.recordDroppedEvent("before_send", "span", diff);
|
|
}
|
|
mergeResult.spans = items;
|
|
tmp2 = mergeResult;
|
|
}
|
|
const obj = closure_0(combined[27]);
|
|
} else {
|
|
tmp2 = sdkProcessingMetadata;
|
|
}
|
|
tmp = tmp2;
|
|
if (beforeSendTransaction) {
|
|
if (tmp2.spans) {
|
|
const obj2 = {};
|
|
const merged = Object.assign(sdkProcessingMetadata.sdkProcessingMetadata);
|
|
obj2.spanCountBeforeProcessing = tmp2.spans.length;
|
|
tmp2.sdkProcessingMetadata = obj2;
|
|
}
|
|
return beforeSendTransaction(tmp2, arg3);
|
|
}
|
|
}
|
|
return tmp;
|
|
})(self, options, result, data);
|
|
const _HermesInternal = HermesInternal;
|
|
str2 = "";
|
|
const combined = "" + closure_8 + " must return `null` or a valid event.";
|
|
if (obj.isThenable(promise)) {
|
|
let nextPromise = promise.then((result) => {
|
|
if (!obj.isPlainObject(result)) {
|
|
if (null !== result) {
|
|
const obj2 = { message: combined };
|
|
obj2[closure_6] = true;
|
|
throw obj2;
|
|
}
|
|
}
|
|
return result;
|
|
}, (arg0) => {
|
|
const obj = { message: "" + closure_0 + " rejected with " + arg0 };
|
|
obj[closure_6] = true;
|
|
throw obj;
|
|
});
|
|
} else {
|
|
nextPromise = promise;
|
|
if (!tmp8Result.isPlainObject(promise)) {
|
|
nextPromise = promise;
|
|
if (null !== promise) {
|
|
const obj3 = { message: combined };
|
|
obj3[closure_6] = true;
|
|
throw obj3;
|
|
}
|
|
}
|
|
tmp8Result = str2(type[13]);
|
|
}
|
|
return nextPromise;
|
|
}
|
|
}).then((sdkProcessingMetadata) => {
|
|
if (null === sdkProcessingMetadata) {
|
|
self.recordDroppedEvent("before_send", str2);
|
|
if (closure_6) {
|
|
self.recordDroppedEvent("before_send", "span", 1 + type.spans || [].length);
|
|
const arr = type.spans || [];
|
|
}
|
|
const _HermesInternal = HermesInternal;
|
|
const obj3 = { message: "" + closure_8 + " returned `null`, will not send event." };
|
|
obj3[closure_7] = true;
|
|
throw obj3;
|
|
} else {
|
|
session = session.getSession();
|
|
if (!session) {
|
|
session = session2.getSession();
|
|
}
|
|
let tmp3 = closure_7;
|
|
if (closure_7) {
|
|
tmp3 = session;
|
|
}
|
|
if (tmp3) {
|
|
const result = self._updateSessionFromEvent(session, sdkProcessingMetadata);
|
|
}
|
|
if (closure_6) {
|
|
sdkProcessingMetadata = sdkProcessingMetadata.sdkProcessingMetadata;
|
|
let num;
|
|
if (sdkProcessingMetadata != null) {
|
|
num = sdkProcessingMetadata.spanCountBeforeProcessing;
|
|
}
|
|
if (!num) {
|
|
num = 0;
|
|
}
|
|
let num3 = 0;
|
|
if (sdkProcessingMetadata.spans) {
|
|
num3 = sdkProcessingMetadata.spans.length;
|
|
}
|
|
const diff = num - num3;
|
|
if (diff > 0) {
|
|
self.recordDroppedEvent("before_send", "span", diff);
|
|
}
|
|
}
|
|
const transaction_info = sdkProcessingMetadata.transaction_info;
|
|
if (closure_6) {
|
|
if (transaction_info) {
|
|
if (sdkProcessingMetadata.transaction !== type.transaction) {
|
|
const obj = {};
|
|
const merged = Object.assign(transaction_info);
|
|
obj.source = "custom";
|
|
sdkProcessingMetadata.transaction_info = obj;
|
|
}
|
|
}
|
|
}
|
|
self.sendEvent(sdkProcessingMetadata, closure_2);
|
|
return sdkProcessingMetadata;
|
|
}
|
|
}).then(null, (originalException) => {
|
|
let tmp = originalException && typeof originalException === "object";
|
|
if (tmp) {
|
|
tmp = closure_7 in originalException;
|
|
}
|
|
if (!tmp) {
|
|
let tmp3 = originalException && typeof originalException === "object";
|
|
if (tmp3) {
|
|
tmp3 = closure_6 in originalException;
|
|
}
|
|
if (!tmp3) {
|
|
const obj = { mechanism: { handled: false, type: "internal" }, data: { __sentry__: true }, originalException };
|
|
self.captureException(originalException, obj);
|
|
const _HermesInternal = HermesInternal;
|
|
const obj2 = { message: "Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\nReason: " + originalException };
|
|
obj2[closure_6] = true;
|
|
throw obj2;
|
|
}
|
|
}
|
|
throw originalException;
|
|
});
|
|
}
|
|
};
|
|
items[28] = {
|
|
key: "_process",
|
|
value: function _process(arg0, arg1) {
|
|
const self = this;
|
|
closure_0 = arg1;
|
|
this._numProcessing = this._numProcessing + 1;
|
|
const _promiseBuffer = this._promiseBuffer;
|
|
_promiseBuffer.add(arg0).then((result) => {
|
|
self._numProcessing = self._numProcessing - 1;
|
|
return result;
|
|
}, (arg0) => {
|
|
self._numProcessing = self._numProcessing - 1;
|
|
if (arg0 === closure_0(_self[4]).SENTRY_BUFFER_FULL_ERROR) {
|
|
self.recordDroppedEvent("queue_overflow", closure_0);
|
|
}
|
|
return arg0;
|
|
});
|
|
}
|
|
};
|
|
items[29] = {
|
|
key: "_clearOutcomes",
|
|
value: function _clearOutcomes() {
|
|
this._outcomes = {};
|
|
const entries = Object.entries(this._outcomes);
|
|
return entries.map((item) => {
|
|
[str, tmp] = item;
|
|
const tmp2 = _slicedToArray(str.split(":"), 2);
|
|
return { reason: tmp2[0], category: tmp2[1], quantity: tmp };
|
|
});
|
|
}
|
|
};
|
|
items[30] = {
|
|
key: "_flushOutcomes",
|
|
value: function _flushOutcomes() {
|
|
if (closure_0(688).DEBUG_BUILD) {
|
|
const debug = tmp(689).debug;
|
|
debug.log("Flushing outcomes...");
|
|
}
|
|
const self = this;
|
|
const _clearOutcomesResult = this._clearOutcomes();
|
|
if (0 !== _clearOutcomesResult.length) {
|
|
const DEBUG_BUILD = tmp(688).DEBUG_BUILD;
|
|
if (self._dsn) {
|
|
if (DEBUG_BUILD) {
|
|
const debug4 = tmp(689).debug;
|
|
debug4.log("Sending outcomes:", _clearOutcomesResult);
|
|
}
|
|
let tunnel = self._options.tunnel;
|
|
if (tunnel) {
|
|
tunnel = tmp(702).dsnToString(self._dsn);
|
|
const tmpResult2 = tmp(702);
|
|
}
|
|
self.sendEnvelope(tmp(754).createClientReportEnvelope(_clearOutcomesResult, tunnel));
|
|
const tmpResult = tmp(754);
|
|
} else if (DEBUG_BUILD) {
|
|
const debug3 = tmp(689).debug;
|
|
debug3.log("No dsn provided, will not send outcomes");
|
|
}
|
|
} else if (tmp(688).DEBUG_BUILD) {
|
|
const debug2 = tmp(689).debug;
|
|
debug2.log("No outcomes to send");
|
|
}
|
|
}
|
|
};
|
|
|
|
export const Client = _createClass(Client, items);
|