@ms-cloudpack/telemetry 0.11.74 → 0.12.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/NOTICE.txt +33 -429
- package/README.md +32 -51
- package/dist/chunk-5KML56LI.js +18119 -0
- package/dist/chunk-ADU6KBKW.js +28 -0
- package/dist/chunk-VFMIPDJG.js +1700 -0
- package/dist/customerSDKStats-SUTAPSAC.js +501 -0
- package/dist/getMachineId-bsd-55FFHI4W.js +48 -0
- package/dist/getMachineId-darwin-EOCJYW3I.js +47 -0
- package/dist/getMachineId-linux-UK6EGJSV.js +41 -0
- package/dist/getMachineId-unsupported-SWVFDPWO.js +31 -0
- package/dist/getMachineId-win-NT6ZG6ZZ.js +50 -0
- package/dist/httpSender-RVSDBTC3.js +15 -0
- package/dist/index.js +3166 -25141
- package/dist/statsbeatExporter-RVJLMKDF.js +15 -0
- package/lib/createResourceFromOptions.d.ts +1 -1
- package/lib/index.d.ts +5 -6
- package/lib/proxies/createProxiedSpan.d.ts +2 -0
- package/lib/proxies/createProxiedTracer.d.ts +22 -10
- package/lib/startTelemetry.d.ts +5 -4
- package/lib/types/AsyncTracer.d.ts +34 -0
- package/lib/types/TelemetryApi.d.ts +5 -6
- package/lib/types/TelemetryClient.d.ts +1 -1
- package/lib/types/TelemetryOptions.d.ts +7 -3
- package/package.json +16 -11
- package/lib/ConsoleSpanExporter.d.ts +0 -37
- package/lib/convertLogLevel.d.ts +0 -4
- package/lib/getComputerName.d.ts +0 -6
- package/lib/proxies/createImprovedStartActiveSpan.d.ts +0 -6
- package/lib/proxies/createImprovedStartActiveSpan.test.d.ts +0 -2
- package/lib/proxies/createSpanFunctionWrapper.d.ts +0 -9
- package/lib/proxies/createSpanFunctionWrapper.test.d.ts +0 -2
|
@@ -0,0 +1,1700 @@
|
|
|
1
|
+
// @ts-nocheck
|
|
2
|
+
/* eslint-disable */
|
|
3
|
+
import { createRequire as topLevelCreateRequire } from 'node:module';
|
|
4
|
+
import topLevelPath from 'node:path';
|
|
5
|
+
import topLevelUrl from 'node:url';
|
|
6
|
+
const require = topLevelCreateRequire(import.meta.url);
|
|
7
|
+
const __filename = topLevelUrl.fileURLToPath(import.meta.url);
|
|
8
|
+
const __dirname = topLevelPath.dirname(__filename);
|
|
9
|
+
var __create = Object.create;
|
|
10
|
+
var __defProp = Object.defineProperty;
|
|
11
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
12
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
13
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
14
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
15
|
+
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
16
|
+
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
|
17
|
+
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
|
|
18
|
+
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
|
|
19
|
+
}) : x)(function(x) {
|
|
20
|
+
if (typeof require !== "undefined") return require.apply(this, arguments);
|
|
21
|
+
throw Error('Dynamic require of "' + x + '" is not supported');
|
|
22
|
+
});
|
|
23
|
+
var __esm = (fn, res) => function __init() {
|
|
24
|
+
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
|
|
25
|
+
};
|
|
26
|
+
var __commonJS = (cb, mod) => function __require2() {
|
|
27
|
+
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
28
|
+
};
|
|
29
|
+
var __export = (target, all) => {
|
|
30
|
+
for (var name in all)
|
|
31
|
+
__defProp(target, name, { get: all[name], enumerable: true });
|
|
32
|
+
};
|
|
33
|
+
var __copyProps = (to, from, except, desc) => {
|
|
34
|
+
if (from && typeof from === "object" || typeof from === "function") {
|
|
35
|
+
for (let key of __getOwnPropNames(from))
|
|
36
|
+
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
37
|
+
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
38
|
+
}
|
|
39
|
+
return to;
|
|
40
|
+
};
|
|
41
|
+
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
42
|
+
// If the importer is in node compatibility mode or this is not an ESM
|
|
43
|
+
// file that has been converted to a CommonJS file using a Babel-
|
|
44
|
+
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
45
|
+
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
46
|
+
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
47
|
+
mod
|
|
48
|
+
));
|
|
49
|
+
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
50
|
+
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
51
|
+
|
|
52
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/status.js
|
|
53
|
+
var SpanStatusCode;
|
|
54
|
+
var init_status = __esm({
|
|
55
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/status.js"() {
|
|
56
|
+
(function(SpanStatusCode2) {
|
|
57
|
+
SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
|
|
58
|
+
SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
|
|
59
|
+
SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
|
|
60
|
+
})(SpanStatusCode || (SpanStatusCode = {}));
|
|
61
|
+
}
|
|
62
|
+
});
|
|
63
|
+
|
|
64
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/context/context.js
|
|
65
|
+
function createContextKey(description) {
|
|
66
|
+
return Symbol.for(description);
|
|
67
|
+
}
|
|
68
|
+
var _BaseContext, BaseContext, ROOT_CONTEXT;
|
|
69
|
+
var init_context = __esm({
|
|
70
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/context/context.js"() {
|
|
71
|
+
__name(createContextKey, "createContextKey");
|
|
72
|
+
_BaseContext = class _BaseContext {
|
|
73
|
+
/**
|
|
74
|
+
* Construct a new context which inherits values from an optional parent context.
|
|
75
|
+
*
|
|
76
|
+
* @param parentContext a context from which to inherit values
|
|
77
|
+
*/
|
|
78
|
+
constructor(parentContext) {
|
|
79
|
+
const self2 = this;
|
|
80
|
+
self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
|
|
81
|
+
self2.getValue = (key) => self2._currentContext.get(key);
|
|
82
|
+
self2.setValue = (key, value) => {
|
|
83
|
+
const context2 = new _BaseContext(self2._currentContext);
|
|
84
|
+
context2._currentContext.set(key, value);
|
|
85
|
+
return context2;
|
|
86
|
+
};
|
|
87
|
+
self2.deleteValue = (key) => {
|
|
88
|
+
const context2 = new _BaseContext(self2._currentContext);
|
|
89
|
+
context2._currentContext.delete(key);
|
|
90
|
+
return context2;
|
|
91
|
+
};
|
|
92
|
+
}
|
|
93
|
+
};
|
|
94
|
+
__name(_BaseContext, "BaseContext");
|
|
95
|
+
BaseContext = _BaseContext;
|
|
96
|
+
ROOT_CONTEXT = new BaseContext();
|
|
97
|
+
}
|
|
98
|
+
});
|
|
99
|
+
|
|
100
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/context/NoopContextManager.js
|
|
101
|
+
var _NoopContextManager, NoopContextManager;
|
|
102
|
+
var init_NoopContextManager = __esm({
|
|
103
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/context/NoopContextManager.js"() {
|
|
104
|
+
init_context();
|
|
105
|
+
_NoopContextManager = class _NoopContextManager {
|
|
106
|
+
active() {
|
|
107
|
+
return ROOT_CONTEXT;
|
|
108
|
+
}
|
|
109
|
+
with(_context, fn, thisArg, ...args) {
|
|
110
|
+
return fn.call(thisArg, ...args);
|
|
111
|
+
}
|
|
112
|
+
bind(_context, target) {
|
|
113
|
+
return target;
|
|
114
|
+
}
|
|
115
|
+
enable() {
|
|
116
|
+
return this;
|
|
117
|
+
}
|
|
118
|
+
disable() {
|
|
119
|
+
return this;
|
|
120
|
+
}
|
|
121
|
+
};
|
|
122
|
+
__name(_NoopContextManager, "NoopContextManager");
|
|
123
|
+
NoopContextManager = _NoopContextManager;
|
|
124
|
+
}
|
|
125
|
+
});
|
|
126
|
+
|
|
127
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/version.js
|
|
128
|
+
var VERSION;
|
|
129
|
+
var init_version = __esm({
|
|
130
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/version.js"() {
|
|
131
|
+
VERSION = "1.9.1";
|
|
132
|
+
}
|
|
133
|
+
});
|
|
134
|
+
|
|
135
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/internal/semver.js
|
|
136
|
+
function _makeCompatibilityCheck(ownVersion) {
|
|
137
|
+
const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
|
|
138
|
+
const rejectedVersions = /* @__PURE__ */ new Set();
|
|
139
|
+
const myVersionMatch = ownVersion.match(re);
|
|
140
|
+
if (!myVersionMatch) {
|
|
141
|
+
return () => false;
|
|
142
|
+
}
|
|
143
|
+
const ownVersionParsed = {
|
|
144
|
+
major: +myVersionMatch[1],
|
|
145
|
+
minor: +myVersionMatch[2],
|
|
146
|
+
patch: +myVersionMatch[3],
|
|
147
|
+
prerelease: myVersionMatch[4]
|
|
148
|
+
};
|
|
149
|
+
if (ownVersionParsed.prerelease != null) {
|
|
150
|
+
return /* @__PURE__ */ __name(function isExactmatch(globalVersion) {
|
|
151
|
+
return globalVersion === ownVersion;
|
|
152
|
+
}, "isExactmatch");
|
|
153
|
+
}
|
|
154
|
+
function _reject(v) {
|
|
155
|
+
rejectedVersions.add(v);
|
|
156
|
+
return false;
|
|
157
|
+
}
|
|
158
|
+
__name(_reject, "_reject");
|
|
159
|
+
function _accept(v) {
|
|
160
|
+
acceptedVersions.add(v);
|
|
161
|
+
return true;
|
|
162
|
+
}
|
|
163
|
+
__name(_accept, "_accept");
|
|
164
|
+
return /* @__PURE__ */ __name(function isCompatible2(globalVersion) {
|
|
165
|
+
if (acceptedVersions.has(globalVersion)) {
|
|
166
|
+
return true;
|
|
167
|
+
}
|
|
168
|
+
if (rejectedVersions.has(globalVersion)) {
|
|
169
|
+
return false;
|
|
170
|
+
}
|
|
171
|
+
const globalVersionMatch = globalVersion.match(re);
|
|
172
|
+
if (!globalVersionMatch) {
|
|
173
|
+
return _reject(globalVersion);
|
|
174
|
+
}
|
|
175
|
+
const globalVersionParsed = {
|
|
176
|
+
major: +globalVersionMatch[1],
|
|
177
|
+
minor: +globalVersionMatch[2],
|
|
178
|
+
patch: +globalVersionMatch[3],
|
|
179
|
+
prerelease: globalVersionMatch[4]
|
|
180
|
+
};
|
|
181
|
+
if (globalVersionParsed.prerelease != null) {
|
|
182
|
+
return _reject(globalVersion);
|
|
183
|
+
}
|
|
184
|
+
if (ownVersionParsed.major !== globalVersionParsed.major) {
|
|
185
|
+
return _reject(globalVersion);
|
|
186
|
+
}
|
|
187
|
+
if (ownVersionParsed.major === 0) {
|
|
188
|
+
if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
|
|
189
|
+
return _accept(globalVersion);
|
|
190
|
+
}
|
|
191
|
+
return _reject(globalVersion);
|
|
192
|
+
}
|
|
193
|
+
if (ownVersionParsed.minor <= globalVersionParsed.minor) {
|
|
194
|
+
return _accept(globalVersion);
|
|
195
|
+
}
|
|
196
|
+
return _reject(globalVersion);
|
|
197
|
+
}, "isCompatible");
|
|
198
|
+
}
|
|
199
|
+
var re, isCompatible;
|
|
200
|
+
var init_semver = __esm({
|
|
201
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/internal/semver.js"() {
|
|
202
|
+
init_version();
|
|
203
|
+
re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
|
|
204
|
+
__name(_makeCompatibilityCheck, "_makeCompatibilityCheck");
|
|
205
|
+
isCompatible = _makeCompatibilityCheck(VERSION);
|
|
206
|
+
}
|
|
207
|
+
});
|
|
208
|
+
|
|
209
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/internal/global-utils.js
|
|
210
|
+
function registerGlobal(type, instance, diag3, allowOverride = false) {
|
|
211
|
+
var _a;
|
|
212
|
+
const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {
|
|
213
|
+
version: VERSION
|
|
214
|
+
};
|
|
215
|
+
if (!allowOverride && api[type]) {
|
|
216
|
+
const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
|
|
217
|
+
diag3.error(err.stack || err.message);
|
|
218
|
+
return false;
|
|
219
|
+
}
|
|
220
|
+
if (api.version !== VERSION) {
|
|
221
|
+
const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
|
|
222
|
+
diag3.error(err.stack || err.message);
|
|
223
|
+
return false;
|
|
224
|
+
}
|
|
225
|
+
api[type] = instance;
|
|
226
|
+
diag3.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
|
|
227
|
+
return true;
|
|
228
|
+
}
|
|
229
|
+
function getGlobal(type) {
|
|
230
|
+
var _a, _b;
|
|
231
|
+
const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
|
|
232
|
+
if (!globalVersion || !isCompatible(globalVersion)) {
|
|
233
|
+
return;
|
|
234
|
+
}
|
|
235
|
+
return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
|
|
236
|
+
}
|
|
237
|
+
function unregisterGlobal(type, diag3) {
|
|
238
|
+
diag3.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
|
|
239
|
+
const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
|
|
240
|
+
if (api) {
|
|
241
|
+
delete api[type];
|
|
242
|
+
}
|
|
243
|
+
}
|
|
244
|
+
var major, GLOBAL_OPENTELEMETRY_API_KEY, _global;
|
|
245
|
+
var init_global_utils = __esm({
|
|
246
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/internal/global-utils.js"() {
|
|
247
|
+
init_version();
|
|
248
|
+
init_semver();
|
|
249
|
+
major = VERSION.split(".")[0];
|
|
250
|
+
GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for(`opentelemetry.js.api.${major}`);
|
|
251
|
+
_global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
|
|
252
|
+
__name(registerGlobal, "registerGlobal");
|
|
253
|
+
__name(getGlobal, "getGlobal");
|
|
254
|
+
__name(unregisterGlobal, "unregisterGlobal");
|
|
255
|
+
}
|
|
256
|
+
});
|
|
257
|
+
|
|
258
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/diag/ComponentLogger.js
|
|
259
|
+
function logProxy(funcName, namespace, args) {
|
|
260
|
+
const logger = getGlobal("diag");
|
|
261
|
+
if (!logger) {
|
|
262
|
+
return;
|
|
263
|
+
}
|
|
264
|
+
return logger[funcName](namespace, ...args);
|
|
265
|
+
}
|
|
266
|
+
var _DiagComponentLogger, DiagComponentLogger;
|
|
267
|
+
var init_ComponentLogger = __esm({
|
|
268
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/diag/ComponentLogger.js"() {
|
|
269
|
+
init_global_utils();
|
|
270
|
+
_DiagComponentLogger = class _DiagComponentLogger {
|
|
271
|
+
constructor(props) {
|
|
272
|
+
this._namespace = props.namespace || "DiagComponentLogger";
|
|
273
|
+
}
|
|
274
|
+
debug(...args) {
|
|
275
|
+
return logProxy("debug", this._namespace, args);
|
|
276
|
+
}
|
|
277
|
+
error(...args) {
|
|
278
|
+
return logProxy("error", this._namespace, args);
|
|
279
|
+
}
|
|
280
|
+
info(...args) {
|
|
281
|
+
return logProxy("info", this._namespace, args);
|
|
282
|
+
}
|
|
283
|
+
warn(...args) {
|
|
284
|
+
return logProxy("warn", this._namespace, args);
|
|
285
|
+
}
|
|
286
|
+
verbose(...args) {
|
|
287
|
+
return logProxy("verbose", this._namespace, args);
|
|
288
|
+
}
|
|
289
|
+
};
|
|
290
|
+
__name(_DiagComponentLogger, "DiagComponentLogger");
|
|
291
|
+
DiagComponentLogger = _DiagComponentLogger;
|
|
292
|
+
__name(logProxy, "logProxy");
|
|
293
|
+
}
|
|
294
|
+
});
|
|
295
|
+
|
|
296
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/diag/types.js
|
|
297
|
+
var DiagLogLevel;
|
|
298
|
+
var init_types = __esm({
|
|
299
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/diag/types.js"() {
|
|
300
|
+
(function(DiagLogLevel2) {
|
|
301
|
+
DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
|
|
302
|
+
DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
|
|
303
|
+
DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
|
|
304
|
+
DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
|
|
305
|
+
DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
|
|
306
|
+
DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
|
|
307
|
+
DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
|
|
308
|
+
})(DiagLogLevel || (DiagLogLevel = {}));
|
|
309
|
+
}
|
|
310
|
+
});
|
|
311
|
+
|
|
312
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/diag/internal/logLevelLogger.js
|
|
313
|
+
function createLogLevelDiagLogger(maxLevel, logger) {
|
|
314
|
+
if (maxLevel < DiagLogLevel.NONE) {
|
|
315
|
+
maxLevel = DiagLogLevel.NONE;
|
|
316
|
+
} else if (maxLevel > DiagLogLevel.ALL) {
|
|
317
|
+
maxLevel = DiagLogLevel.ALL;
|
|
318
|
+
}
|
|
319
|
+
logger = logger || {};
|
|
320
|
+
function _filterFunc(funcName, theLevel) {
|
|
321
|
+
const theFunc = logger[funcName];
|
|
322
|
+
if (typeof theFunc === "function" && maxLevel >= theLevel) {
|
|
323
|
+
return theFunc.bind(logger);
|
|
324
|
+
}
|
|
325
|
+
return function() {
|
|
326
|
+
};
|
|
327
|
+
}
|
|
328
|
+
__name(_filterFunc, "_filterFunc");
|
|
329
|
+
return {
|
|
330
|
+
error: _filterFunc("error", DiagLogLevel.ERROR),
|
|
331
|
+
warn: _filterFunc("warn", DiagLogLevel.WARN),
|
|
332
|
+
info: _filterFunc("info", DiagLogLevel.INFO),
|
|
333
|
+
debug: _filterFunc("debug", DiagLogLevel.DEBUG),
|
|
334
|
+
verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
|
|
335
|
+
};
|
|
336
|
+
}
|
|
337
|
+
var init_logLevelLogger = __esm({
|
|
338
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/diag/internal/logLevelLogger.js"() {
|
|
339
|
+
init_types();
|
|
340
|
+
__name(createLogLevelDiagLogger, "createLogLevelDiagLogger");
|
|
341
|
+
}
|
|
342
|
+
});
|
|
343
|
+
|
|
344
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/api/diag.js
|
|
345
|
+
var API_NAME, _DiagAPI, DiagAPI;
|
|
346
|
+
var init_diag = __esm({
|
|
347
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/api/diag.js"() {
|
|
348
|
+
init_ComponentLogger();
|
|
349
|
+
init_logLevelLogger();
|
|
350
|
+
init_types();
|
|
351
|
+
init_global_utils();
|
|
352
|
+
API_NAME = "diag";
|
|
353
|
+
_DiagAPI = class _DiagAPI {
|
|
354
|
+
/** Get the singleton instance of the DiagAPI API */
|
|
355
|
+
static instance() {
|
|
356
|
+
if (!this._instance) {
|
|
357
|
+
this._instance = new _DiagAPI();
|
|
358
|
+
}
|
|
359
|
+
return this._instance;
|
|
360
|
+
}
|
|
361
|
+
/**
|
|
362
|
+
* Private internal constructor
|
|
363
|
+
* @private
|
|
364
|
+
*/
|
|
365
|
+
constructor() {
|
|
366
|
+
function _logProxy(funcName) {
|
|
367
|
+
return function(...args) {
|
|
368
|
+
const logger = getGlobal("diag");
|
|
369
|
+
if (!logger)
|
|
370
|
+
return;
|
|
371
|
+
return logger[funcName](...args);
|
|
372
|
+
};
|
|
373
|
+
}
|
|
374
|
+
__name(_logProxy, "_logProxy");
|
|
375
|
+
const self2 = this;
|
|
376
|
+
const setLogger = /* @__PURE__ */ __name((logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
|
|
377
|
+
var _a, _b, _c;
|
|
378
|
+
if (logger === self2) {
|
|
379
|
+
const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
|
|
380
|
+
self2.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
|
|
381
|
+
return false;
|
|
382
|
+
}
|
|
383
|
+
if (typeof optionsOrLogLevel === "number") {
|
|
384
|
+
optionsOrLogLevel = {
|
|
385
|
+
logLevel: optionsOrLogLevel
|
|
386
|
+
};
|
|
387
|
+
}
|
|
388
|
+
const oldLogger = getGlobal("diag");
|
|
389
|
+
const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
|
|
390
|
+
if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
|
|
391
|
+
const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
|
|
392
|
+
oldLogger.warn(`Current logger will be overwritten from ${stack}`);
|
|
393
|
+
newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
|
|
394
|
+
}
|
|
395
|
+
return registerGlobal("diag", newLogger, self2, true);
|
|
396
|
+
}, "setLogger");
|
|
397
|
+
self2.setLogger = setLogger;
|
|
398
|
+
self2.disable = () => {
|
|
399
|
+
unregisterGlobal(API_NAME, self2);
|
|
400
|
+
};
|
|
401
|
+
self2.createComponentLogger = (options) => {
|
|
402
|
+
return new DiagComponentLogger(options);
|
|
403
|
+
};
|
|
404
|
+
self2.verbose = _logProxy("verbose");
|
|
405
|
+
self2.debug = _logProxy("debug");
|
|
406
|
+
self2.info = _logProxy("info");
|
|
407
|
+
self2.warn = _logProxy("warn");
|
|
408
|
+
self2.error = _logProxy("error");
|
|
409
|
+
}
|
|
410
|
+
};
|
|
411
|
+
__name(_DiagAPI, "DiagAPI");
|
|
412
|
+
DiagAPI = _DiagAPI;
|
|
413
|
+
}
|
|
414
|
+
});
|
|
415
|
+
|
|
416
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/api/context.js
|
|
417
|
+
var API_NAME2, NOOP_CONTEXT_MANAGER, _ContextAPI, ContextAPI;
|
|
418
|
+
var init_context2 = __esm({
|
|
419
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/api/context.js"() {
|
|
420
|
+
init_NoopContextManager();
|
|
421
|
+
init_global_utils();
|
|
422
|
+
init_diag();
|
|
423
|
+
API_NAME2 = "context";
|
|
424
|
+
NOOP_CONTEXT_MANAGER = new NoopContextManager();
|
|
425
|
+
_ContextAPI = class _ContextAPI {
|
|
426
|
+
/** Empty private constructor prevents end users from constructing a new instance of the API */
|
|
427
|
+
constructor() {
|
|
428
|
+
}
|
|
429
|
+
/** Get the singleton instance of the Context API */
|
|
430
|
+
static getInstance() {
|
|
431
|
+
if (!this._instance) {
|
|
432
|
+
this._instance = new _ContextAPI();
|
|
433
|
+
}
|
|
434
|
+
return this._instance;
|
|
435
|
+
}
|
|
436
|
+
/**
|
|
437
|
+
* Set the current context manager.
|
|
438
|
+
*
|
|
439
|
+
* @returns true if the context manager was successfully registered, else false
|
|
440
|
+
*/
|
|
441
|
+
setGlobalContextManager(contextManager) {
|
|
442
|
+
return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
|
|
443
|
+
}
|
|
444
|
+
/**
|
|
445
|
+
* Get the currently active context
|
|
446
|
+
*/
|
|
447
|
+
active() {
|
|
448
|
+
return this._getContextManager().active();
|
|
449
|
+
}
|
|
450
|
+
/**
|
|
451
|
+
* Execute a function with an active context
|
|
452
|
+
*
|
|
453
|
+
* @param context context to be active during function execution
|
|
454
|
+
* @param fn function to execute in a context
|
|
455
|
+
* @param thisArg optional receiver to be used for calling fn
|
|
456
|
+
* @param args optional arguments forwarded to fn
|
|
457
|
+
*/
|
|
458
|
+
with(context2, fn, thisArg, ...args) {
|
|
459
|
+
return this._getContextManager().with(context2, fn, thisArg, ...args);
|
|
460
|
+
}
|
|
461
|
+
/**
|
|
462
|
+
* Bind a context to a target function or event emitter
|
|
463
|
+
*
|
|
464
|
+
* @param context context to bind to the event emitter or function. Defaults to the currently active context
|
|
465
|
+
* @param target function or event emitter to bind
|
|
466
|
+
*/
|
|
467
|
+
bind(context2, target) {
|
|
468
|
+
return this._getContextManager().bind(context2, target);
|
|
469
|
+
}
|
|
470
|
+
_getContextManager() {
|
|
471
|
+
return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
|
|
472
|
+
}
|
|
473
|
+
/** Disable and remove the global context manager */
|
|
474
|
+
disable() {
|
|
475
|
+
this._getContextManager().disable();
|
|
476
|
+
unregisterGlobal(API_NAME2, DiagAPI.instance());
|
|
477
|
+
}
|
|
478
|
+
};
|
|
479
|
+
__name(_ContextAPI, "ContextAPI");
|
|
480
|
+
ContextAPI = _ContextAPI;
|
|
481
|
+
}
|
|
482
|
+
});
|
|
483
|
+
|
|
484
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/context-api.js
|
|
485
|
+
var context;
|
|
486
|
+
var init_context_api = __esm({
|
|
487
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/context-api.js"() {
|
|
488
|
+
init_context2();
|
|
489
|
+
context = ContextAPI.getInstance();
|
|
490
|
+
}
|
|
491
|
+
});
|
|
492
|
+
|
|
493
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/diag-api.js
|
|
494
|
+
var diag;
|
|
495
|
+
var init_diag_api = __esm({
|
|
496
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/diag-api.js"() {
|
|
497
|
+
init_diag();
|
|
498
|
+
diag = DiagAPI.instance();
|
|
499
|
+
}
|
|
500
|
+
});
|
|
501
|
+
|
|
502
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/baggage/internal/baggage-impl.js
|
|
503
|
+
var _BaggageImpl, BaggageImpl;
|
|
504
|
+
var init_baggage_impl = __esm({
|
|
505
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/baggage/internal/baggage-impl.js"() {
|
|
506
|
+
_BaggageImpl = class _BaggageImpl {
|
|
507
|
+
constructor(entries) {
|
|
508
|
+
this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
|
|
509
|
+
}
|
|
510
|
+
getEntry(key) {
|
|
511
|
+
const entry = this._entries.get(key);
|
|
512
|
+
if (!entry) {
|
|
513
|
+
return void 0;
|
|
514
|
+
}
|
|
515
|
+
return Object.assign({}, entry);
|
|
516
|
+
}
|
|
517
|
+
getAllEntries() {
|
|
518
|
+
return Array.from(this._entries.entries());
|
|
519
|
+
}
|
|
520
|
+
setEntry(key, entry) {
|
|
521
|
+
const newBaggage = new _BaggageImpl(this._entries);
|
|
522
|
+
newBaggage._entries.set(key, entry);
|
|
523
|
+
return newBaggage;
|
|
524
|
+
}
|
|
525
|
+
removeEntry(key) {
|
|
526
|
+
const newBaggage = new _BaggageImpl(this._entries);
|
|
527
|
+
newBaggage._entries.delete(key);
|
|
528
|
+
return newBaggage;
|
|
529
|
+
}
|
|
530
|
+
removeEntries(...keys) {
|
|
531
|
+
const newBaggage = new _BaggageImpl(this._entries);
|
|
532
|
+
for (const key of keys) {
|
|
533
|
+
newBaggage._entries.delete(key);
|
|
534
|
+
}
|
|
535
|
+
return newBaggage;
|
|
536
|
+
}
|
|
537
|
+
clear() {
|
|
538
|
+
return new _BaggageImpl();
|
|
539
|
+
}
|
|
540
|
+
};
|
|
541
|
+
__name(_BaggageImpl, "BaggageImpl");
|
|
542
|
+
BaggageImpl = _BaggageImpl;
|
|
543
|
+
}
|
|
544
|
+
});
|
|
545
|
+
|
|
546
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/baggage/internal/symbol.js
|
|
547
|
+
var baggageEntryMetadataSymbol;
|
|
548
|
+
var init_symbol = __esm({
|
|
549
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/baggage/internal/symbol.js"() {
|
|
550
|
+
baggageEntryMetadataSymbol = /* @__PURE__ */ Symbol("BaggageEntryMetadata");
|
|
551
|
+
}
|
|
552
|
+
});
|
|
553
|
+
|
|
554
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/baggage/utils.js
|
|
555
|
+
function createBaggage(entries = {}) {
|
|
556
|
+
return new BaggageImpl(new Map(Object.entries(entries)));
|
|
557
|
+
}
|
|
558
|
+
function baggageEntryMetadataFromString(str) {
|
|
559
|
+
if (typeof str !== "string") {
|
|
560
|
+
diag2.error(`Cannot create baggage metadata from unknown type: ${typeof str}`);
|
|
561
|
+
str = "";
|
|
562
|
+
}
|
|
563
|
+
return {
|
|
564
|
+
__TYPE__: baggageEntryMetadataSymbol,
|
|
565
|
+
toString() {
|
|
566
|
+
return str;
|
|
567
|
+
}
|
|
568
|
+
};
|
|
569
|
+
}
|
|
570
|
+
var diag2;
|
|
571
|
+
var init_utils = __esm({
|
|
572
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/baggage/utils.js"() {
|
|
573
|
+
init_diag();
|
|
574
|
+
init_baggage_impl();
|
|
575
|
+
init_symbol();
|
|
576
|
+
diag2 = DiagAPI.instance();
|
|
577
|
+
__name(createBaggage, "createBaggage");
|
|
578
|
+
__name(baggageEntryMetadataFromString, "baggageEntryMetadataFromString");
|
|
579
|
+
}
|
|
580
|
+
});
|
|
581
|
+
|
|
582
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/diag/consoleLogger.js
|
|
583
|
+
var consoleMap, _originalConsoleMethods, _DiagConsoleLogger, DiagConsoleLogger;
|
|
584
|
+
var init_consoleLogger = __esm({
|
|
585
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/diag/consoleLogger.js"() {
|
|
586
|
+
consoleMap = [
|
|
587
|
+
{ n: "error", c: "error" },
|
|
588
|
+
{ n: "warn", c: "warn" },
|
|
589
|
+
{ n: "info", c: "info" },
|
|
590
|
+
{ n: "debug", c: "debug" },
|
|
591
|
+
{ n: "verbose", c: "trace" }
|
|
592
|
+
];
|
|
593
|
+
_originalConsoleMethods = {};
|
|
594
|
+
if (typeof console !== "undefined") {
|
|
595
|
+
const keys = [
|
|
596
|
+
"error",
|
|
597
|
+
"warn",
|
|
598
|
+
"info",
|
|
599
|
+
"debug",
|
|
600
|
+
"trace",
|
|
601
|
+
"log"
|
|
602
|
+
];
|
|
603
|
+
for (const key of keys) {
|
|
604
|
+
if (typeof console[key] === "function") {
|
|
605
|
+
_originalConsoleMethods[key] = console[key];
|
|
606
|
+
}
|
|
607
|
+
}
|
|
608
|
+
}
|
|
609
|
+
_DiagConsoleLogger = class _DiagConsoleLogger {
|
|
610
|
+
constructor() {
|
|
611
|
+
function _consoleFunc(funcName) {
|
|
612
|
+
return function(...args) {
|
|
613
|
+
let theFunc = _originalConsoleMethods[funcName];
|
|
614
|
+
if (typeof theFunc !== "function") {
|
|
615
|
+
theFunc = _originalConsoleMethods["log"];
|
|
616
|
+
}
|
|
617
|
+
if (typeof theFunc !== "function" && console) {
|
|
618
|
+
theFunc = console[funcName];
|
|
619
|
+
if (typeof theFunc !== "function") {
|
|
620
|
+
theFunc = console.log;
|
|
621
|
+
}
|
|
622
|
+
}
|
|
623
|
+
if (typeof theFunc === "function") {
|
|
624
|
+
return theFunc.apply(console, args);
|
|
625
|
+
}
|
|
626
|
+
};
|
|
627
|
+
}
|
|
628
|
+
__name(_consoleFunc, "_consoleFunc");
|
|
629
|
+
for (let i = 0; i < consoleMap.length; i++) {
|
|
630
|
+
this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);
|
|
631
|
+
}
|
|
632
|
+
}
|
|
633
|
+
};
|
|
634
|
+
__name(_DiagConsoleLogger, "DiagConsoleLogger");
|
|
635
|
+
DiagConsoleLogger = _DiagConsoleLogger;
|
|
636
|
+
}
|
|
637
|
+
});
|
|
638
|
+
|
|
639
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/metrics/NoopMeter.js
|
|
640
|
+
function createNoopMeter() {
|
|
641
|
+
return NOOP_METER;
|
|
642
|
+
}
|
|
643
|
+
var _NoopMeter, NoopMeter, _NoopMetric, NoopMetric, _NoopCounterMetric, NoopCounterMetric, _NoopUpDownCounterMetric, NoopUpDownCounterMetric, _NoopGaugeMetric, NoopGaugeMetric, _NoopHistogramMetric, NoopHistogramMetric, _NoopObservableMetric, NoopObservableMetric, _NoopObservableCounterMetric, NoopObservableCounterMetric, _NoopObservableGaugeMetric, NoopObservableGaugeMetric, _NoopObservableUpDownCounterMetric, NoopObservableUpDownCounterMetric, NOOP_METER, NOOP_COUNTER_METRIC, NOOP_GAUGE_METRIC, NOOP_HISTOGRAM_METRIC, NOOP_UP_DOWN_COUNTER_METRIC, NOOP_OBSERVABLE_COUNTER_METRIC, NOOP_OBSERVABLE_GAUGE_METRIC, NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
|
|
644
|
+
var init_NoopMeter = __esm({
|
|
645
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/metrics/NoopMeter.js"() {
|
|
646
|
+
_NoopMeter = class _NoopMeter {
|
|
647
|
+
constructor() {
|
|
648
|
+
}
|
|
649
|
+
/**
|
|
650
|
+
* @see {@link Meter.createGauge}
|
|
651
|
+
*/
|
|
652
|
+
createGauge(_name, _options) {
|
|
653
|
+
return NOOP_GAUGE_METRIC;
|
|
654
|
+
}
|
|
655
|
+
/**
|
|
656
|
+
* @see {@link Meter.createHistogram}
|
|
657
|
+
*/
|
|
658
|
+
createHistogram(_name, _options) {
|
|
659
|
+
return NOOP_HISTOGRAM_METRIC;
|
|
660
|
+
}
|
|
661
|
+
/**
|
|
662
|
+
* @see {@link Meter.createCounter}
|
|
663
|
+
*/
|
|
664
|
+
createCounter(_name, _options) {
|
|
665
|
+
return NOOP_COUNTER_METRIC;
|
|
666
|
+
}
|
|
667
|
+
/**
|
|
668
|
+
* @see {@link Meter.createUpDownCounter}
|
|
669
|
+
*/
|
|
670
|
+
createUpDownCounter(_name, _options) {
|
|
671
|
+
return NOOP_UP_DOWN_COUNTER_METRIC;
|
|
672
|
+
}
|
|
673
|
+
/**
|
|
674
|
+
* @see {@link Meter.createObservableGauge}
|
|
675
|
+
*/
|
|
676
|
+
createObservableGauge(_name, _options) {
|
|
677
|
+
return NOOP_OBSERVABLE_GAUGE_METRIC;
|
|
678
|
+
}
|
|
679
|
+
/**
|
|
680
|
+
* @see {@link Meter.createObservableCounter}
|
|
681
|
+
*/
|
|
682
|
+
createObservableCounter(_name, _options) {
|
|
683
|
+
return NOOP_OBSERVABLE_COUNTER_METRIC;
|
|
684
|
+
}
|
|
685
|
+
/**
|
|
686
|
+
* @see {@link Meter.createObservableUpDownCounter}
|
|
687
|
+
*/
|
|
688
|
+
createObservableUpDownCounter(_name, _options) {
|
|
689
|
+
return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;
|
|
690
|
+
}
|
|
691
|
+
/**
|
|
692
|
+
* @see {@link Meter.addBatchObservableCallback}
|
|
693
|
+
*/
|
|
694
|
+
addBatchObservableCallback(_callback, _observables) {
|
|
695
|
+
}
|
|
696
|
+
/**
|
|
697
|
+
* @see {@link Meter.removeBatchObservableCallback}
|
|
698
|
+
*/
|
|
699
|
+
removeBatchObservableCallback(_callback) {
|
|
700
|
+
}
|
|
701
|
+
};
|
|
702
|
+
__name(_NoopMeter, "NoopMeter");
|
|
703
|
+
NoopMeter = _NoopMeter;
|
|
704
|
+
_NoopMetric = class _NoopMetric {
|
|
705
|
+
};
|
|
706
|
+
__name(_NoopMetric, "NoopMetric");
|
|
707
|
+
NoopMetric = _NoopMetric;
|
|
708
|
+
_NoopCounterMetric = class _NoopCounterMetric extends NoopMetric {
|
|
709
|
+
add(_value, _attributes) {
|
|
710
|
+
}
|
|
711
|
+
};
|
|
712
|
+
__name(_NoopCounterMetric, "NoopCounterMetric");
|
|
713
|
+
NoopCounterMetric = _NoopCounterMetric;
|
|
714
|
+
_NoopUpDownCounterMetric = class _NoopUpDownCounterMetric extends NoopMetric {
|
|
715
|
+
add(_value, _attributes) {
|
|
716
|
+
}
|
|
717
|
+
};
|
|
718
|
+
__name(_NoopUpDownCounterMetric, "NoopUpDownCounterMetric");
|
|
719
|
+
NoopUpDownCounterMetric = _NoopUpDownCounterMetric;
|
|
720
|
+
_NoopGaugeMetric = class _NoopGaugeMetric extends NoopMetric {
|
|
721
|
+
record(_value, _attributes) {
|
|
722
|
+
}
|
|
723
|
+
};
|
|
724
|
+
__name(_NoopGaugeMetric, "NoopGaugeMetric");
|
|
725
|
+
NoopGaugeMetric = _NoopGaugeMetric;
|
|
726
|
+
_NoopHistogramMetric = class _NoopHistogramMetric extends NoopMetric {
|
|
727
|
+
record(_value, _attributes) {
|
|
728
|
+
}
|
|
729
|
+
};
|
|
730
|
+
__name(_NoopHistogramMetric, "NoopHistogramMetric");
|
|
731
|
+
NoopHistogramMetric = _NoopHistogramMetric;
|
|
732
|
+
_NoopObservableMetric = class _NoopObservableMetric {
|
|
733
|
+
addCallback(_callback) {
|
|
734
|
+
}
|
|
735
|
+
removeCallback(_callback) {
|
|
736
|
+
}
|
|
737
|
+
};
|
|
738
|
+
__name(_NoopObservableMetric, "NoopObservableMetric");
|
|
739
|
+
NoopObservableMetric = _NoopObservableMetric;
|
|
740
|
+
_NoopObservableCounterMetric = class _NoopObservableCounterMetric extends NoopObservableMetric {
|
|
741
|
+
};
|
|
742
|
+
__name(_NoopObservableCounterMetric, "NoopObservableCounterMetric");
|
|
743
|
+
NoopObservableCounterMetric = _NoopObservableCounterMetric;
|
|
744
|
+
_NoopObservableGaugeMetric = class _NoopObservableGaugeMetric extends NoopObservableMetric {
|
|
745
|
+
};
|
|
746
|
+
__name(_NoopObservableGaugeMetric, "NoopObservableGaugeMetric");
|
|
747
|
+
NoopObservableGaugeMetric = _NoopObservableGaugeMetric;
|
|
748
|
+
_NoopObservableUpDownCounterMetric = class _NoopObservableUpDownCounterMetric extends NoopObservableMetric {
|
|
749
|
+
};
|
|
750
|
+
__name(_NoopObservableUpDownCounterMetric, "NoopObservableUpDownCounterMetric");
|
|
751
|
+
NoopObservableUpDownCounterMetric = _NoopObservableUpDownCounterMetric;
|
|
752
|
+
NOOP_METER = new NoopMeter();
|
|
753
|
+
NOOP_COUNTER_METRIC = new NoopCounterMetric();
|
|
754
|
+
NOOP_GAUGE_METRIC = new NoopGaugeMetric();
|
|
755
|
+
NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();
|
|
756
|
+
NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();
|
|
757
|
+
NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();
|
|
758
|
+
NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();
|
|
759
|
+
NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();
|
|
760
|
+
__name(createNoopMeter, "createNoopMeter");
|
|
761
|
+
}
|
|
762
|
+
});
|
|
763
|
+
|
|
764
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/metrics/Metric.js
|
|
765
|
+
var ValueType;
|
|
766
|
+
var init_Metric = __esm({
|
|
767
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/metrics/Metric.js"() {
|
|
768
|
+
(function(ValueType2) {
|
|
769
|
+
ValueType2[ValueType2["INT"] = 0] = "INT";
|
|
770
|
+
ValueType2[ValueType2["DOUBLE"] = 1] = "DOUBLE";
|
|
771
|
+
})(ValueType || (ValueType = {}));
|
|
772
|
+
}
|
|
773
|
+
});
|
|
774
|
+
|
|
775
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/propagation/TextMapPropagator.js
|
|
776
|
+
var defaultTextMapGetter, defaultTextMapSetter;
|
|
777
|
+
var init_TextMapPropagator = __esm({
|
|
778
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/propagation/TextMapPropagator.js"() {
|
|
779
|
+
defaultTextMapGetter = {
|
|
780
|
+
get(carrier, key) {
|
|
781
|
+
if (carrier == null) {
|
|
782
|
+
return void 0;
|
|
783
|
+
}
|
|
784
|
+
return carrier[key];
|
|
785
|
+
},
|
|
786
|
+
keys(carrier) {
|
|
787
|
+
if (carrier == null) {
|
|
788
|
+
return [];
|
|
789
|
+
}
|
|
790
|
+
return Object.keys(carrier);
|
|
791
|
+
}
|
|
792
|
+
};
|
|
793
|
+
defaultTextMapSetter = {
|
|
794
|
+
set(carrier, key, value) {
|
|
795
|
+
if (carrier == null) {
|
|
796
|
+
return;
|
|
797
|
+
}
|
|
798
|
+
carrier[key] = value;
|
|
799
|
+
}
|
|
800
|
+
};
|
|
801
|
+
}
|
|
802
|
+
});
|
|
803
|
+
|
|
804
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/trace_flags.js
|
|
805
|
+
var TraceFlags;
|
|
806
|
+
var init_trace_flags = __esm({
|
|
807
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/trace_flags.js"() {
|
|
808
|
+
(function(TraceFlags2) {
|
|
809
|
+
TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
|
|
810
|
+
TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
|
|
811
|
+
})(TraceFlags || (TraceFlags = {}));
|
|
812
|
+
}
|
|
813
|
+
});
|
|
814
|
+
|
|
815
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/invalid-span-constants.js
|
|
816
|
+
var INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT;
|
|
817
|
+
var init_invalid_span_constants = __esm({
|
|
818
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/invalid-span-constants.js"() {
|
|
819
|
+
init_trace_flags();
|
|
820
|
+
INVALID_SPANID = "0000000000000000";
|
|
821
|
+
INVALID_TRACEID = "00000000000000000000000000000000";
|
|
822
|
+
INVALID_SPAN_CONTEXT = {
|
|
823
|
+
traceId: INVALID_TRACEID,
|
|
824
|
+
spanId: INVALID_SPANID,
|
|
825
|
+
traceFlags: TraceFlags.NONE
|
|
826
|
+
};
|
|
827
|
+
}
|
|
828
|
+
});
|
|
829
|
+
|
|
830
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/NonRecordingSpan.js
|
|
831
|
+
var _NonRecordingSpan, NonRecordingSpan;
|
|
832
|
+
var init_NonRecordingSpan = __esm({
|
|
833
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/NonRecordingSpan.js"() {
|
|
834
|
+
init_invalid_span_constants();
|
|
835
|
+
_NonRecordingSpan = class _NonRecordingSpan {
|
|
836
|
+
constructor(spanContext = INVALID_SPAN_CONTEXT) {
|
|
837
|
+
this._spanContext = spanContext;
|
|
838
|
+
}
|
|
839
|
+
// Returns a SpanContext.
|
|
840
|
+
spanContext() {
|
|
841
|
+
return this._spanContext;
|
|
842
|
+
}
|
|
843
|
+
// By default does nothing
|
|
844
|
+
setAttribute(_key, _value) {
|
|
845
|
+
return this;
|
|
846
|
+
}
|
|
847
|
+
// By default does nothing
|
|
848
|
+
setAttributes(_attributes) {
|
|
849
|
+
return this;
|
|
850
|
+
}
|
|
851
|
+
// By default does nothing
|
|
852
|
+
addEvent(_name, _attributes) {
|
|
853
|
+
return this;
|
|
854
|
+
}
|
|
855
|
+
addLink(_link) {
|
|
856
|
+
return this;
|
|
857
|
+
}
|
|
858
|
+
addLinks(_links) {
|
|
859
|
+
return this;
|
|
860
|
+
}
|
|
861
|
+
// By default does nothing
|
|
862
|
+
setStatus(_status) {
|
|
863
|
+
return this;
|
|
864
|
+
}
|
|
865
|
+
// By default does nothing
|
|
866
|
+
updateName(_name) {
|
|
867
|
+
return this;
|
|
868
|
+
}
|
|
869
|
+
// By default does nothing
|
|
870
|
+
end(_endTime) {
|
|
871
|
+
}
|
|
872
|
+
// isRecording always returns false for NonRecordingSpan.
|
|
873
|
+
isRecording() {
|
|
874
|
+
return false;
|
|
875
|
+
}
|
|
876
|
+
// By default does nothing
|
|
877
|
+
recordException(_exception, _time) {
|
|
878
|
+
}
|
|
879
|
+
};
|
|
880
|
+
__name(_NonRecordingSpan, "NonRecordingSpan");
|
|
881
|
+
NonRecordingSpan = _NonRecordingSpan;
|
|
882
|
+
}
|
|
883
|
+
});
|
|
884
|
+
|
|
885
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/context-utils.js
|
|
886
|
+
function getSpan(context2) {
|
|
887
|
+
return context2.getValue(SPAN_KEY) || void 0;
|
|
888
|
+
}
|
|
889
|
+
function getActiveSpan() {
|
|
890
|
+
return getSpan(ContextAPI.getInstance().active());
|
|
891
|
+
}
|
|
892
|
+
function setSpan(context2, span) {
|
|
893
|
+
return context2.setValue(SPAN_KEY, span);
|
|
894
|
+
}
|
|
895
|
+
function deleteSpan(context2) {
|
|
896
|
+
return context2.deleteValue(SPAN_KEY);
|
|
897
|
+
}
|
|
898
|
+
function setSpanContext(context2, spanContext) {
|
|
899
|
+
return setSpan(context2, new NonRecordingSpan(spanContext));
|
|
900
|
+
}
|
|
901
|
+
function getSpanContext(context2) {
|
|
902
|
+
var _a;
|
|
903
|
+
return (_a = getSpan(context2)) === null || _a === void 0 ? void 0 : _a.spanContext();
|
|
904
|
+
}
|
|
905
|
+
var SPAN_KEY;
|
|
906
|
+
var init_context_utils = __esm({
|
|
907
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/context-utils.js"() {
|
|
908
|
+
init_context();
|
|
909
|
+
init_NonRecordingSpan();
|
|
910
|
+
init_context2();
|
|
911
|
+
SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
|
|
912
|
+
__name(getSpan, "getSpan");
|
|
913
|
+
__name(getActiveSpan, "getActiveSpan");
|
|
914
|
+
__name(setSpan, "setSpan");
|
|
915
|
+
__name(deleteSpan, "deleteSpan");
|
|
916
|
+
__name(setSpanContext, "setSpanContext");
|
|
917
|
+
__name(getSpanContext, "getSpanContext");
|
|
918
|
+
}
|
|
919
|
+
});
|
|
920
|
+
|
|
921
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/spancontext-utils.js
|
|
922
|
+
function isValidHex(id, length) {
|
|
923
|
+
if (typeof id !== "string" || id.length !== length)
|
|
924
|
+
return false;
|
|
925
|
+
let r = 0;
|
|
926
|
+
for (let i = 0; i < id.length; i += 4) {
|
|
927
|
+
r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
|
|
928
|
+
}
|
|
929
|
+
return r === length;
|
|
930
|
+
}
|
|
931
|
+
function isValidTraceId(traceId) {
|
|
932
|
+
return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID;
|
|
933
|
+
}
|
|
934
|
+
function isValidSpanId(spanId) {
|
|
935
|
+
return isValidHex(spanId, 16) && spanId !== INVALID_SPANID;
|
|
936
|
+
}
|
|
937
|
+
function isSpanContextValid(spanContext) {
|
|
938
|
+
return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
|
|
939
|
+
}
|
|
940
|
+
function wrapSpanContext(spanContext) {
|
|
941
|
+
return new NonRecordingSpan(spanContext);
|
|
942
|
+
}
|
|
943
|
+
var isHex;
|
|
944
|
+
var init_spancontext_utils = __esm({
|
|
945
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/spancontext-utils.js"() {
|
|
946
|
+
init_invalid_span_constants();
|
|
947
|
+
init_NonRecordingSpan();
|
|
948
|
+
isHex = new Uint8Array([
|
|
949
|
+
0,
|
|
950
|
+
0,
|
|
951
|
+
0,
|
|
952
|
+
0,
|
|
953
|
+
0,
|
|
954
|
+
0,
|
|
955
|
+
0,
|
|
956
|
+
0,
|
|
957
|
+
0,
|
|
958
|
+
0,
|
|
959
|
+
0,
|
|
960
|
+
0,
|
|
961
|
+
0,
|
|
962
|
+
0,
|
|
963
|
+
0,
|
|
964
|
+
0,
|
|
965
|
+
0,
|
|
966
|
+
0,
|
|
967
|
+
0,
|
|
968
|
+
0,
|
|
969
|
+
0,
|
|
970
|
+
0,
|
|
971
|
+
0,
|
|
972
|
+
0,
|
|
973
|
+
0,
|
|
974
|
+
0,
|
|
975
|
+
0,
|
|
976
|
+
0,
|
|
977
|
+
0,
|
|
978
|
+
0,
|
|
979
|
+
0,
|
|
980
|
+
0,
|
|
981
|
+
0,
|
|
982
|
+
0,
|
|
983
|
+
0,
|
|
984
|
+
0,
|
|
985
|
+
0,
|
|
986
|
+
0,
|
|
987
|
+
0,
|
|
988
|
+
0,
|
|
989
|
+
0,
|
|
990
|
+
0,
|
|
991
|
+
0,
|
|
992
|
+
0,
|
|
993
|
+
0,
|
|
994
|
+
0,
|
|
995
|
+
0,
|
|
996
|
+
0,
|
|
997
|
+
1,
|
|
998
|
+
1,
|
|
999
|
+
1,
|
|
1000
|
+
1,
|
|
1001
|
+
1,
|
|
1002
|
+
1,
|
|
1003
|
+
1,
|
|
1004
|
+
1,
|
|
1005
|
+
1,
|
|
1006
|
+
1,
|
|
1007
|
+
0,
|
|
1008
|
+
0,
|
|
1009
|
+
0,
|
|
1010
|
+
0,
|
|
1011
|
+
0,
|
|
1012
|
+
0,
|
|
1013
|
+
0,
|
|
1014
|
+
1,
|
|
1015
|
+
1,
|
|
1016
|
+
1,
|
|
1017
|
+
1,
|
|
1018
|
+
1,
|
|
1019
|
+
1,
|
|
1020
|
+
0,
|
|
1021
|
+
0,
|
|
1022
|
+
0,
|
|
1023
|
+
0,
|
|
1024
|
+
0,
|
|
1025
|
+
0,
|
|
1026
|
+
0,
|
|
1027
|
+
0,
|
|
1028
|
+
0,
|
|
1029
|
+
0,
|
|
1030
|
+
0,
|
|
1031
|
+
0,
|
|
1032
|
+
0,
|
|
1033
|
+
0,
|
|
1034
|
+
0,
|
|
1035
|
+
0,
|
|
1036
|
+
0,
|
|
1037
|
+
0,
|
|
1038
|
+
0,
|
|
1039
|
+
0,
|
|
1040
|
+
0,
|
|
1041
|
+
0,
|
|
1042
|
+
0,
|
|
1043
|
+
0,
|
|
1044
|
+
0,
|
|
1045
|
+
0,
|
|
1046
|
+
1,
|
|
1047
|
+
1,
|
|
1048
|
+
1,
|
|
1049
|
+
1,
|
|
1050
|
+
1,
|
|
1051
|
+
1
|
|
1052
|
+
]);
|
|
1053
|
+
__name(isValidHex, "isValidHex");
|
|
1054
|
+
__name(isValidTraceId, "isValidTraceId");
|
|
1055
|
+
__name(isValidSpanId, "isValidSpanId");
|
|
1056
|
+
__name(isSpanContextValid, "isSpanContextValid");
|
|
1057
|
+
__name(wrapSpanContext, "wrapSpanContext");
|
|
1058
|
+
}
|
|
1059
|
+
});
|
|
1060
|
+
|
|
1061
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/NoopTracer.js
|
|
1062
|
+
function isSpanContext(spanContext) {
|
|
1063
|
+
return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
|
|
1064
|
+
}
|
|
1065
|
+
var contextApi, _NoopTracer, NoopTracer;
|
|
1066
|
+
var init_NoopTracer = __esm({
|
|
1067
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/NoopTracer.js"() {
|
|
1068
|
+
init_context2();
|
|
1069
|
+
init_context_utils();
|
|
1070
|
+
init_NonRecordingSpan();
|
|
1071
|
+
init_spancontext_utils();
|
|
1072
|
+
contextApi = ContextAPI.getInstance();
|
|
1073
|
+
_NoopTracer = class _NoopTracer {
|
|
1074
|
+
// startSpan starts a noop span.
|
|
1075
|
+
startSpan(name, options, context2 = contextApi.active()) {
|
|
1076
|
+
const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
|
|
1077
|
+
if (root) {
|
|
1078
|
+
return new NonRecordingSpan();
|
|
1079
|
+
}
|
|
1080
|
+
const parentFromContext = context2 && getSpanContext(context2);
|
|
1081
|
+
if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
|
|
1082
|
+
return new NonRecordingSpan(parentFromContext);
|
|
1083
|
+
} else {
|
|
1084
|
+
return new NonRecordingSpan();
|
|
1085
|
+
}
|
|
1086
|
+
}
|
|
1087
|
+
startActiveSpan(name, arg2, arg3, arg4) {
|
|
1088
|
+
let opts;
|
|
1089
|
+
let ctx;
|
|
1090
|
+
let fn;
|
|
1091
|
+
if (arguments.length < 2) {
|
|
1092
|
+
return;
|
|
1093
|
+
} else if (arguments.length === 2) {
|
|
1094
|
+
fn = arg2;
|
|
1095
|
+
} else if (arguments.length === 3) {
|
|
1096
|
+
opts = arg2;
|
|
1097
|
+
fn = arg3;
|
|
1098
|
+
} else {
|
|
1099
|
+
opts = arg2;
|
|
1100
|
+
ctx = arg3;
|
|
1101
|
+
fn = arg4;
|
|
1102
|
+
}
|
|
1103
|
+
const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
|
|
1104
|
+
const span = this.startSpan(name, opts, parentContext);
|
|
1105
|
+
const contextWithSpanSet = setSpan(parentContext, span);
|
|
1106
|
+
return contextApi.with(contextWithSpanSet, fn, void 0, span);
|
|
1107
|
+
}
|
|
1108
|
+
};
|
|
1109
|
+
__name(_NoopTracer, "NoopTracer");
|
|
1110
|
+
NoopTracer = _NoopTracer;
|
|
1111
|
+
__name(isSpanContext, "isSpanContext");
|
|
1112
|
+
}
|
|
1113
|
+
});
|
|
1114
|
+
|
|
1115
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/ProxyTracer.js
|
|
1116
|
+
var NOOP_TRACER, _ProxyTracer, ProxyTracer;
|
|
1117
|
+
var init_ProxyTracer = __esm({
|
|
1118
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/ProxyTracer.js"() {
|
|
1119
|
+
init_NoopTracer();
|
|
1120
|
+
NOOP_TRACER = new NoopTracer();
|
|
1121
|
+
_ProxyTracer = class _ProxyTracer {
|
|
1122
|
+
constructor(provider, name, version, options) {
|
|
1123
|
+
this._provider = provider;
|
|
1124
|
+
this.name = name;
|
|
1125
|
+
this.version = version;
|
|
1126
|
+
this.options = options;
|
|
1127
|
+
}
|
|
1128
|
+
startSpan(name, options, context2) {
|
|
1129
|
+
return this._getTracer().startSpan(name, options, context2);
|
|
1130
|
+
}
|
|
1131
|
+
startActiveSpan(_name, _options, _context, _fn) {
|
|
1132
|
+
const tracer = this._getTracer();
|
|
1133
|
+
return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
|
|
1134
|
+
}
|
|
1135
|
+
/**
|
|
1136
|
+
* Try to get a tracer from the proxy tracer provider.
|
|
1137
|
+
* If the proxy tracer provider has no delegate, return a noop tracer.
|
|
1138
|
+
*/
|
|
1139
|
+
_getTracer() {
|
|
1140
|
+
if (this._delegate) {
|
|
1141
|
+
return this._delegate;
|
|
1142
|
+
}
|
|
1143
|
+
const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
|
|
1144
|
+
if (!tracer) {
|
|
1145
|
+
return NOOP_TRACER;
|
|
1146
|
+
}
|
|
1147
|
+
this._delegate = tracer;
|
|
1148
|
+
return this._delegate;
|
|
1149
|
+
}
|
|
1150
|
+
};
|
|
1151
|
+
__name(_ProxyTracer, "ProxyTracer");
|
|
1152
|
+
ProxyTracer = _ProxyTracer;
|
|
1153
|
+
}
|
|
1154
|
+
});
|
|
1155
|
+
|
|
1156
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/NoopTracerProvider.js
|
|
1157
|
+
var _NoopTracerProvider, NoopTracerProvider;
|
|
1158
|
+
var init_NoopTracerProvider = __esm({
|
|
1159
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/NoopTracerProvider.js"() {
|
|
1160
|
+
init_NoopTracer();
|
|
1161
|
+
_NoopTracerProvider = class _NoopTracerProvider {
|
|
1162
|
+
getTracer(_name, _version, _options) {
|
|
1163
|
+
return new NoopTracer();
|
|
1164
|
+
}
|
|
1165
|
+
};
|
|
1166
|
+
__name(_NoopTracerProvider, "NoopTracerProvider");
|
|
1167
|
+
NoopTracerProvider = _NoopTracerProvider;
|
|
1168
|
+
}
|
|
1169
|
+
});
|
|
1170
|
+
|
|
1171
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/ProxyTracerProvider.js
|
|
1172
|
+
var NOOP_TRACER_PROVIDER, _ProxyTracerProvider, ProxyTracerProvider;
|
|
1173
|
+
var init_ProxyTracerProvider = __esm({
|
|
1174
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/ProxyTracerProvider.js"() {
|
|
1175
|
+
init_ProxyTracer();
|
|
1176
|
+
init_NoopTracerProvider();
|
|
1177
|
+
NOOP_TRACER_PROVIDER = new NoopTracerProvider();
|
|
1178
|
+
_ProxyTracerProvider = class _ProxyTracerProvider {
|
|
1179
|
+
/**
|
|
1180
|
+
* Get a {@link ProxyTracer}
|
|
1181
|
+
*/
|
|
1182
|
+
getTracer(name, version, options) {
|
|
1183
|
+
var _a;
|
|
1184
|
+
return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
|
|
1185
|
+
}
|
|
1186
|
+
getDelegate() {
|
|
1187
|
+
var _a;
|
|
1188
|
+
return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
|
|
1189
|
+
}
|
|
1190
|
+
/**
|
|
1191
|
+
* Set the delegate tracer provider
|
|
1192
|
+
*/
|
|
1193
|
+
setDelegate(delegate) {
|
|
1194
|
+
this._delegate = delegate;
|
|
1195
|
+
}
|
|
1196
|
+
getDelegateTracer(name, version, options) {
|
|
1197
|
+
var _a;
|
|
1198
|
+
return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
|
|
1199
|
+
}
|
|
1200
|
+
};
|
|
1201
|
+
__name(_ProxyTracerProvider, "ProxyTracerProvider");
|
|
1202
|
+
ProxyTracerProvider = _ProxyTracerProvider;
|
|
1203
|
+
}
|
|
1204
|
+
});
|
|
1205
|
+
|
|
1206
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/SamplingResult.js
|
|
1207
|
+
var SamplingDecision;
|
|
1208
|
+
var init_SamplingResult = __esm({
|
|
1209
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/SamplingResult.js"() {
|
|
1210
|
+
(function(SamplingDecision2) {
|
|
1211
|
+
SamplingDecision2[SamplingDecision2["NOT_RECORD"] = 0] = "NOT_RECORD";
|
|
1212
|
+
SamplingDecision2[SamplingDecision2["RECORD"] = 1] = "RECORD";
|
|
1213
|
+
SamplingDecision2[SamplingDecision2["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED";
|
|
1214
|
+
})(SamplingDecision || (SamplingDecision = {}));
|
|
1215
|
+
}
|
|
1216
|
+
});
|
|
1217
|
+
|
|
1218
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/span_kind.js
|
|
1219
|
+
var SpanKind;
|
|
1220
|
+
var init_span_kind = __esm({
|
|
1221
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/span_kind.js"() {
|
|
1222
|
+
(function(SpanKind2) {
|
|
1223
|
+
SpanKind2[SpanKind2["INTERNAL"] = 0] = "INTERNAL";
|
|
1224
|
+
SpanKind2[SpanKind2["SERVER"] = 1] = "SERVER";
|
|
1225
|
+
SpanKind2[SpanKind2["CLIENT"] = 2] = "CLIENT";
|
|
1226
|
+
SpanKind2[SpanKind2["PRODUCER"] = 3] = "PRODUCER";
|
|
1227
|
+
SpanKind2[SpanKind2["CONSUMER"] = 4] = "CONSUMER";
|
|
1228
|
+
})(SpanKind || (SpanKind = {}));
|
|
1229
|
+
}
|
|
1230
|
+
});
|
|
1231
|
+
|
|
1232
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/internal/tracestate-validators.js
|
|
1233
|
+
function validateKey(key) {
|
|
1234
|
+
return VALID_KEY_REGEX.test(key);
|
|
1235
|
+
}
|
|
1236
|
+
function validateValue(value) {
|
|
1237
|
+
return VALID_VALUE_BASE_REGEX.test(value) && !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value);
|
|
1238
|
+
}
|
|
1239
|
+
var VALID_KEY_CHAR_RANGE, VALID_KEY, VALID_VENDOR_KEY, VALID_KEY_REGEX, VALID_VALUE_BASE_REGEX, INVALID_VALUE_COMMA_EQUAL_REGEX;
|
|
1240
|
+
var init_tracestate_validators = __esm({
|
|
1241
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/internal/tracestate-validators.js"() {
|
|
1242
|
+
VALID_KEY_CHAR_RANGE = "[_0-9a-z-*/]";
|
|
1243
|
+
VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`;
|
|
1244
|
+
VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`;
|
|
1245
|
+
VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`);
|
|
1246
|
+
VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;
|
|
1247
|
+
INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;
|
|
1248
|
+
__name(validateKey, "validateKey");
|
|
1249
|
+
__name(validateValue, "validateValue");
|
|
1250
|
+
}
|
|
1251
|
+
});
|
|
1252
|
+
|
|
1253
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/internal/tracestate-impl.js
|
|
1254
|
+
var MAX_TRACE_STATE_ITEMS, MAX_TRACE_STATE_LEN, LIST_MEMBERS_SEPARATOR, LIST_MEMBER_KEY_VALUE_SPLITTER, _TraceStateImpl, TraceStateImpl;
|
|
1255
|
+
var init_tracestate_impl = __esm({
|
|
1256
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/internal/tracestate-impl.js"() {
|
|
1257
|
+
init_tracestate_validators();
|
|
1258
|
+
MAX_TRACE_STATE_ITEMS = 32;
|
|
1259
|
+
MAX_TRACE_STATE_LEN = 512;
|
|
1260
|
+
LIST_MEMBERS_SEPARATOR = ",";
|
|
1261
|
+
LIST_MEMBER_KEY_VALUE_SPLITTER = "=";
|
|
1262
|
+
_TraceStateImpl = class _TraceStateImpl {
|
|
1263
|
+
constructor(rawTraceState) {
|
|
1264
|
+
this._internalState = /* @__PURE__ */ new Map();
|
|
1265
|
+
if (rawTraceState)
|
|
1266
|
+
this._parse(rawTraceState);
|
|
1267
|
+
}
|
|
1268
|
+
set(key, value) {
|
|
1269
|
+
const traceState = this._clone();
|
|
1270
|
+
if (traceState._internalState.has(key)) {
|
|
1271
|
+
traceState._internalState.delete(key);
|
|
1272
|
+
}
|
|
1273
|
+
traceState._internalState.set(key, value);
|
|
1274
|
+
return traceState;
|
|
1275
|
+
}
|
|
1276
|
+
unset(key) {
|
|
1277
|
+
const traceState = this._clone();
|
|
1278
|
+
traceState._internalState.delete(key);
|
|
1279
|
+
return traceState;
|
|
1280
|
+
}
|
|
1281
|
+
get(key) {
|
|
1282
|
+
return this._internalState.get(key);
|
|
1283
|
+
}
|
|
1284
|
+
serialize() {
|
|
1285
|
+
return Array.from(this._internalState.keys()).reduceRight((agg, key) => {
|
|
1286
|
+
agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key));
|
|
1287
|
+
return agg;
|
|
1288
|
+
}, []).join(LIST_MEMBERS_SEPARATOR);
|
|
1289
|
+
}
|
|
1290
|
+
_parse(rawTraceState) {
|
|
1291
|
+
if (rawTraceState.length > MAX_TRACE_STATE_LEN)
|
|
1292
|
+
return;
|
|
1293
|
+
this._internalState = rawTraceState.split(LIST_MEMBERS_SEPARATOR).reduceRight((agg, part) => {
|
|
1294
|
+
const listMember = part.trim();
|
|
1295
|
+
const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);
|
|
1296
|
+
if (i !== -1) {
|
|
1297
|
+
const key = listMember.slice(0, i);
|
|
1298
|
+
const value = listMember.slice(i + 1, part.length);
|
|
1299
|
+
if (validateKey(key) && validateValue(value)) {
|
|
1300
|
+
agg.set(key, value);
|
|
1301
|
+
} else {
|
|
1302
|
+
}
|
|
1303
|
+
}
|
|
1304
|
+
return agg;
|
|
1305
|
+
}, /* @__PURE__ */ new Map());
|
|
1306
|
+
if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {
|
|
1307
|
+
this._internalState = new Map(Array.from(this._internalState.entries()).reverse().slice(0, MAX_TRACE_STATE_ITEMS));
|
|
1308
|
+
}
|
|
1309
|
+
}
|
|
1310
|
+
// @ts-expect-error TS6133 Accessed in tests only.
|
|
1311
|
+
_keys() {
|
|
1312
|
+
return Array.from(this._internalState.keys()).reverse();
|
|
1313
|
+
}
|
|
1314
|
+
_clone() {
|
|
1315
|
+
const traceState = new _TraceStateImpl();
|
|
1316
|
+
traceState._internalState = new Map(this._internalState);
|
|
1317
|
+
return traceState;
|
|
1318
|
+
}
|
|
1319
|
+
};
|
|
1320
|
+
__name(_TraceStateImpl, "TraceStateImpl");
|
|
1321
|
+
TraceStateImpl = _TraceStateImpl;
|
|
1322
|
+
}
|
|
1323
|
+
});
|
|
1324
|
+
|
|
1325
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/internal/utils.js
|
|
1326
|
+
function createTraceState(rawTraceState) {
|
|
1327
|
+
return new TraceStateImpl(rawTraceState);
|
|
1328
|
+
}
|
|
1329
|
+
var init_utils2 = __esm({
|
|
1330
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace/internal/utils.js"() {
|
|
1331
|
+
init_tracestate_impl();
|
|
1332
|
+
__name(createTraceState, "createTraceState");
|
|
1333
|
+
}
|
|
1334
|
+
});
|
|
1335
|
+
|
|
1336
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/metrics/NoopMeterProvider.js
|
|
1337
|
+
var _NoopMeterProvider, NoopMeterProvider, NOOP_METER_PROVIDER;
|
|
1338
|
+
var init_NoopMeterProvider = __esm({
|
|
1339
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/metrics/NoopMeterProvider.js"() {
|
|
1340
|
+
init_NoopMeter();
|
|
1341
|
+
_NoopMeterProvider = class _NoopMeterProvider {
|
|
1342
|
+
getMeter(_name, _version, _options) {
|
|
1343
|
+
return NOOP_METER;
|
|
1344
|
+
}
|
|
1345
|
+
};
|
|
1346
|
+
__name(_NoopMeterProvider, "NoopMeterProvider");
|
|
1347
|
+
NoopMeterProvider = _NoopMeterProvider;
|
|
1348
|
+
NOOP_METER_PROVIDER = new NoopMeterProvider();
|
|
1349
|
+
}
|
|
1350
|
+
});
|
|
1351
|
+
|
|
1352
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/api/metrics.js
|
|
1353
|
+
var API_NAME3, _MetricsAPI, MetricsAPI;
|
|
1354
|
+
var init_metrics = __esm({
|
|
1355
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/api/metrics.js"() {
|
|
1356
|
+
init_NoopMeterProvider();
|
|
1357
|
+
init_global_utils();
|
|
1358
|
+
init_diag();
|
|
1359
|
+
API_NAME3 = "metrics";
|
|
1360
|
+
_MetricsAPI = class _MetricsAPI {
|
|
1361
|
+
/** Empty private constructor prevents end users from constructing a new instance of the API */
|
|
1362
|
+
constructor() {
|
|
1363
|
+
}
|
|
1364
|
+
/** Get the singleton instance of the Metrics API */
|
|
1365
|
+
static getInstance() {
|
|
1366
|
+
if (!this._instance) {
|
|
1367
|
+
this._instance = new _MetricsAPI();
|
|
1368
|
+
}
|
|
1369
|
+
return this._instance;
|
|
1370
|
+
}
|
|
1371
|
+
/**
|
|
1372
|
+
* Set the current global meter provider.
|
|
1373
|
+
* Returns true if the meter provider was successfully registered, else false.
|
|
1374
|
+
*/
|
|
1375
|
+
setGlobalMeterProvider(provider) {
|
|
1376
|
+
return registerGlobal(API_NAME3, provider, DiagAPI.instance());
|
|
1377
|
+
}
|
|
1378
|
+
/**
|
|
1379
|
+
* Returns the global meter provider.
|
|
1380
|
+
*/
|
|
1381
|
+
getMeterProvider() {
|
|
1382
|
+
return getGlobal(API_NAME3) || NOOP_METER_PROVIDER;
|
|
1383
|
+
}
|
|
1384
|
+
/**
|
|
1385
|
+
* Returns a meter from the global meter provider.
|
|
1386
|
+
*/
|
|
1387
|
+
getMeter(name, version, options) {
|
|
1388
|
+
return this.getMeterProvider().getMeter(name, version, options);
|
|
1389
|
+
}
|
|
1390
|
+
/** Remove the global meter provider */
|
|
1391
|
+
disable() {
|
|
1392
|
+
unregisterGlobal(API_NAME3, DiagAPI.instance());
|
|
1393
|
+
}
|
|
1394
|
+
};
|
|
1395
|
+
__name(_MetricsAPI, "MetricsAPI");
|
|
1396
|
+
MetricsAPI = _MetricsAPI;
|
|
1397
|
+
}
|
|
1398
|
+
});
|
|
1399
|
+
|
|
1400
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/metrics-api.js
|
|
1401
|
+
var metrics;
|
|
1402
|
+
var init_metrics_api = __esm({
|
|
1403
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/metrics-api.js"() {
|
|
1404
|
+
init_metrics();
|
|
1405
|
+
metrics = MetricsAPI.getInstance();
|
|
1406
|
+
}
|
|
1407
|
+
});
|
|
1408
|
+
|
|
1409
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/propagation/NoopTextMapPropagator.js
|
|
1410
|
+
var _NoopTextMapPropagator, NoopTextMapPropagator;
|
|
1411
|
+
var init_NoopTextMapPropagator = __esm({
|
|
1412
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/propagation/NoopTextMapPropagator.js"() {
|
|
1413
|
+
_NoopTextMapPropagator = class _NoopTextMapPropagator {
|
|
1414
|
+
/** Noop inject function does nothing */
|
|
1415
|
+
inject(_context, _carrier) {
|
|
1416
|
+
}
|
|
1417
|
+
/** Noop extract function does nothing and returns the input context */
|
|
1418
|
+
extract(context2, _carrier) {
|
|
1419
|
+
return context2;
|
|
1420
|
+
}
|
|
1421
|
+
fields() {
|
|
1422
|
+
return [];
|
|
1423
|
+
}
|
|
1424
|
+
};
|
|
1425
|
+
__name(_NoopTextMapPropagator, "NoopTextMapPropagator");
|
|
1426
|
+
NoopTextMapPropagator = _NoopTextMapPropagator;
|
|
1427
|
+
}
|
|
1428
|
+
});
|
|
1429
|
+
|
|
1430
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/baggage/context-helpers.js
|
|
1431
|
+
function getBaggage(context2) {
|
|
1432
|
+
return context2.getValue(BAGGAGE_KEY) || void 0;
|
|
1433
|
+
}
|
|
1434
|
+
function getActiveBaggage() {
|
|
1435
|
+
return getBaggage(ContextAPI.getInstance().active());
|
|
1436
|
+
}
|
|
1437
|
+
function setBaggage(context2, baggage) {
|
|
1438
|
+
return context2.setValue(BAGGAGE_KEY, baggage);
|
|
1439
|
+
}
|
|
1440
|
+
function deleteBaggage(context2) {
|
|
1441
|
+
return context2.deleteValue(BAGGAGE_KEY);
|
|
1442
|
+
}
|
|
1443
|
+
var BAGGAGE_KEY;
|
|
1444
|
+
var init_context_helpers = __esm({
|
|
1445
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/baggage/context-helpers.js"() {
|
|
1446
|
+
init_context2();
|
|
1447
|
+
init_context();
|
|
1448
|
+
BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
|
|
1449
|
+
__name(getBaggage, "getBaggage");
|
|
1450
|
+
__name(getActiveBaggage, "getActiveBaggage");
|
|
1451
|
+
__name(setBaggage, "setBaggage");
|
|
1452
|
+
__name(deleteBaggage, "deleteBaggage");
|
|
1453
|
+
}
|
|
1454
|
+
});
|
|
1455
|
+
|
|
1456
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/api/propagation.js
|
|
1457
|
+
var API_NAME4, NOOP_TEXT_MAP_PROPAGATOR, _PropagationAPI, PropagationAPI;
|
|
1458
|
+
var init_propagation = __esm({
|
|
1459
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/api/propagation.js"() {
|
|
1460
|
+
init_global_utils();
|
|
1461
|
+
init_NoopTextMapPropagator();
|
|
1462
|
+
init_TextMapPropagator();
|
|
1463
|
+
init_context_helpers();
|
|
1464
|
+
init_utils();
|
|
1465
|
+
init_diag();
|
|
1466
|
+
API_NAME4 = "propagation";
|
|
1467
|
+
NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
|
|
1468
|
+
_PropagationAPI = class _PropagationAPI {
|
|
1469
|
+
/** Empty private constructor prevents end users from constructing a new instance of the API */
|
|
1470
|
+
constructor() {
|
|
1471
|
+
this.createBaggage = createBaggage;
|
|
1472
|
+
this.getBaggage = getBaggage;
|
|
1473
|
+
this.getActiveBaggage = getActiveBaggage;
|
|
1474
|
+
this.setBaggage = setBaggage;
|
|
1475
|
+
this.deleteBaggage = deleteBaggage;
|
|
1476
|
+
}
|
|
1477
|
+
/** Get the singleton instance of the Propagator API */
|
|
1478
|
+
static getInstance() {
|
|
1479
|
+
if (!this._instance) {
|
|
1480
|
+
this._instance = new _PropagationAPI();
|
|
1481
|
+
}
|
|
1482
|
+
return this._instance;
|
|
1483
|
+
}
|
|
1484
|
+
/**
|
|
1485
|
+
* Set the current propagator.
|
|
1486
|
+
*
|
|
1487
|
+
* @returns true if the propagator was successfully registered, else false
|
|
1488
|
+
*/
|
|
1489
|
+
setGlobalPropagator(propagator) {
|
|
1490
|
+
return registerGlobal(API_NAME4, propagator, DiagAPI.instance());
|
|
1491
|
+
}
|
|
1492
|
+
/**
|
|
1493
|
+
* Inject context into a carrier to be propagated inter-process
|
|
1494
|
+
*
|
|
1495
|
+
* @param context Context carrying tracing data to inject
|
|
1496
|
+
* @param carrier carrier to inject context into
|
|
1497
|
+
* @param setter Function used to set values on the carrier
|
|
1498
|
+
*/
|
|
1499
|
+
inject(context2, carrier, setter = defaultTextMapSetter) {
|
|
1500
|
+
return this._getGlobalPropagator().inject(context2, carrier, setter);
|
|
1501
|
+
}
|
|
1502
|
+
/**
|
|
1503
|
+
* Extract context from a carrier
|
|
1504
|
+
*
|
|
1505
|
+
* @param context Context which the newly created context will inherit from
|
|
1506
|
+
* @param carrier Carrier to extract context from
|
|
1507
|
+
* @param getter Function used to extract keys from a carrier
|
|
1508
|
+
*/
|
|
1509
|
+
extract(context2, carrier, getter = defaultTextMapGetter) {
|
|
1510
|
+
return this._getGlobalPropagator().extract(context2, carrier, getter);
|
|
1511
|
+
}
|
|
1512
|
+
/**
|
|
1513
|
+
* Return a list of all fields which may be used by the propagator.
|
|
1514
|
+
*/
|
|
1515
|
+
fields() {
|
|
1516
|
+
return this._getGlobalPropagator().fields();
|
|
1517
|
+
}
|
|
1518
|
+
/** Remove the global propagator */
|
|
1519
|
+
disable() {
|
|
1520
|
+
unregisterGlobal(API_NAME4, DiagAPI.instance());
|
|
1521
|
+
}
|
|
1522
|
+
_getGlobalPropagator() {
|
|
1523
|
+
return getGlobal(API_NAME4) || NOOP_TEXT_MAP_PROPAGATOR;
|
|
1524
|
+
}
|
|
1525
|
+
};
|
|
1526
|
+
__name(_PropagationAPI, "PropagationAPI");
|
|
1527
|
+
PropagationAPI = _PropagationAPI;
|
|
1528
|
+
}
|
|
1529
|
+
});
|
|
1530
|
+
|
|
1531
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/propagation-api.js
|
|
1532
|
+
var propagation;
|
|
1533
|
+
var init_propagation_api = __esm({
|
|
1534
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/propagation-api.js"() {
|
|
1535
|
+
init_propagation();
|
|
1536
|
+
propagation = PropagationAPI.getInstance();
|
|
1537
|
+
}
|
|
1538
|
+
});
|
|
1539
|
+
|
|
1540
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/api/trace.js
|
|
1541
|
+
var API_NAME5, _TraceAPI, TraceAPI;
|
|
1542
|
+
var init_trace = __esm({
|
|
1543
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/api/trace.js"() {
|
|
1544
|
+
init_global_utils();
|
|
1545
|
+
init_ProxyTracerProvider();
|
|
1546
|
+
init_spancontext_utils();
|
|
1547
|
+
init_context_utils();
|
|
1548
|
+
init_diag();
|
|
1549
|
+
API_NAME5 = "trace";
|
|
1550
|
+
_TraceAPI = class _TraceAPI {
|
|
1551
|
+
/** Empty private constructor prevents end users from constructing a new instance of the API */
|
|
1552
|
+
constructor() {
|
|
1553
|
+
this._proxyTracerProvider = new ProxyTracerProvider();
|
|
1554
|
+
this.wrapSpanContext = wrapSpanContext;
|
|
1555
|
+
this.isSpanContextValid = isSpanContextValid;
|
|
1556
|
+
this.deleteSpan = deleteSpan;
|
|
1557
|
+
this.getSpan = getSpan;
|
|
1558
|
+
this.getActiveSpan = getActiveSpan;
|
|
1559
|
+
this.getSpanContext = getSpanContext;
|
|
1560
|
+
this.setSpan = setSpan;
|
|
1561
|
+
this.setSpanContext = setSpanContext;
|
|
1562
|
+
}
|
|
1563
|
+
/** Get the singleton instance of the Trace API */
|
|
1564
|
+
static getInstance() {
|
|
1565
|
+
if (!this._instance) {
|
|
1566
|
+
this._instance = new _TraceAPI();
|
|
1567
|
+
}
|
|
1568
|
+
return this._instance;
|
|
1569
|
+
}
|
|
1570
|
+
/**
|
|
1571
|
+
* Set the current global tracer.
|
|
1572
|
+
*
|
|
1573
|
+
* @returns true if the tracer provider was successfully registered, else false
|
|
1574
|
+
*/
|
|
1575
|
+
setGlobalTracerProvider(provider) {
|
|
1576
|
+
const success = registerGlobal(API_NAME5, this._proxyTracerProvider, DiagAPI.instance());
|
|
1577
|
+
if (success) {
|
|
1578
|
+
this._proxyTracerProvider.setDelegate(provider);
|
|
1579
|
+
}
|
|
1580
|
+
return success;
|
|
1581
|
+
}
|
|
1582
|
+
/**
|
|
1583
|
+
* Returns the global tracer provider.
|
|
1584
|
+
*/
|
|
1585
|
+
getTracerProvider() {
|
|
1586
|
+
return getGlobal(API_NAME5) || this._proxyTracerProvider;
|
|
1587
|
+
}
|
|
1588
|
+
/**
|
|
1589
|
+
* Returns a tracer from the global tracer provider.
|
|
1590
|
+
*/
|
|
1591
|
+
getTracer(name, version) {
|
|
1592
|
+
return this.getTracerProvider().getTracer(name, version);
|
|
1593
|
+
}
|
|
1594
|
+
/** Remove the global tracer provider */
|
|
1595
|
+
disable() {
|
|
1596
|
+
unregisterGlobal(API_NAME5, DiagAPI.instance());
|
|
1597
|
+
this._proxyTracerProvider = new ProxyTracerProvider();
|
|
1598
|
+
}
|
|
1599
|
+
};
|
|
1600
|
+
__name(_TraceAPI, "TraceAPI");
|
|
1601
|
+
TraceAPI = _TraceAPI;
|
|
1602
|
+
}
|
|
1603
|
+
});
|
|
1604
|
+
|
|
1605
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace-api.js
|
|
1606
|
+
var trace;
|
|
1607
|
+
var init_trace_api = __esm({
|
|
1608
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/trace-api.js"() {
|
|
1609
|
+
init_trace();
|
|
1610
|
+
trace = TraceAPI.getInstance();
|
|
1611
|
+
}
|
|
1612
|
+
});
|
|
1613
|
+
|
|
1614
|
+
// ../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/index.js
|
|
1615
|
+
var esm_exports = {};
|
|
1616
|
+
__export(esm_exports, {
|
|
1617
|
+
DiagConsoleLogger: () => DiagConsoleLogger,
|
|
1618
|
+
DiagLogLevel: () => DiagLogLevel,
|
|
1619
|
+
INVALID_SPANID: () => INVALID_SPANID,
|
|
1620
|
+
INVALID_SPAN_CONTEXT: () => INVALID_SPAN_CONTEXT,
|
|
1621
|
+
INVALID_TRACEID: () => INVALID_TRACEID,
|
|
1622
|
+
ProxyTracer: () => ProxyTracer,
|
|
1623
|
+
ProxyTracerProvider: () => ProxyTracerProvider,
|
|
1624
|
+
ROOT_CONTEXT: () => ROOT_CONTEXT,
|
|
1625
|
+
SamplingDecision: () => SamplingDecision,
|
|
1626
|
+
SpanKind: () => SpanKind,
|
|
1627
|
+
SpanStatusCode: () => SpanStatusCode,
|
|
1628
|
+
TraceFlags: () => TraceFlags,
|
|
1629
|
+
ValueType: () => ValueType,
|
|
1630
|
+
baggageEntryMetadataFromString: () => baggageEntryMetadataFromString,
|
|
1631
|
+
context: () => context,
|
|
1632
|
+
createContextKey: () => createContextKey,
|
|
1633
|
+
createNoopMeter: () => createNoopMeter,
|
|
1634
|
+
createTraceState: () => createTraceState,
|
|
1635
|
+
default: () => esm_default,
|
|
1636
|
+
defaultTextMapGetter: () => defaultTextMapGetter,
|
|
1637
|
+
defaultTextMapSetter: () => defaultTextMapSetter,
|
|
1638
|
+
diag: () => diag,
|
|
1639
|
+
isSpanContextValid: () => isSpanContextValid,
|
|
1640
|
+
isValidSpanId: () => isValidSpanId,
|
|
1641
|
+
isValidTraceId: () => isValidTraceId,
|
|
1642
|
+
metrics: () => metrics,
|
|
1643
|
+
propagation: () => propagation,
|
|
1644
|
+
trace: () => trace
|
|
1645
|
+
});
|
|
1646
|
+
var esm_default;
|
|
1647
|
+
var init_esm = __esm({
|
|
1648
|
+
"../../node_modules/.store/@opentelemetry-api-npm-1.9.1-a6d8abf4cb/package/build/esm/index.js"() {
|
|
1649
|
+
init_utils();
|
|
1650
|
+
init_context();
|
|
1651
|
+
init_consoleLogger();
|
|
1652
|
+
init_types();
|
|
1653
|
+
init_NoopMeter();
|
|
1654
|
+
init_Metric();
|
|
1655
|
+
init_TextMapPropagator();
|
|
1656
|
+
init_ProxyTracer();
|
|
1657
|
+
init_ProxyTracerProvider();
|
|
1658
|
+
init_SamplingResult();
|
|
1659
|
+
init_span_kind();
|
|
1660
|
+
init_status();
|
|
1661
|
+
init_trace_flags();
|
|
1662
|
+
init_utils2();
|
|
1663
|
+
init_spancontext_utils();
|
|
1664
|
+
init_invalid_span_constants();
|
|
1665
|
+
init_context_api();
|
|
1666
|
+
init_diag_api();
|
|
1667
|
+
init_metrics_api();
|
|
1668
|
+
init_propagation_api();
|
|
1669
|
+
init_trace_api();
|
|
1670
|
+
esm_default = {
|
|
1671
|
+
context,
|
|
1672
|
+
diag,
|
|
1673
|
+
metrics,
|
|
1674
|
+
propagation,
|
|
1675
|
+
trace
|
|
1676
|
+
};
|
|
1677
|
+
}
|
|
1678
|
+
});
|
|
1679
|
+
|
|
1680
|
+
export {
|
|
1681
|
+
__name,
|
|
1682
|
+
__require,
|
|
1683
|
+
__esm,
|
|
1684
|
+
__commonJS,
|
|
1685
|
+
__export,
|
|
1686
|
+
__toESM,
|
|
1687
|
+
__toCommonJS,
|
|
1688
|
+
__publicField,
|
|
1689
|
+
DiagLogLevel,
|
|
1690
|
+
ROOT_CONTEXT,
|
|
1691
|
+
DiagConsoleLogger,
|
|
1692
|
+
SpanKind,
|
|
1693
|
+
SpanStatusCode,
|
|
1694
|
+
context,
|
|
1695
|
+
diag,
|
|
1696
|
+
metrics,
|
|
1697
|
+
trace,
|
|
1698
|
+
esm_exports,
|
|
1699
|
+
init_esm
|
|
1700
|
+
};
|