374 lines
13 KiB
JavaScript
374 lines
13 KiB
JavaScript
// Module ID: 852
|
|
// Function ID: 853
|
|
// Name: TRACING_DEFAULTS
|
|
// Dependencies: [853, 848, 855, 856, 857, 819, 838, 859, 844, 839, 840, 824, 823, 860, 866]
|
|
// Exports: startIdleSpan
|
|
|
|
// Module 852 (TRACING_DEFAULTS)
|
|
import _toArray from "_toArray";
|
|
|
|
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
|
|
let obj = { idleTimeout: 1000, finalTimeout: 30000, childSpanTimeout: 15000 };
|
|
|
|
export const TRACING_DEFAULTS = obj;
|
|
export const startIdleSpan = function startIdleSpan(arg0) {
|
|
let c9;
|
|
let trimIdleSpanEndTimestamp;
|
|
let obj = arg1;
|
|
if (arg1 === undefined) {
|
|
obj = {};
|
|
}
|
|
let _require;
|
|
let map;
|
|
let c2;
|
|
let externalFinish;
|
|
let closure_4;
|
|
let items;
|
|
let idleTimeout;
|
|
let finalTimeout;
|
|
let childSpanTimeout;
|
|
c9 = undefined;
|
|
let closure_10;
|
|
let client;
|
|
let currentScope;
|
|
let activeSpan;
|
|
let c14;
|
|
function onIdleSpanEnded(arg0) {
|
|
const callback = arg0;
|
|
let c2 = true;
|
|
map.clear();
|
|
const item = items.forEach((arg0) => arg0());
|
|
let obj = callback(map[8]);
|
|
obj._setSpanForScope(closure_12, closure_13);
|
|
let spanToJSONResult = callback(map[5]).spanToJSON(c14);
|
|
if (spanToJSONResult.start_timestamp) {
|
|
if (!spanToJSONResult.data[tmp3(undefined, tmp4[9]).SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON]) {
|
|
const attr = obj3.setAttribute(tmp3(tmp4[9]).SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, externalFinish);
|
|
}
|
|
const status = spanToJSONResult.status;
|
|
let tmp9 = status;
|
|
if (status) {
|
|
tmp9 = "unknown" !== status;
|
|
}
|
|
if (!tmp9) {
|
|
obj = { code: null };
|
|
obj[0] = tmp3(tmp4[10]).SPAN_STATUS_OK;
|
|
obj3.setStatus(obj);
|
|
}
|
|
let debug = tmp3(tmp4[11]).debug;
|
|
const _HermesInternal = HermesInternal;
|
|
debug.log("[Tracing] Idle span \"" + spanToJSONResult.op + "\" finished");
|
|
const spanDescendants = tmp3(tmp4[5]).getSpanDescendants(obj3);
|
|
const found = spanDescendants.filter((arg0) => arg0 !== closure_14);
|
|
const item1 = found.forEach((isRecording) => {
|
|
if (isRecording.isRecording()) {
|
|
const obj = { code: null, message: "cancelled" };
|
|
obj[0] = callback(map[10]).SPAN_STATUS_ERROR;
|
|
isRecording.setStatus(obj);
|
|
isRecording.end(callback);
|
|
if (callback(map[12]).DEBUG_BUILD) {
|
|
const debug = callback(map[11]).debug;
|
|
const _JSON = JSON;
|
|
debug.log("[Tracing] Cancelling span since span ended early", JSON.stringify(isRecording, undefined, 2));
|
|
}
|
|
}
|
|
const spanToJSONResult = callback(map[5]).spanToJSON(isRecording);
|
|
const timestamp = spanToJSONResult.timestamp;
|
|
let num2 = 0;
|
|
if (undefined !== timestamp) {
|
|
num2 = timestamp;
|
|
}
|
|
const start_timestamp = spanToJSONResult.start_timestamp;
|
|
let num3 = 0;
|
|
if (undefined !== start_timestamp) {
|
|
num3 = start_timestamp;
|
|
}
|
|
let tmp14 = num2 - num3 <= (outer1_7 + outer1_6) / 1000;
|
|
if (callback(map[12]).DEBUG_BUILD) {
|
|
const _JSON2 = JSON;
|
|
const json = JSON.stringify(isRecording, undefined, 2);
|
|
if (tmp13) {
|
|
if (!tmp14) {
|
|
const debug3 = callback(map[11]).debug;
|
|
debug3.log("[Tracing] Discarding span since it finished after idle span final timeout", json);
|
|
}
|
|
} else {
|
|
const debug2 = callback(map[11]).debug;
|
|
debug2.log("[Tracing] Discarding span since it happened after idle span was finished", json);
|
|
}
|
|
}
|
|
if (tmp14) {
|
|
tmp14 = tmp13;
|
|
}
|
|
if (!tmp14) {
|
|
const result = callback(map[5]).removeChildSpanFromSpan(outer1_14, isRecording);
|
|
closure_1 = closure_1 + 1;
|
|
const obj3 = callback(map[5]);
|
|
}
|
|
});
|
|
if (0 > 0) {
|
|
const attr1 = obj3.setAttribute("sentry.idle_span_discarded_spans", map);
|
|
}
|
|
const tmp3Result = tmp3(tmp4[5]);
|
|
}
|
|
}
|
|
map = new Map();
|
|
c2 = false;
|
|
externalFinish = "externalFinish";
|
|
closure_4 = !obj.disableAutoFinish;
|
|
items = [];
|
|
idleTimeout = obj.idleTimeout;
|
|
if (undefined === idleTimeout) {
|
|
idleTimeout = externalFinish.idleTimeout;
|
|
}
|
|
finalTimeout = obj.finalTimeout;
|
|
if (undefined === finalTimeout) {
|
|
finalTimeout = externalFinish.finalTimeout;
|
|
}
|
|
childSpanTimeout = obj.childSpanTimeout;
|
|
if (undefined === childSpanTimeout) {
|
|
childSpanTimeout = externalFinish.childSpanTimeout;
|
|
}
|
|
({ beforeSpanEnd: c9, trimIdleSpanEndTimestamp } = obj);
|
|
closure_10 = undefined === trimIdleSpanEndTimestamp || trimIdleSpanEndTimestamp;
|
|
client = _require(map[1]).getClient();
|
|
if (client) {
|
|
let tmp5Result = tmp5(tmp6[2]);
|
|
if (tmp5Result.hasSpansEnabled()) {
|
|
tmp5Result = tmp5(tmp6[1]);
|
|
currentScope = tmp5Result.getCurrentScope();
|
|
activeSpan = tmp5(tmp6[5]).getActiveSpan();
|
|
const tmp5Result1 = tmp5(tmp6[5]);
|
|
const startInactiveSpanResult = tmp5(tmp6[14]).startInactiveSpan(arg0);
|
|
const tmp5Result2 = tmp5(tmp6[14]);
|
|
const tmp5Result3 = tmp5(tmp6[8]);
|
|
tmp5Result3._setSpanForScope(tmp5(tmp6[1]).getCurrentScope(), startInactiveSpanResult);
|
|
if (tmp5(tmp6[12]).DEBUG_BUILD) {
|
|
let debug = tmp5(tmp6[11]).debug;
|
|
debug.log("[Tracing] Started span is an idle span");
|
|
}
|
|
c14 = startInactiveSpanResult;
|
|
const _Proxy = Proxy;
|
|
obj = { apply: null };
|
|
obj[0] = function apply(arg0, arg1, arg2) {
|
|
if (c9) {
|
|
tmp(c14);
|
|
}
|
|
if (!(arg1 instanceof callback(map[3]).SentryNonRecordingSpan)) {
|
|
const arr = callback2(arg2);
|
|
let first = arr[0];
|
|
const substr = arr.slice(1);
|
|
if (!first) {
|
|
let tmp4Result = tmp4(tmp5[6]);
|
|
first = tmp4Result.timestampInSeconds();
|
|
}
|
|
tmp4Result = tmp4(tmp5[5]);
|
|
const result = tmp4Result.spanTimeInputToSeconds(first);
|
|
const spanDescendants = tmp4(tmp5[5]).getSpanDescendants(c14);
|
|
const found = spanDescendants.filter((arg0) => arg0 !== closure_14);
|
|
tmp4(tmp5[5]);
|
|
if (found.length) {
|
|
if (closure_10) {
|
|
const ignoreSpans = client.getOptions().ignoreSpans;
|
|
let num3;
|
|
if (found != null) {
|
|
num3 = found.reduce((arg0, arg1) => {
|
|
let timestamp = ignoreSpans(map[5]).spanToJSON(arg1);
|
|
let tmp3 = arg0;
|
|
if (timestamp.timestamp) {
|
|
if (ignoreSpans) {
|
|
if (tmpResult.shouldIgnoreSpan(timestamp, tmp4)) {
|
|
tmp3 = arg0;
|
|
}
|
|
tmpResult = ignoreSpans(map[7]);
|
|
}
|
|
if (arg0) {
|
|
const _Math = Math;
|
|
timestamp = timestamp.timestamp;
|
|
let timestamp2 = Math.max(arg0, timestamp);
|
|
} else {
|
|
timestamp2 = timestamp.timestamp;
|
|
}
|
|
}
|
|
return tmp3;
|
|
}, undefined);
|
|
}
|
|
let num4 = tmp14.start_timestamp;
|
|
let num6 = Infinity;
|
|
if (num4) {
|
|
num6 = num4 + finalTimeout / 1000;
|
|
}
|
|
if (!num4) {
|
|
num4 = -Infinity;
|
|
}
|
|
if (!num3) {
|
|
num3 = Infinity;
|
|
}
|
|
const bound = Math.min(num6, Math.max(num4, Math.min(result, num3)));
|
|
onIdleSpanEnded(bound);
|
|
const _Reflect2 = Reflect;
|
|
const items = [bound];
|
|
HermesBuiltin.arraySpread(substr, 1);
|
|
return Reflect.apply(arg0, arg1, items);
|
|
}
|
|
}
|
|
onIdleSpanEnded(result);
|
|
const _Reflect = Reflect;
|
|
const items1 = [result];
|
|
HermesBuiltin.arraySpread(substr, 1);
|
|
return Reflect.apply(arg0, arg1, items1);
|
|
}
|
|
};
|
|
const proxy = new Proxy(startInactiveSpanResult.end, obj);
|
|
startInactiveSpanResult.end = proxy;
|
|
items.push(client.on("spanStart", (isStandaloneSpan) => {
|
|
let timestamp = c2;
|
|
if (!c2) {
|
|
timestamp = isStandaloneSpan === c14;
|
|
}
|
|
if (!timestamp) {
|
|
timestamp = callback(map[5]).spanToJSON(isStandaloneSpan).timestamp;
|
|
const obj = callback(map[5]);
|
|
}
|
|
if (!timestamp) {
|
|
timestamp = isStandaloneSpan instanceof callback(map[13]).SentrySpan && isStandaloneSpan.isStandaloneSpan();
|
|
const tmp6 = isStandaloneSpan instanceof callback(map[13]).SentrySpan && isStandaloneSpan.isStandaloneSpan();
|
|
}
|
|
if (!timestamp) {
|
|
const spanDescendants = callback(map[5]).getSpanDescendants(c14);
|
|
if (spanDescendants.includes(isStandaloneSpan)) {
|
|
if (callback) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(callback);
|
|
callback = undefined;
|
|
}
|
|
const result = map.set(isStandaloneSpan.spanContext().spanId, true);
|
|
callback = callback(map[6]).timestampInSeconds() + childSpanTimeout / 1000;
|
|
const _setTimeout = setTimeout;
|
|
callback = setTimeout(() => {
|
|
let tmp = !outer1_2;
|
|
if (!outer1_2) {
|
|
tmp = c4;
|
|
}
|
|
if (tmp) {
|
|
const outer1_3 = "heartbeatFailed";
|
|
outer1_14.end(closure_0);
|
|
}
|
|
}, childSpanTimeout);
|
|
const obj4 = callback(map[6]);
|
|
}
|
|
const obj2 = callback(map[5]);
|
|
}
|
|
}));
|
|
items.push(client.on("spanEnd", (spanContext) => {
|
|
if (!c2) {
|
|
const spanId = spanContext.spanContext().spanId;
|
|
if (map.has(spanId)) {
|
|
obj.delete(spanId);
|
|
}
|
|
if (0 === map.size) {
|
|
callback = callback(map[6]).timestampInSeconds() + idleTimeout / 1000;
|
|
if (callback) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(callback);
|
|
callback = undefined;
|
|
}
|
|
const _setTimeout = setTimeout;
|
|
callback = setTimeout(() => {
|
|
let tmp = !outer1_2;
|
|
if (!outer1_2) {
|
|
tmp = 0 === outer1_1.size;
|
|
}
|
|
if (tmp) {
|
|
tmp = c4;
|
|
}
|
|
if (tmp) {
|
|
const outer1_3 = "idleTimeout";
|
|
outer1_14.end(closure_0);
|
|
}
|
|
}, idleTimeout);
|
|
const obj2 = callback(map[6]);
|
|
const tmp5 = idleTimeout;
|
|
}
|
|
}
|
|
}));
|
|
items.push(client.on("idleSpanEnableAutoFinish", (arg0) => {
|
|
if (arg0 === c14) {
|
|
let c4 = true;
|
|
let timeout;
|
|
if (timeout) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(timeout);
|
|
timeout = undefined;
|
|
}
|
|
const _setTimeout = setTimeout;
|
|
timeout = setTimeout(() => {
|
|
let tmp = !outer1_2;
|
|
if (!outer1_2) {
|
|
tmp = 0 === outer1_1.size;
|
|
}
|
|
if (tmp) {
|
|
tmp = c4;
|
|
}
|
|
if (tmp) {
|
|
const outer1_3 = "idleTimeout";
|
|
outer1_14.end(closure_0);
|
|
}
|
|
}, idleTimeout);
|
|
if (map.size) {
|
|
const _setTimeout2 = setTimeout;
|
|
timeout = setTimeout(() => {
|
|
let tmp = !outer1_2;
|
|
if (!outer1_2) {
|
|
tmp = c4;
|
|
}
|
|
if (tmp) {
|
|
const outer1_3 = "heartbeatFailed";
|
|
outer1_14.end(closure_0);
|
|
}
|
|
}, childSpanTimeout);
|
|
}
|
|
}
|
|
}));
|
|
if (!obj.disableAutoFinish) {
|
|
if (_require) {
|
|
let _clearTimeout = clearTimeout;
|
|
clearTimeout(_require);
|
|
_require = undefined;
|
|
}
|
|
let _setTimeout = setTimeout;
|
|
_require = setTimeout(() => {
|
|
let tmp = !outer1_2;
|
|
if (!outer1_2) {
|
|
tmp = 0 === outer1_1.size;
|
|
}
|
|
if (tmp) {
|
|
tmp = c4;
|
|
}
|
|
if (tmp) {
|
|
const outer1_3 = "idleTimeout";
|
|
outer1_14.end(closure_0);
|
|
}
|
|
}, idleTimeout);
|
|
}
|
|
let _setTimeout2 = setTimeout;
|
|
const timerId = setTimeout(() => {
|
|
if (!c2) {
|
|
const obj = { code: null, message: "deadline_exceeded" };
|
|
obj[0] = callback(map[10]).SPAN_STATUS_ERROR;
|
|
_undefined.setStatus(obj);
|
|
const finalTimeout = "finalTimeout";
|
|
_undefined.end();
|
|
}
|
|
}, finalTimeout);
|
|
return startInactiveSpanResult;
|
|
}
|
|
}
|
|
const sentryNonRecordingSpan = new tmp5(tmp6[3]).SentryNonRecordingSpan();
|
|
obj = { sample_rate: "0", sampled: "false" };
|
|
let obj2 = _require(map[1]);
|
|
const merged = Object.assign(_require(map[4]).getDynamicSamplingContextFromSpan(sentryNonRecordingSpan));
|
|
const tmp5Result5 = _require(map[4]);
|
|
_require(map[4]).freezeDscOnSpan(sentryNonRecordingSpan, obj);
|
|
return sentryNonRecordingSpan;
|
|
};
|