597 lines
28 KiB
JavaScript
597 lines
28 KiB
JavaScript
// Module ID: 1128
|
|
// Function ID: 12851
|
|
// Name: _captureAppStart
|
|
// Dependencies: []
|
|
// Exports: _clearRootComponentCreationTimestampMs, _setRootComponentCreationTimestampMs, appStartIntegration, captureAppStart
|
|
|
|
// Module 1128 (_captureAppStart)
|
|
function _captureAppStart(isManual) {
|
|
const dependencyMap = isManual.isManual;
|
|
return fn(this, undefined, undefined, function*() {
|
|
let integrationByName;
|
|
let obj = integrationByName(closure_1[1]);
|
|
const client = obj.getClient();
|
|
if (client) {
|
|
let closure_6 = closure_1;
|
|
let tmp9 = null;
|
|
const result = 1000 * integrationByName(closure_1[1]).timestampInSeconds();
|
|
if (integrationByName(closure_1[2]).NATIVE.enableNative) {
|
|
const NATIVE = integrationByName(closure_1[2]).NATIVE;
|
|
const tmp12 = yield NATIVE.fetchNativeFrames();
|
|
tmp9 = tmp12;
|
|
const debug2 = integrationByName(closure_1[1]).debug;
|
|
debug2.log("[AppStart] Captured end frames for app start.", tmp12);
|
|
}
|
|
while (true) {
|
|
let tmp16 = callback;
|
|
obj = { timestampMs: result, endFrames: tmp9 };
|
|
let tmp17 = callback(obj);
|
|
let tmp18 = closure_4;
|
|
integrationByName = client.getIntegrationByName(closure_4);
|
|
if (null === integrationByName) {
|
|
break;
|
|
} else {
|
|
let tmp21 = integrationByName;
|
|
if (undefined === integrationByName) {
|
|
break;
|
|
} else {
|
|
let tmp22 = integrationByName;
|
|
let result1 = integrationByName.captureStandaloneAppStart();
|
|
// break
|
|
}
|
|
}
|
|
let tmp23 = yield result1;
|
|
}
|
|
const obj3 = integrationByName(closure_1[1]);
|
|
} else {
|
|
const debug = integrationByName(closure_1[1]).debug;
|
|
debug.warn("[AppStart] Could not capture App Start, missing client.");
|
|
}
|
|
});
|
|
}
|
|
function setRootComponentCreationTimestampMs(arg0) {
|
|
let timestampMs;
|
|
if (null != timestampMs) {
|
|
timestampMs = timestampMs.timestampMs;
|
|
}
|
|
if (timestampMs) {
|
|
const debug = arg1(dependencyMap[1]).debug;
|
|
debug.warn("Setting Root component creation timestamp after app start end is set.");
|
|
}
|
|
if (closure_7) {
|
|
const debug2 = arg1(dependencyMap[1]).debug;
|
|
debug2.warn("Overwriting already set root component creation timestamp.");
|
|
}
|
|
closure_7 = arg0;
|
|
let closure_8 = true;
|
|
}
|
|
function setSpanDurationAsMeasurementOnTransactionEvent(measurements, arg1, timestamp) {
|
|
if (timestamp.timestamp) {
|
|
if (timestamp.start_timestamp) {
|
|
measurements.measurements = measurements.measurements || {};
|
|
const obj = { value: 1000 * (timestamp.timestamp - timestamp.start_timestamp), unit: "millisecond" };
|
|
measurements.measurements[arg1] = obj;
|
|
}
|
|
}
|
|
const debug = arg1(dependencyMap[1]).debug;
|
|
debug.warn("Span is missing start or end timestamp. Cam not set measurement on transaction event.");
|
|
}
|
|
let closure_2 = importDefault(dependencyMap[0]);
|
|
let fn = this;
|
|
if (this) {
|
|
fn = this.__awaiter;
|
|
}
|
|
if (!fn) {
|
|
fn = (arg0, arg1, arg2, arg3) => {
|
|
let _Promise = arg2;
|
|
arg1 = arg0;
|
|
const dependencyMap = arg1;
|
|
if (!arg2) {
|
|
_Promise = Promise;
|
|
}
|
|
_Promise = new _Promise((arg0, arg1) => {
|
|
function fulfilled(arg0) {
|
|
step(iter.next(arg0));
|
|
}
|
|
let arg3 = function rejected(arg0) {
|
|
step(iter.throw(arg0));
|
|
};
|
|
function step(iter) {
|
|
if (iter.done) {
|
|
iter(iter.value);
|
|
} else {
|
|
function adopt(value) {
|
|
let tmp = value;
|
|
if (!(value instanceof ctor)) {
|
|
const prototype = ctor.prototype;
|
|
tmp = new ctor((arg0) => {
|
|
arg0(arg0);
|
|
});
|
|
}
|
|
return tmp;
|
|
}(iter.value).then(fulfilled, iter);
|
|
const promise = function adopt(value) {
|
|
let tmp = value;
|
|
if (!(value instanceof ctor)) {
|
|
const prototype = ctor.prototype;
|
|
tmp = new ctor((arg0) => {
|
|
arg0(arg0);
|
|
});
|
|
}
|
|
return tmp;
|
|
}(iter.value);
|
|
}
|
|
}
|
|
let items = arg1;
|
|
if (!arg1) {
|
|
items = [];
|
|
}
|
|
const iter = arg3.apply(arg0, items);
|
|
arg3 = iter;
|
|
step(iter.next());
|
|
});
|
|
return _Promise;
|
|
};
|
|
}
|
|
let closure_4 = "AppStart";
|
|
let closure_5;
|
|
let closure_6 = false;
|
|
let closure_7;
|
|
let closure_8 = false;
|
|
function _setAppStartEndData(arg0) {
|
|
if (closure_5) {
|
|
const debug = arg1(dependencyMap[1]).debug;
|
|
debug.warn("Overwriting already set app start end data.");
|
|
}
|
|
closure_5 = arg0;
|
|
}
|
|
|
|
export const captureAppStart = function captureAppStart() {
|
|
return _captureAppStart({ isManual: true });
|
|
};
|
|
export { _captureAppStart };
|
|
export { setRootComponentCreationTimestampMs };
|
|
export const _setRootComponentCreationTimestampMs = function _setRootComponentCreationTimestampMs(arg0) {
|
|
setRootComponentCreationTimestampMs(arg0);
|
|
let closure_8 = false;
|
|
};
|
|
export { _setAppStartEndData };
|
|
export function _clearRootComponentCreationTimestampMs() {
|
|
let closure_7;
|
|
}
|
|
export const appStartIntegration = function appStartIntegration() {
|
|
function attachAppStartToTransactionEvent(arg0) {
|
|
let closure_0 = arg0;
|
|
return callback2(this, undefined, undefined, function*() {
|
|
if (!closure_3) {
|
|
let warnResult2 = lib;
|
|
const contexts = lib.contexts;
|
|
let trace;
|
|
if (null !== contexts) {
|
|
if (undefined !== contexts) {
|
|
trace = contexts.trace;
|
|
}
|
|
}
|
|
if (trace) {
|
|
if (!lib) {
|
|
if (closure_5) {
|
|
if (closure_5 !== lib.contexts.trace.span_id) {
|
|
const debug3 = lib(contexts[1]).debug;
|
|
debug3.warn("[AppStart] First started active root span id does not match the transaction event span id. Can not attached app start.");
|
|
}
|
|
} else {
|
|
const debug2 = lib(contexts[1]).debug;
|
|
debug2.warn("[AppStart] No first started active root span id recorded. Can not attach app start.");
|
|
}
|
|
}
|
|
const NATIVE = lib(contexts[2]).NATIVE;
|
|
const tmp21 = yield NATIVE.fetchNativeAppStart();
|
|
if (tmp21) {
|
|
if (tmp21.has_fetched) {
|
|
warnResult2 = lib;
|
|
warnResult2 = contexts;
|
|
const debug17 = lib(contexts[1]).debug;
|
|
warnResult2 = debug17.warn("[AppStart] Measured app start metrics were already reported from the native layer.");
|
|
} else {
|
|
const app_start_timestamp_ms = tmp21.app_start_timestamp_ms;
|
|
if (app_start_timestamp_ms) {
|
|
let timestampMs;
|
|
if (null != closure_5) {
|
|
timestampMs = closure_5.timestampMs;
|
|
}
|
|
if (!timestampMs) {
|
|
let obj = lib(contexts[6]);
|
|
timestampMs = obj.getBundleStartTimestampMs();
|
|
}
|
|
if (timestampMs) {
|
|
if (lib.start_timestamp) {
|
|
if (app_start_timestamp_ms >= 1000 * lib.start_timestamp - 60000) {
|
|
const diff = timestampMs - app_start_timestamp_ms;
|
|
if (diff >= 60000) {
|
|
warnResult2 = lib;
|
|
warnResult2 = contexts;
|
|
const debug16 = lib(contexts[1]).debug;
|
|
warnResult2 = debug16.warn("[AppStart] App start duration is over a minute long, not adding app start span.");
|
|
} else if (diff < 0) {
|
|
warnResult2 = lib;
|
|
warnResult2 = contexts;
|
|
const debug15 = lib(contexts[1]).debug;
|
|
warnResult2 = debug15.warn("[AppStart] Last recorded app start end timestamp is before the app start timestamp.", "This is usually caused by missing `Sentry.wrap(RootComponent)` call.");
|
|
} else {
|
|
closure_3 = true;
|
|
warnResult2 = lib;
|
|
let data = lib.contexts.trace.data;
|
|
if (!data) {
|
|
data = {};
|
|
}
|
|
lib.contexts.trace.data = data;
|
|
lib.contexts.trace.data[lib(contexts[7]).SEMANTIC_ATTRIBUTE_SENTRY_OP] = lib(contexts[5]).UI_LOAD;
|
|
lib.contexts.trace.op = lib(contexts[5]).UI_LOAD;
|
|
const tmp48 = lib(contexts[8]);
|
|
const tmp49 = closure_6 ? tmp48.SPAN_ORIGIN_MANUAL_APP_START : tmp48.SPAN_ORIGIN_AUTO_APP_START;
|
|
lib.contexts.trace.data[lib(contexts[1]).SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = tmp49;
|
|
lib.contexts.trace.origin = tmp49;
|
|
const result = app_start_timestamp_ms / 1000;
|
|
lib.start_timestamp = result;
|
|
lib.spans = lib.spans || [];
|
|
const spans = lib.spans;
|
|
const found = spans.find((op) => "ui.load.initial_display" === op.op);
|
|
if (found) {
|
|
found.start_timestamp = result;
|
|
callback2(lib, "time_to_initial_display", found);
|
|
}
|
|
const found1 = spans.find((op) => "ui.load.full_display" === op.op);
|
|
if (found1) {
|
|
found1.start_timestamp = result;
|
|
callback2(lib, "time_to_full_display", found1);
|
|
}
|
|
const result1 = timestampMs / 1000;
|
|
let timestamp = lib.timestamp;
|
|
if (timestamp) {
|
|
timestamp = lib.timestamp < result1;
|
|
}
|
|
if (timestamp) {
|
|
const debug8 = lib(contexts[1]).debug;
|
|
debug8.log("[AppStart] Transaction event timestamp is before app start end. Adjusting transaction event timestamp.");
|
|
lib.timestamp = result1;
|
|
}
|
|
if ("cold" === tmp21.type) {
|
|
let APP_START_WARM = lib(contexts[5]).APP_START_COLD;
|
|
} else {
|
|
APP_START_WARM = lib(contexts[5]).APP_START_WARM;
|
|
}
|
|
let obj2 = lib(contexts[6]);
|
|
obj = { op: APP_START_WARM };
|
|
let str12 = "Warm Start";
|
|
if ("cold" === tmp21.type) {
|
|
str12 = "Cold Start";
|
|
}
|
|
obj.description = str12;
|
|
obj.start_timestamp = result;
|
|
obj.timestamp = result1;
|
|
obj.trace_id = lib.contexts.trace.trace_id;
|
|
obj.parent_span_id = lib.contexts.trace.span_id;
|
|
obj.origin = tmp49;
|
|
const spanJSON = obj2.createSpanJSON(obj);
|
|
let endFrames;
|
|
if (null != closure_5) {
|
|
endFrames = closure_5.endFrames;
|
|
}
|
|
if (endFrames) {
|
|
endFrames = closure_5.endFrames;
|
|
if (endFrames.totalFrames <= 0) {
|
|
if (endFrames.slowFrames <= 0) {
|
|
if (endFrames.totalFrames <= 0) {
|
|
const debug10 = lib(contexts[1]).debug;
|
|
const _HermesInternal = HermesInternal;
|
|
debug10.warn("[AppStart] Detected zero slow or frozen frames. Not adding measurements to spanId (" + spanJSON.span_id + ").");
|
|
}
|
|
}
|
|
}
|
|
spanJSON.data = spanJSON.data || {};
|
|
({ totalFrames: tmp77.data.frames.total, slowFrames: tmp77.data.frames.slow, frozenFrames: tmp77.data.frames.frozen } = endFrames);
|
|
const debug9 = lib(contexts[1]).debug;
|
|
obj = { spanId: spanJSON.span_id };
|
|
({ totalFrames: obj6.total, slowFrames: obj6.slow, frozenFrames: obj6.frozen } = endFrames);
|
|
obj.frameData = {};
|
|
debug9.log("[AppStart] Attached frame data to span.", obj);
|
|
const obj1 = {};
|
|
}
|
|
const bundleStartTimestampMs = lib(contexts[6]).getBundleStartTimestampMs();
|
|
let childSpanJSON;
|
|
if (bundleStartTimestampMs) {
|
|
const result2 = bundleStartTimestampMs / 1000;
|
|
if (result2 < spanJSON.start_timestamp) {
|
|
warnResult2 = lib;
|
|
warnResult2 = contexts;
|
|
const debug12 = lib(contexts[1]).debug;
|
|
warnResult2 = debug12.warn("Bundle start timestamp is before the app start span start timestamp. Skipping JS execution span.");
|
|
} else {
|
|
warnResult2 = lib;
|
|
warnResult2 = contexts;
|
|
if (tmp89) {
|
|
obj2 = { description: "JS Bundle Execution Before React Root", start_timestamp: result2, timestamp: tmp89 / 1000 };
|
|
const tmp99 = lib(contexts[8]);
|
|
obj2.origin = closure_8 ? tmp99.SPAN_ORIGIN_MANUAL_APP_START : tmp99.SPAN_ORIGIN_AUTO_APP_START;
|
|
childSpanJSON = warnResult2(warnResult2[6]).createChildSpanJSON(spanJSON, obj2);
|
|
const warnResult2Result = warnResult2(warnResult2[6]);
|
|
} else {
|
|
const debug11 = warnResult2(warnResult2[1]).debug;
|
|
debug11.warn("Missing the root component first constructor call timestamp.");
|
|
const obj3 = { description: "JS Bundle Execution Start", start_timestamp: result2, timestamp: result2, origin: warnResult2(warnResult2[8]).SPAN_ORIGIN_AUTO_APP_START };
|
|
childSpanJSON = warnResult2(warnResult2[6]).createChildSpanJSON(spanJSON, obj3);
|
|
const warnResult2Result1 = warnResult2(warnResult2[6]);
|
|
}
|
|
}
|
|
}
|
|
const items = [spanJSON];
|
|
warnResult2 = callback;
|
|
if (childSpanJSON) {
|
|
const items1 = [childSpanJSON];
|
|
let items2 = items1;
|
|
} else {
|
|
items2 = [];
|
|
}
|
|
warnResult2 = callback;
|
|
warnResult2 = warnResult2(items2);
|
|
warnResult2 = items.concat(warnResult2, callback(function convertNativeSpansToSpanJSON(spanJSON, spans) {
|
|
const found = spans.filter((start_timestamp_ms) => start_timestamp_ms.start_timestamp_ms / 1000 >= start_timestamp_ms.start_timestamp);
|
|
return found.map((description) => {
|
|
let SPAN_ORIGIN_AUTO_APP_START = description;
|
|
if ("UIKit init" === description.description) {
|
|
let obj = description(closure_1[10]);
|
|
obj = 6;
|
|
const bundleStartTimestampMs = description(closure_1[6]).getBundleStartTimestampMs();
|
|
if (!bundleStartTimestampMs) {
|
|
obj = { description: "UIKit Init", start_timestamp: SPAN_ORIGIN_AUTO_APP_START.start_timestamp_ms / 1000, timestamp: SPAN_ORIGIN_AUTO_APP_START.end_timestamp_ms / 1000, origin: description(closure_1[8]).SPAN_ORIGIN_AUTO_APP_START };
|
|
let childSpanJSON = description(closure_1[obj]).createChildSpanJSON(tmp3, obj);
|
|
obj.setMainThreadInfo(childSpanJSON);
|
|
const obj4 = description(closure_1[obj]);
|
|
}
|
|
const obj3 = description(closure_1[6]);
|
|
obj = { description: "UIKit Init to JS Exec Start", start_timestamp: SPAN_ORIGIN_AUTO_APP_START.start_timestamp_ms / 1000, timestamp: bundleStartTimestampMs / 1000 };
|
|
SPAN_ORIGIN_AUTO_APP_START = description(closure_1[8]).SPAN_ORIGIN_AUTO_APP_START;
|
|
obj.origin = SPAN_ORIGIN_AUTO_APP_START;
|
|
childSpanJSON = description(closure_1[obj]).createChildSpanJSON(tmp3, obj);
|
|
const obj6 = description(closure_1[obj]);
|
|
} else {
|
|
const obj7 = description(closure_1[10]);
|
|
const obj1 = { description: SPAN_ORIGIN_AUTO_APP_START.description, start_timestamp: SPAN_ORIGIN_AUTO_APP_START.start_timestamp_ms / 1000, timestamp: SPAN_ORIGIN_AUTO_APP_START.end_timestamp_ms / 1000, origin: description(closure_1[8]).SPAN_ORIGIN_AUTO_APP_START };
|
|
return obj7.setMainThreadInfo(description(closure_1[6]).createChildSpanJSON(description, obj1));
|
|
}
|
|
});
|
|
}(spanJSON, tmp21.spans)));
|
|
const push = spans.push;
|
|
warnResult2 = push.apply(spans, callback(warnResult2));
|
|
warnResult2 = lib;
|
|
warnResult2 = contexts;
|
|
const debug13 = lib(contexts[1]).debug;
|
|
warnResult2 = globalThis;
|
|
const _JSON = JSON;
|
|
warnResult2 = debug13.log("[AppStart] Added app start spans to transaction event.", JSON.stringify(warnResult2, undefined, 2));
|
|
if ("cold" === tmp21.type) {
|
|
warnResult2 = lib;
|
|
warnResult2 = contexts;
|
|
let APP_START_WARM2 = lib(contexts[9]).APP_START_COLD;
|
|
} else {
|
|
warnResult2 = lib;
|
|
warnResult2 = contexts;
|
|
APP_START_WARM2 = lib(contexts[9]).APP_START_WARM;
|
|
}
|
|
const obj4 = { value: diff, unit: "millisecond" };
|
|
let measurements = lib.measurements;
|
|
warnResult2 = lib;
|
|
if (!measurements) {
|
|
measurements = {};
|
|
}
|
|
warnResult2.measurements = measurements;
|
|
warnResult2 = lib;
|
|
lib.measurements[APP_START_WARM2] = obj4;
|
|
warnResult2 = lib;
|
|
warnResult2 = contexts;
|
|
const debug14 = lib(contexts[1]).debug;
|
|
const _JSON2 = JSON;
|
|
warnResult2 = debug14.log("[AppStart] Added app start measurement to transaction event.", JSON.stringify(obj4, undefined, 2));
|
|
const obj7 = lib(contexts[6]);
|
|
const tmp50 = lib;
|
|
}
|
|
}
|
|
}
|
|
const debug7 = lib(contexts[1]).debug;
|
|
debug7.warn("[AppStart] App start timestamp is too far in the past to be used for app start span.");
|
|
} else {
|
|
const debug6 = lib(contexts[1]).debug;
|
|
debug6.warn("[AppStart] Javascript failed to record app start end. `_setAppStartEndData` was not called nor could the bundle start be found.");
|
|
}
|
|
} else {
|
|
const debug5 = lib(contexts[1]).debug;
|
|
debug5.warn("[AppStart] App start timestamp could not be loaded from the native layer.");
|
|
}
|
|
}
|
|
} else {
|
|
const debug4 = lib(contexts[1]).debug;
|
|
debug4.warn("[AppStart] Failed to retrieve the app start metrics from the native layer.");
|
|
}
|
|
} else {
|
|
const debug = lib(contexts[1]).debug;
|
|
debug.warn("[AppStart] Transaction event is missing trace context. Can not attach app start.");
|
|
}
|
|
}
|
|
});
|
|
}
|
|
if (arguments.length > 0) {
|
|
if (undefined !== arguments[0]) {
|
|
const first = arguments[0];
|
|
}
|
|
const standalone = {}.standalone;
|
|
let closure_0 = undefined !== standalone && standalone;
|
|
let closure_1;
|
|
let closure_2 = true;
|
|
let closure_3 = false;
|
|
let closure_4 = false;
|
|
let closure_5;
|
|
function recordFirstStartedActiveRootSpanId(spanContext) {
|
|
if (!closure_5) {
|
|
if (obj.isRootSpan(spanContext)) {
|
|
setFirstStartedActiveRootSpanId(spanContext.spanContext().spanId);
|
|
}
|
|
const obj = callback(closure_1[4]);
|
|
}
|
|
}
|
|
function setFirstStartedActiveRootSpanId(spanId) {
|
|
let closure_5 = spanId;
|
|
const debug = callback(closure_1[1]).debug;
|
|
debug.log("[AppStart] First started active root span id recorded.", closure_5);
|
|
}
|
|
let closure_7 = setFirstStartedActiveRootSpanId;
|
|
const obj = {
|
|
name: closure_4,
|
|
setup(getOptions) {
|
|
let closure_1 = getOptions;
|
|
if (!getOptions.getOptions().enableAppStartTracking) {
|
|
let closure_2 = false;
|
|
const debug = callback(closure_1[1]).debug;
|
|
debug.warn("[AppStart] App start tracking is disabled.");
|
|
}
|
|
getOptions.on("spanStart", recordFirstStartedActiveRootSpanId);
|
|
},
|
|
afterAllSetup(client) {
|
|
if (!closure_4) {
|
|
closure_4 = true;
|
|
const appRegistryIntegration = callback(closure_1[3]).getAppRegistryIntegration(client);
|
|
if (!tmp5) {
|
|
appRegistryIntegration.onRunApplication(() => {
|
|
const debug = callback(closure_1[1]).debug;
|
|
const log = debug.log;
|
|
if (closure_3) {
|
|
log("[AppStartIntegration] Resetting app start data flushed flag based on runApplication call.");
|
|
closure_3 = false;
|
|
let closure_5;
|
|
} else {
|
|
log("[AppStartIntegration] Waiting for initial app start was flush, before updating based on runApplication call.");
|
|
}
|
|
});
|
|
}
|
|
const obj = callback(closure_1[3]);
|
|
const tmp5 = null === appRegistryIntegration || undefined === appRegistryIntegration;
|
|
}
|
|
},
|
|
processEvent(arg0) {
|
|
let closure_0 = arg0;
|
|
return callback2(undefined, undefined, undefined, function*() {
|
|
let tmp = !closure_2;
|
|
if (closure_2) {
|
|
tmp = type;
|
|
}
|
|
if (!tmp) {
|
|
tmp = "transaction" !== type.type;
|
|
}
|
|
if (tmp) {
|
|
return type;
|
|
} else {
|
|
return yield closure_8(closure_0);
|
|
}
|
|
});
|
|
},
|
|
captureStandaloneAppStart() {
|
|
return callback2(this, undefined, undefined, function*() {
|
|
if (closure_1) {
|
|
const debug = callback(closure_1[1]).debug;
|
|
const log = debug.log;
|
|
if (callback) {
|
|
log("[AppStart] App start tracking standalone root span (transaction).");
|
|
let endFrames;
|
|
if (null != closure_5) {
|
|
endFrames = closure_5.endFrames;
|
|
}
|
|
if (!endFrames) {
|
|
if (callback(closure_1[2]).NATIVE.enableNative) {
|
|
const NATIVE = callback(closure_1[2]).NATIVE;
|
|
const tmp16 = yield NATIVE.fetchNativeFrames();
|
|
const debug2 = callback(closure_1[1]).debug;
|
|
debug2.log("[AppStart] Captured end frames for standalone app start.", tmp16);
|
|
let timestampMs;
|
|
if (null != closure_5) {
|
|
timestampMs = closure_5.timestampMs;
|
|
}
|
|
let result = timestampMs;
|
|
if (!timestampMs) {
|
|
let obj = callback(closure_1[1]);
|
|
result = 1000 * obj.timestampInSeconds();
|
|
}
|
|
obj = { timestampMs: result, endFrames: tmp16 };
|
|
callback2(obj);
|
|
}
|
|
}
|
|
while (true) {
|
|
let tmp30 = callback;
|
|
let tmp31 = closure_1;
|
|
let obj3 = callback(closure_1[1]);
|
|
obj = { disabled: "<string:2739077376>", round: "<string:2717909401>" };
|
|
let num4 = 5;
|
|
obj.op = callback(closure_1[5]).UI_LOAD;
|
|
let startInactiveSpanResult = obj3.startInactiveSpan(obj);
|
|
if (startInactiveSpanResult instanceof callback(closure_1[1]).SentryNonRecordingSpan) {
|
|
break;
|
|
} else {
|
|
let tmp33 = callback;
|
|
let tmp34 = closure_1;
|
|
let num5 = 4;
|
|
let obj5 = callback(closure_1[4]);
|
|
let obj6 = callback(closure_1[1]);
|
|
let setEndTimeValueResult = obj5.setEndTimeValue(startInactiveSpanResult, obj6.timestampInSeconds());
|
|
let tmp36 = closure_1;
|
|
let str5 = "spanEnd";
|
|
let emitResult = closure_1.emit("spanEnd", startInactiveSpanResult);
|
|
let obj7 = callback(closure_1[4]);
|
|
let result1 = obj7.convertSpanToTransaction(startInactiveSpanResult);
|
|
if (result1) {
|
|
let tmp42 = closure_8;
|
|
let tmp43 = yield closure_8(result1);
|
|
if (!result1.spans) {
|
|
break;
|
|
} else {
|
|
let num6 = 0;
|
|
if (0 === result1.spans.length) {
|
|
break;
|
|
} else {
|
|
let tmp44 = callback;
|
|
let tmp45 = closure_1;
|
|
let obj8 = callback(closure_1[1]);
|
|
let scope = obj8.getCapturedScopesOnSpan(startInactiveSpanResult).scope;
|
|
if (!scope) {
|
|
let tmp46 = callback;
|
|
let tmp47 = closure_1;
|
|
let obj9 = callback(closure_1[1]);
|
|
scope = obj9.getCurrentScope();
|
|
}
|
|
let captureEventResult = scope.captureEvent(result1);
|
|
// break
|
|
}
|
|
}
|
|
} else {
|
|
let tmp39 = callback;
|
|
let tmp40 = closure_1;
|
|
let debug3 = callback(closure_1[1]).debug;
|
|
let str6 = "[AppStart] Failed to convert App Start span to transaction.";
|
|
let warnResult = debug3.warn("[AppStart] Failed to convert App Start span to transaction.");
|
|
// break
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
} else {
|
|
log("[AppStart] App start tracking is enabled. App start will be added to the first transaction as a child span.");
|
|
}
|
|
} else {
|
|
const _console = console;
|
|
console.warn("[AppStart] Could not capture App Start, missing client, call `Sentry.init` first.");
|
|
}
|
|
});
|
|
},
|
|
setFirstStartedActiveRootSpanId
|
|
};
|
|
return obj;
|
|
}
|
|
};
|