Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 uid=33(www-data) gid=33(www-data) groups=33(www-data) Safe-mode: OFF (not secure) /var/www/html/wincloud_gateway/node_modules/strapi-plugin-sentry/node_modules/@sentry/tracing/dist/ drwxr-xr-x | |
| Viewing file: Select action/file-type: Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var utils_1 = require("@sentry/utils");
var span_1 = require("./span");
var spanstatus_1 = require("./spanstatus");
var transaction_1 = require("./transaction");
exports.DEFAULT_IDLE_TIMEOUT = 1000;
/**
* @inheritDoc
*/
var IdleTransactionSpanRecorder = /** @class */ (function (_super) {
tslib_1.__extends(IdleTransactionSpanRecorder, _super);
function IdleTransactionSpanRecorder(_pushActivity, _popActivity, transactionSpanId, maxlen) {
if (transactionSpanId === void 0) { transactionSpanId = ''; }
var _this = _super.call(this, maxlen) || this;
_this._pushActivity = _pushActivity;
_this._popActivity = _popActivity;
_this.transactionSpanId = transactionSpanId;
return _this;
}
/**
* @inheritDoc
*/
IdleTransactionSpanRecorder.prototype.add = function (span) {
var _this = this;
// We should make sure we do not push and pop activities for
// the transaction that this span recorder belongs to.
if (span.spanId !== this.transactionSpanId) {
// We patch span.finish() to pop an activity after setting an endTimestamp.
span.finish = function (endTimestamp) {
span.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : utils_1.timestampWithMs();
_this._popActivity(span.spanId);
};
// We should only push new activities if the span does not have an end timestamp.
if (span.endTimestamp === undefined) {
this._pushActivity(span.spanId);
}
}
_super.prototype.add.call(this, span);
};
return IdleTransactionSpanRecorder;
}(span_1.SpanRecorder));
exports.IdleTransactionSpanRecorder = IdleTransactionSpanRecorder;
/**
* An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.
* You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will
* put itself on the scope on creation.
*/
var IdleTransaction = /** @class */ (function (_super) {
tslib_1.__extends(IdleTransaction, _super);
function IdleTransaction(transactionContext, _idleHub,
// The time to wait in ms until the idle transaction will be finished. Default: 1000
_idleTimeout,
// If an idle transaction should be put itself on and off the scope automatically.
_onScope) {
if (_idleTimeout === void 0) { _idleTimeout = exports.DEFAULT_IDLE_TIMEOUT; }
if (_onScope === void 0) { _onScope = false; }
var _this = _super.call(this, transactionContext, _idleHub) || this;
_this._idleHub = _idleHub;
_this._idleTimeout = _idleTimeout;
_this._onScope = _onScope;
// Activities store a list of active spans
_this.activities = {};
// Stores reference to the timeout that calls _beat().
_this._heartbeatTimer = 0;
// Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.
_this._heartbeatCounter = 0;
// We should not use heartbeat if we finished a transaction
_this._finished = false;
_this._beforeFinishCallbacks = [];
if (_idleHub && _onScope) {
// There should only be one active transaction on the scope
clearActiveTransaction(_idleHub);
// We set the transaction here on the scope so error events pick up the trace
// context and attach it to the error.
utils_1.logger.log("Setting idle transaction on scope. Span ID: " + _this.spanId);
_idleHub.configureScope(function (scope) { return scope.setSpan(_this); });
}
_this._initTimeout = setTimeout(function () {
if (!_this._finished) {
_this.finish();
}
}, _this._idleTimeout);
return _this;
}
/** {@inheritDoc} */
IdleTransaction.prototype.finish = function (endTimestamp) {
var e_1, _a;
var _this = this;
if (endTimestamp === void 0) { endTimestamp = utils_1.timestampWithMs(); }
this._finished = true;
this.activities = {};
if (this.spanRecorder) {
utils_1.logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);
try {
for (var _b = tslib_1.__values(this._beforeFinishCallbacks), _c = _b.next(); !_c.done; _c = _b.next()) {
var callback = _c.value;
callback(this, endTimestamp);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
this.spanRecorder.spans = this.spanRecorder.spans.filter(function (span) {
// If we are dealing with the transaction itself, we just return it
if (span.spanId === _this.spanId) {
return true;
}
// We cancel all pending spans with status "cancelled" to indicate the idle transaction was finished early
if (!span.endTimestamp) {
span.endTimestamp = endTimestamp;
span.setStatus(spanstatus_1.SpanStatus.Cancelled);
utils_1.logger.log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));
}
var keepSpan = span.startTimestamp < endTimestamp;
if (!keepSpan) {
utils_1.logger.log('[Tracing] discarding Span since it happened after Transaction was finished', JSON.stringify(span, undefined, 2));
}
return keepSpan;
});
utils_1.logger.log('[Tracing] flushing IdleTransaction');
}
else {
utils_1.logger.log('[Tracing] No active IdleTransaction');
}
// this._onScope is true if the transaction was previously on the scope.
if (this._onScope) {
clearActiveTransaction(this._idleHub);
}
return _super.prototype.finish.call(this, endTimestamp);
};
/**
* Register a callback function that gets excecuted before the transaction finishes.
* Useful for cleanup or if you want to add any additional spans based on current context.
*
* This is exposed because users have no other way of running something before an idle transaction
* finishes.
*/
IdleTransaction.prototype.registerBeforeFinishCallback = function (callback) {
this._beforeFinishCallbacks.push(callback);
};
/**
* @inheritDoc
*/
IdleTransaction.prototype.initSpanRecorder = function (maxlen) {
var _this = this;
if (!this.spanRecorder) {
var pushActivity = function (id) {
if (_this._finished) {
return;
}
_this._pushActivity(id);
};
var popActivity = function (id) {
if (_this._finished) {
return;
}
_this._popActivity(id);
};
this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanId, maxlen);
// Start heartbeat so that transactions do not run forever.
utils_1.logger.log('Starting heartbeat');
this._pingHeartbeat();
}
this.spanRecorder.add(this);
};
/**
* Start tracking a specific activity.
* @param spanId The span id that represents the activity
*/
IdleTransaction.prototype._pushActivity = function (spanId) {
if (this._initTimeout) {
clearTimeout(this._initTimeout);
this._initTimeout = undefined;
}
utils_1.logger.log("[Tracing] pushActivity: " + spanId);
this.activities[spanId] = true;
utils_1.logger.log('[Tracing] new activities count', Object.keys(this.activities).length);
};
/**
* Remove an activity from usage
* @param spanId The span id that represents the activity
*/
IdleTransaction.prototype._popActivity = function (spanId) {
var _this = this;
if (this.activities[spanId]) {
utils_1.logger.log("[Tracing] popActivity " + spanId);
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
delete this.activities[spanId];
utils_1.logger.log('[Tracing] new activities count', Object.keys(this.activities).length);
}
if (Object.keys(this.activities).length === 0) {
var timeout = this._idleTimeout;
// We need to add the timeout here to have the real endtimestamp of the transaction
// Remember timestampWithMs is in seconds, timeout is in ms
var end_1 = utils_1.timestampWithMs() + timeout / 1000;
setTimeout(function () {
if (!_this._finished) {
_this.finish(end_1);
}
}, timeout);
}
};
/**
* Checks when entries of this.activities are not changing for 3 beats.
* If this occurs we finish the transaction.
*/
IdleTransaction.prototype._beat = function () {
clearTimeout(this._heartbeatTimer);
// We should not be running heartbeat if the idle transaction is finished.
if (this._finished) {
return;
}
var keys = Object.keys(this.activities);
var heartbeatString = keys.length ? keys.reduce(function (prev, current) { return prev + current; }) : '';
if (heartbeatString === this._prevHeartbeatString) {
this._heartbeatCounter += 1;
}
else {
this._heartbeatCounter = 1;
}
this._prevHeartbeatString = heartbeatString;
if (this._heartbeatCounter >= 3) {
utils_1.logger.log("[Tracing] Transaction finished because of no change for 3 heart beats");
this.setStatus(spanstatus_1.SpanStatus.DeadlineExceeded);
this.setTag('heartbeat', 'failed');
this.finish();
}
else {
this._pingHeartbeat();
}
};
/**
* Pings the heartbeat
*/
IdleTransaction.prototype._pingHeartbeat = function () {
var _this = this;
utils_1.logger.log("pinging Heartbeat -> current counter: " + this._heartbeatCounter);
this._heartbeatTimer = setTimeout(function () {
_this._beat();
}, 5000);
};
return IdleTransaction;
}(transaction_1.Transaction));
exports.IdleTransaction = IdleTransaction;
/**
* Reset active transaction on scope
*/
function clearActiveTransaction(hub) {
if (hub) {
var scope = hub.getScope();
if (scope) {
var transaction = scope.getTransaction();
if (transaction) {
scope.setSpan(undefined);
}
}
}
}
//# sourceMappingURL=idletransaction.js.map |
:: Command execute :: | |
--[ c99shell v. 2.5 [PHP 8 Update] [24.05.2025] | Generation time: 0.0053 ]-- |