Spaces:
Running
Running
File size: 6,120 Bytes
979bf48 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 | "use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
0 && (module.exports = {
Span: null,
SpanStatus: null,
clearTraceEvents: null,
exportTraceState: null,
flushAllTraces: null,
getTraceEvents: null,
initializeTraceState: null,
recordTraceEvents: null,
trace: null
});
function _export(target, all) {
for(var name in all)Object.defineProperty(target, name, {
enumerable: true,
get: all[name]
});
}
_export(exports, {
Span: function() {
return Span;
},
SpanStatus: function() {
return SpanStatus;
},
clearTraceEvents: function() {
return clearTraceEvents;
},
exportTraceState: function() {
return exportTraceState;
},
flushAllTraces: function() {
return flushAllTraces;
},
getTraceEvents: function() {
return getTraceEvents;
},
initializeTraceState: function() {
return initializeTraceState;
},
recordTraceEvents: function() {
return recordTraceEvents;
},
trace: function() {
return trace;
}
});
const _report = require("./report");
const NUM_OF_MICROSEC_IN_NANOSEC = BigInt('1000');
const NUM_OF_MILLISEC_IN_NANOSEC = BigInt('1000000');
let count = 0;
const getId = ()=>{
count++;
return count;
};
let defaultParentSpanId;
let shouldSaveTraceEvents;
let savedTraceEvents = [];
const RECORD_SPAN_THRESHOLD_MS = parseInt(process.env.NEXT_TRACE_SPAN_THRESHOLD_MS ?? '-1');
var SpanStatus = /*#__PURE__*/ function(SpanStatus) {
SpanStatus["Started"] = "started";
SpanStatus["Stopped"] = "stopped";
return SpanStatus;
}({});
class Span {
constructor({ name, parentId, attrs, startTime }){
this.name = name;
this.parentId = parentId ?? defaultParentSpanId;
this.attrs = attrs ? {
...attrs
} : {};
this.status = "started";
this.id = getId();
this._start = startTime || process.hrtime.bigint();
// hrtime cannot be used to reconstruct tracing span's actual start time
// since it does not have relation to clock time:
// `These times are relative to an arbitrary time in the past, and not related to the time of day and therefore not subject to clock drift`
// https://nodejs.org/api/process.html#processhrtimetime
// Capturing current datetime as additional metadata for external reconstruction.
this.now = Date.now();
}
// Durations are reported as microseconds. This gives 1000x the precision
// of something like Date.now(), which reports in milliseconds.
// Additionally, ~285 years can be safely represented as microseconds as
// a float64 in both JSON and JavaScript.
stop(stopTime) {
if (this.status === "stopped") {
// Don't report the same span twice.
// TODO: In the future this should throw as `.stop()` shouldn't be called multiple times.
return;
}
const end = stopTime || process.hrtime.bigint();
const duration = (end - this._start) / NUM_OF_MICROSEC_IN_NANOSEC;
this.status = "stopped";
if (duration > Number.MAX_SAFE_INTEGER) {
throw Object.defineProperty(new Error(`Duration is too long to express as float64: ${duration}`), "__NEXT_ERROR_CODE", {
value: "E513",
enumerable: false,
configurable: true
});
}
const timestamp = this._start / NUM_OF_MICROSEC_IN_NANOSEC;
const traceEvent = {
name: this.name,
duration: Number(duration),
timestamp: Number(timestamp),
id: this.id,
parentId: this.parentId,
tags: this.attrs,
startTime: this.now
};
if (duration > RECORD_SPAN_THRESHOLD_MS * 1000) {
_report.reporter.report(traceEvent);
if (shouldSaveTraceEvents) {
savedTraceEvents.push(traceEvent);
}
}
}
traceChild(name, attrs) {
return new Span({
name,
parentId: this.id,
attrs
});
}
manualTraceChild(name, // Start time in nanoseconds since epoch.
startTime, // Stop time in nanoseconds since epoch.
stopTime, attrs) {
// We need to convert the time info to the same base as hrtime since that is used usually.
const correction = process.hrtime.bigint() - BigInt(Date.now()) * NUM_OF_MILLISEC_IN_NANOSEC;
const span = new Span({
name,
parentId: this.id,
attrs,
startTime: startTime ? startTime + correction : process.hrtime.bigint()
});
span.stop(stopTime ? stopTime + correction : process.hrtime.bigint());
}
getId() {
return this.id;
}
setAttribute(key, value) {
this.attrs[key] = value;
}
traceFn(fn) {
try {
return fn(this);
} finally{
this.stop();
}
}
async traceAsyncFn(fn) {
try {
return await fn(this);
} finally{
this.stop();
}
}
}
const trace = (name, parentId, attrs)=>{
return new Span({
name,
parentId,
attrs
});
};
const flushAllTraces = (opts)=>_report.reporter.flushAll(opts);
const exportTraceState = ()=>({
defaultParentSpanId,
lastId: count,
shouldSaveTraceEvents
});
const initializeTraceState = (state)=>{
count = state.lastId;
defaultParentSpanId = state.defaultParentSpanId;
shouldSaveTraceEvents = state.shouldSaveTraceEvents;
};
function getTraceEvents() {
return savedTraceEvents;
}
function recordTraceEvents(events) {
for (const traceEvent of events){
_report.reporter.report(traceEvent);
if (traceEvent.id > count) {
count = traceEvent.id + 1;
}
}
if (shouldSaveTraceEvents) {
savedTraceEvents.push(...events);
}
}
const clearTraceEvents = ()=>savedTraceEvents = [];
//# sourceMappingURL=trace.js.map |