diff --git a/packages/compiler/ambient/scriptc-node-fallback.d.ts b/packages/compiler/ambient/scriptc-node-fallback.d.ts index 436bcace3..106e5f581 100644 --- a/packages/compiler/ambient/scriptc-node-fallback.d.ts +++ b/packages/compiler/ambient/scriptc-node-fallback.d.ts @@ -4852,15 +4852,17 @@ declare module "net" { host?: string, connectListener?: () => void, ): Socket; - /* The caller-resolver dial (@types/node's net.LookupFunction, narrowed - * to the lowered shape): the runtime invokes it as Node does and dials - * the answered addresses in order under autoSelectFamily: true. */ + /* The caller-resolver dial (@types/node's net.LookupFunction): the + * runtime invokes it as Node's autoSelectFamily dial does (options + * { hints, all: true }, so the callback answers an address list) and + * dials the answered addresses in order. */ export type LookupFunction = ( hostname: string, - options: unknown, + options: import("node:dns").LookupOptions, callback: ( err: NodeJS.ErrnoException | null, - addresses: { address: string; family: number }[], + address: string | import("node:dns").LookupAddress[], + family?: number, ) => void, ) => void; export function connect( diff --git a/packages/compiler/src/backend/llvm/lib-shared.ts b/packages/compiler/src/backend/llvm/lib-shared.ts index 38c6bdbe0..77496b8ba 100644 --- a/packages/compiler/src/backend/llvm/lib-shared.ts +++ b/packages/compiler/src/backend/llvm/lib-shared.ts @@ -459,6 +459,7 @@ export const LIB_FN_SYMS: Record = { "fs.existsChk": "scr_fs_exists_async", "fs.mkdtempSyncChk": "scr_fs_mkdtemp_sync_chk", "net.connectAttempt": "scr_net_connect_attempt", + "net.connectLookupDyn": "scr_net_connect_lookup_dyn", "fs.lchmodSyncChk": "scr_fs_lchmod_sync_chk", "fsp.lchmodChk": "scr_fsp_lchmod_chk", "fs.readFileSyncBuf": "scr_fs_read_file_bytes", @@ -1639,6 +1640,7 @@ export const USES_TIMERS_LIB_FNS = new Set([ "net.connect", "net.connectCb", "net.connectLookup", + "net.connectLookupDyn", "net.connectAttempt", "fs.existsChk", "fs.callbackValue", diff --git a/packages/compiler/src/frontend/lowering/call-signatures.ts b/packages/compiler/src/frontend/lowering/call-signatures.ts index 7570fff88..898cca8d9 100644 --- a/packages/compiler/src/frontend/lowering/call-signatures.ts +++ b/packages/compiler/src/frontend/lowering/call-signatures.ts @@ -854,6 +854,17 @@ export function lambdaSignature( return { shapes, funcType: funcTypeFromParamShapes(shapes, DYN) }; } } + // A callback whose arguments arrive as the runtime produced them, wider + // than its contextual overload says (dns.lookup's callback when the + // options are only known at run time: the address is a string or an + // address list): every parameter binds as a checked-dynamic value. + if (lowerer.dynParamLambdas.has(node)) { + const shapes: ParamShape[] = node.parameters.nodes.map(() => ({ + type: DYN, + mode: "required", + })); + return { shapes, funcType: funcTypeFromParamShapes(shapes, VOID) }; + } if (node.typeParameters?.nodes && !lowerer.erasingLambdas.has(node)) { // Generic function-like forms monomorphize only where a static home // exists: top-level generic function declarations, generic methods diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index ae864c2cb..b89f26578 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -4252,8 +4252,13 @@ function lowerArrayIsArrayCall( if (lowerer.stdlibGlobalMember(access, "Array") !== "isArray") return null; if (call.arguments.nodes.length !== 1) return null; // the stdlib chokepoint fences const argNode = call.arguments.nodes[0]!; - const arg = lowerer.lowerExpr(argNode); + let arg = lowerer.lowerExpr(argNode); const loc = locOf(call); + // A checker-narrowed dyn read arrives as a validated extraction (the + // dynCheck bridge). The runtime value may be wider than the flow type + // claims (an overload narrower than what arrives), so test the dyn value + // itself instead of folding on the extracted type (typeof's rule). + if (arg.kind === "dynCheck" && arg.value.type.kind === "dyn") arg = arg.value; if (arg.type.kind === "dyn") { return { kind: "dynTest", test: "array", value: arg, type: BOOL, loc }; } diff --git a/packages/compiler/src/frontend/lowering/lower-dgram.ts b/packages/compiler/src/frontend/lowering/lower-dgram.ts index d035b21c2..c299eb641 100644 --- a/packages/compiler/src/frontend/lowering/lower-dgram.ts +++ b/packages/compiler/src/frontend/lowering/lower-dgram.ts @@ -321,8 +321,31 @@ function lowerDnsModuleCall( const hostname = dyn(args[0]!); const options = args.length === 3 ? dyn(args[1]!) : dynUndefinedExpr(loc); const last = args[args.length - 1]!; - const typed = typedResult(last); - const cb = lowerDnsCallback(lowerer, last, "lookup callbacks"); + // Options known only at run time (a checked-dynamic value, or one cast + // to an overload's option type) decide between Node's two callback + // shapes there: the address is a string, or an address list with + // `all: true`. An inline callback then binds its parameters as + // checked-dynamic values, whatever the overload the checker picked + // says, and its body tests what actually arrived. + let runtimeOptions = false; + if (args.length === 3) { + let inner: ts.Expression = args[1]!; + while (ts.isParenthesizedExpression(inner) || ts.isAsExpression(inner)) + inner = inner.expression; + runtimeOptions = lowerer.mapTypeOf(lowerer.typeOf(inner))?.kind === "dyn"; + } + let callbackNode: ts.Expression = last; + while (ts.isParenthesizedExpression(callbackNode)) callbackNode = callbackNode.expression; + const dynCallback = + runtimeOptions && (ts.isArrowFunction(callbackNode) || ts.isFunctionExpression(callbackNode)); + const typed = dynCallback ? boolLit(false, loc) : typedResult(last); + if (dynCallback) lowerer.dynParamLambdas.add(callbackNode); + let cb: IrExpr; + try { + cb = lowerDnsCallback(lowerer, last, "lookup callbacks"); + } finally { + if (dynCallback) lowerer.dynParamLambdas.delete(callbackNode); + } return { kind: "libCall", fn: "dns.lookupDyn", diff --git a/packages/compiler/src/frontend/lowering/lower-modules.ts b/packages/compiler/src/frontend/lowering/lower-modules.ts index ba33811f9..6ea0ee151 100644 --- a/packages/compiler/src/frontend/lowering/lower-modules.ts +++ b/packages/compiler/src/frontend/lowering/lower-modules.ts @@ -1357,8 +1357,17 @@ export function collectGlobals( // common/tls's `exports.check = function (certs) {...}` — // keep func-ness with dyn pieces; everything else is dyn). const strict = lowerer.checker.getTypeOfSymbol(symbol); - const t = lowerer.mapTypeOf(strict) ?? dynFallbackType(lowerer, nameNode, strict); + let t = lowerer.mapTypeOf(strict) ?? dynFallbackType(lowerer, nameNode, strict); if (!t || t.kind === "void") lowerer.badType(typeNode, strict); + // An export typed as the empty object literal (tsc's enum output + // `exports.E || (exports.E = {})` after its `exports.E = void 0` + // preamble): TS's `{}` admits any later non-nullish value and the + // export is undefined until then, so it rides checked-dynamic + // storage like the same-shaped var binding (varBindingType). + if (t.kind === "record" && isJsSourceFile(sf)) { + const shape = lowerer.shapes.get(t.shapeId); + if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple) t = DYN; + } // An immutable export source shares its live storage and native // callable ABI. Mutable sources need a separate snapshot slot: // later writes to the binding do not change the exported value. diff --git a/packages/compiler/src/frontend/lowering/lower-server.ts b/packages/compiler/src/frontend/lowering/lower-server.ts index 7cdb9ef5d..a5387ac30 100644 --- a/packages/compiler/src/frontend/lowering/lower-server.ts +++ b/packages/compiler/src/frontend/lowering/lower-server.ts @@ -930,6 +930,7 @@ function lowerNetConnectOptions( let port: IrExpr | null = null; let host: IrExpr | null = null; let lookup: IrExpr | null = null; + let dynLookup: IrExpr | null = null; let autoSelect = false; let attempt: IrExpr | null = null; let optionThrow: IrExpr | null = null; @@ -1037,7 +1038,23 @@ function lowerNetConnectOptions( ); } lookup = lowerer.lowerExpr(initializer); - if (!lookupFnShapeOk(lowerer, lookup.type)) { + // A lookup of Node's own type (net.LookupFunction: options and a + // callback taking an address string or list) crosses as a checked- + // dynamic function the runtime calls the way Node's dial does. + if ( + !lookupFnShapeOk(lowerer, lookup.type) && + lookup.type.kind === "func" && + lookup.type.params.length === 3 && + canBoxFuncIntoDyn( + lookup.type, + (id) => lowerer.shapes.get(id), + (id) => lowerer.unions.get(id), + ) + ) { + dynLookup = { kind: "dynFrom", value: lookup, type: DYN, loc: locOf(initializer) }; + } else if (lookup.type.kind === "dyn") { + dynLookup = lookup; + } else if (!lookupFnShapeOk(lowerer, lookup.type)) { lowerer.noLowering( `a ${member} 'lookup' option of '${lowerer.fmt(lookup.type)}' values`, prop, @@ -1080,6 +1097,22 @@ function lowerNetConnectOptions( loc, }; } + if (dynLookup !== null) { + if (args.length !== 1) { + lowerer.noLowering( + `${member} with a lookup and a connect listener`, + expr, + "register the listener separately: socket.once('connect', ...)", + ); + } + return { + kind: "libCall", + fn: "net.connectLookupDyn", + args: [port, host, dynLookup], + type: NETSOCKET_T, + loc, + }; + } if (lookup !== null) { if (!autoSelect) { lowerer.noLowering( diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index fd2ecfcf0..ccd4fe1b7 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -1950,6 +1950,9 @@ export class Lowerer { * setEncoding call whose receiver is a socket or an untyped value. * Computed once on first use (null until then). */ socketEncodingReachable: boolean | null = null; + /** Lambdas lowered with checked-dynamic parameters (lambdaSignature): + * callbacks whose arguments are wider than their contextual overload. */ + readonly dynParamLambdas = new Set(); /** IMPLICIT-ANY instances lowered EAGERLY at first demand (their return * types are inferred from the body — the call site needs them settled), * collected here for run()'s function list (the liftedFns discipline). */ diff --git a/packages/compiler/src/ir/builtin-effects.ts b/packages/compiler/src/ir/builtin-effects.ts index 20969d9b8..3edd55161 100644 --- a/packages/compiler/src/ir/builtin-effects.ts +++ b/packages/compiler/src/ir/builtin-effects.ts @@ -423,6 +423,7 @@ export const MAY_THROW_LIB_FNS: ReadonlySet = new Set([ // The caller's lookup runs synchronously inside the connect call — a // throw there propagates like Node's. "net.connectLookup", + "net.connectLookupDyn", "cp.execSync", "cp.execCapture", // The client request constructors validate the method token diff --git a/packages/compiler/src/ir/builtin-signatures.ts b/packages/compiler/src/ir/builtin-signatures.ts index 381258b07..3317705a7 100644 --- a/packages/compiler/src/ir/builtin-signatures.ts +++ b/packages/compiler/src/ir/builtin-signatures.ts @@ -1368,6 +1368,11 @@ export const LIB_FN_SIGS = defineLibFnSignatures({ * 'error'. A synchronous throw INSIDE the lookup propagates out of the * connect call (may-throw seed). */ "net.connectLookup": { argTypes: [F64, STRING, null], result: NETSOCKET_T }, + /** connect({ host, port, lookup }) with a lookup of Node's own type, as + * a checked-dynamic function: the runtime calls it with { hints, all: + * true } and a callback taking an address string or list, then dials + * the answers in order. MAY THROW (host validation, a lookup throw). */ + "net.connectLookupDyn": { argTypes: [F64, STRING, DYN], result: NETSOCKET_T }, "net.sockWrite": { argTypes: [NETSOCKET_T, STRING], result: VOID }, "net.sockWriteBytes": { argTypes: [NETSOCKET_T, BYTES_U8], result: VOID }, "net.sockEnd": { argTypes: [NETSOCKET_T], result: VOID }, diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6452-dns-lookup-runtime-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6452-dns-lookup-runtime-options.ts.json new file mode 100644 index 000000000..350a2fa6e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/6452-dns-lookup-runtime-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/6452-dns-lookup-runtime-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/opentelemetry-api/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/opentelemetry-api/main.ts.json new file mode 100644 index 000000000..cf29b6130 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/opentelemetry-api/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/opentelemetry-api/main.ts" + ], + "diags": [] +} diff --git a/packages/runtime/src/scr_dgram.c b/packages/runtime/src/scr_dgram.c index c34923607..0707edecf 100644 --- a/packages/runtime/src/scr_dgram.c +++ b/packages/runtime/src/scr_dgram.c @@ -1394,6 +1394,7 @@ static void scr_dns_lookup_plain(const ScrDyn *hostname, const ScrDyn *options, double family = 0; bool all = false; int order = scr_dns_default_order; + int ai_flags = 0; if (options->kind == SCR_DYN_NUM) { double f = options->v.num; if (f != 0 && f != 4 && f != 6) { @@ -1412,10 +1413,15 @@ static void scr_dns_lookup_plain(const ScrDyn *hostname, const ScrDyn *options, scr_dyn_prop_type_fail("options.hints", "of type number", v); return; } - if (v->v.num != 0) { - scr_throw_error_msg_code(SCR_ERR_ERROR, "dns.lookup hints are not supported yet", 38, "SC2020"); + /* Node's validateHints: only dns.ADDRCONFIG, dns.V4MAPPED and + * dns.ALL (getaddrinfo's own flags), which then reach getaddrinfo */ + double h = v->v.num; + int allowed = AI_ADDRCONFIG | AI_V4MAPPED | AI_ALL; + if (!(h == h && trunc(h) == h && h >= 0 && h <= 0x7fffffff) || ((int)h & ~allowed) != 0) { + scr_dyn_arg_value_fail("hints", "is invalid", v); return; } + ai_flags = (int)h; } v = scr_dyn_obj_get(options, "family", 6); if (v != NULL && v->kind != SCR_DYN_UNDEF && v->kind != SCR_DYN_NULL) { @@ -1519,6 +1525,7 @@ static void scr_dns_lookup_plain(const ScrDyn *hostname, const ScrDyn *options, memset(&hints, 0, sizeof hints); hints.ai_family = family == 4 ? AF_INET : family == 6 ? AF_INET6 : AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = ai_flags; struct addrinfo *res = NULL; int rc = getaddrinfo(host->data, NULL, &hints, &res); if (rc != 0 || res == NULL) { diff --git a/packages/runtime/src/scr_net.c b/packages/runtime/src/scr_net.c index f13906454..85c1a3258 100644 --- a/packages/runtime/src/scr_net.c +++ b/packages/runtime/src/scr_net.c @@ -2669,6 +2669,81 @@ ScrNetSocket *scr_net_connect_lookup(double port, ScrStr *host /*borrowed*/, return s; } +/* The callback a checked-dynamic lookup function receives (Node's own + * shape, `(err, address, family)`): with `all: true` the address is a list + * of { address, family } records, otherwise one address string. caps[0] + * boxes the socket, as for the typed answer closure. */ +static ScrDyn *scr_net_lookup_dyn_thunk(ScrClosure *clo, ScrDyn *const *args, size_t argc) { + const ScrDyn *err = argc > 0 ? args[0] : scr_dyn_undefined(); + const ScrDyn *addr = argc > 1 ? args[1] : scr_dyn_undefined(); + ScrStr *msg = NULL; + ScrArr *ips = NULL; + bool failed = scr_dyn_truthy(err); + if (failed) { + const ScrDyn *m = err->kind == SCR_DYN_OBJ ? scr_dyn_obj_get(err, "message", 7) : NULL; + msg = m != NULL && m->kind == SCR_DYN_STR ? scr_str_retain(m->v.str) : scr_dyn_string_coerce_js(err); + } else { + ScrDyn *view = addr->kind == SCR_DYN_TYPED_REF ? scr_dyn_typed_ref_materialize(addr) : NULL; + const ScrDyn *list = view != NULL ? view : addr; + ips = scr_arr_new(SCR_ELEM_STR, 0); + if (list->kind == SCR_DYN_STR) { + scr_arr_push_ref(ips, scr_str_retain(list->v.str)); + } else if (list->kind == SCR_DYN_ARR) { + for (size_t i = 0; i < list->v.arr.len; i++) { + const ScrDyn *entry = list->v.arr.items[i]; + ScrDyn *ev = entry->kind == SCR_DYN_TYPED_REF ? scr_dyn_typed_ref_materialize(entry) : NULL; + const ScrDyn *rec = ev != NULL ? ev : entry; + const ScrDyn *a = rec->kind == SCR_DYN_OBJ ? scr_dyn_obj_get(rec, "address", 7) : NULL; + if (a != NULL && a->kind == SCR_DYN_STR) scr_arr_push_ref(ips, scr_str_retain(a->v.str)); + scr_dyn_release(ev); + } + } + scr_dyn_release(view); + } + scr_net_lookup_answer(clo, failed, msg, ips); + scr_str_release(msg); + if (ips != NULL) scr_arr_release(ips); + return scr_dyn_retain(scr_dyn_undefined()); +} + +/* net.connect({ host, port, lookup }) with a lookup of Node's own type + * (`(hostname, options, callback)` whose callback takes a string or an + * address list), held as a checked-dynamic function: the runtime calls it + * as Node's autoSelectFamily dial does, with { hints, all: true }, and dials + * the answered addresses in order. NULL with the exception pending. */ +ScrNetSocket *scr_net_connect_lookup_dyn(double port, ScrStr *host /*borrowed*/, + const ScrDyn *lookup /*borrowed*/) { + if (!scr_net_host_chk(host)) return NULL; + ScrNetSocket *s = scr_net_sock_new(); + s->peer_port = (int)port; + snprintf(s->peer_ip, sizeof s->peer_ip, "%.*s", + (int)(host->len < 63 ? host->len : 63), host->data); + if (!scr_net_poller_init()) { + fputs("scriptc: event poller init failed\n", stderr); + abort(); + } + s->connecting = true; + s->lookup_wait = true; + scr_net_sock_register(s); + ScrClosure *ans = scr_closure_new((void *)&scr_net_lookup_dyn_thunk, 1); + ScrBox *box = scr_box_new_obj(&scr_net_sock_retain_v, &scr_net_sock_release_v, NULL); + scr_box_set_ref(box, scr_net_sock_retain(s)); + ans->caps[0] = box; + ScrDyn *callback = scr_dyn_new_func(ans, &scr_net_lookup_dyn_thunk, 3, "(err, address, family)", "callback"); + ScrDyn *options = scr_dyn_new_obj(); +#ifndef _WIN32 + scr_dyn_obj_set(options, "hints", 5, scr_dyn_new_num((double)AI_ADDRCONFIG)); +#endif + scr_dyn_obj_set(options, "all", 3, scr_dyn_new_bool(true)); + ScrDyn *name = scr_dyn_new_str(host); + ScrDyn *args[3] = { name, options, callback }; + scr_dyn_release(scr_dyn_call(lookup, args, 3, "lookup")); + scr_dyn_release(name); + scr_dyn_release(options); + scr_dyn_release(callback); + return s; +} + /* The answer closure's runtime half (its fn is the emitted per-shape * thunk; caps[0] boxes the socket). msg/ips are borrowed (nullable). */ void scr_net_lookup_answer(ScrClosure *self, bool has_err, ScrStr *msg /*borrowed, nullable*/, diff --git a/packages/runtime/src/scr_net.h b/packages/runtime/src/scr_net.h index f76613a0e..8c9a27327 100644 --- a/packages/runtime/src/scr_net.h +++ b/packages/runtime/src/scr_net.h @@ -237,6 +237,7 @@ bool scr_net_sock_readable(ScrNetSocket *s); /* The deferred dial (the http agent's maxSockets queue): the socket * registers "connecting" and buffers writes; dial_start runs the dial. */ ScrNetSocket *scr_net_connect_deferred(double port, ScrStr *host /*borrowed, nullable*/); /* +1 */ +ScrNetSocket *scr_net_connect_lookup_dyn(double port, ScrStr *host /*borrowed*/, const ScrDyn *lookup /*borrowed*/); /* +1, NULL on throw */ void scr_net_sock_dial_start(ScrNetSocket *s); void scr_net_sock_set_timeout(ScrNetSocket *s, double ms); void scr_net_sock_on_timeout(ScrNetSocket *s, ScrClosure *cb /*moves*/, bool once); diff --git a/tests/corpus/6452-dns-lookup-runtime-options.ts b/tests/corpus/6452-dns-lookup-runtime-options.ts new file mode 100644 index 000000000..85f8e84de --- /dev/null +++ b/tests/corpus/6452-dns-lookup-runtime-options.ts @@ -0,0 +1,65 @@ +// A custom lookup function over Node's lookup-option union passes its +// options to dns.lookup through a cast, so the callback's address is a +// string or, with `all: true`, an address list, whatever the overload the +// checker picked says. Array.isArray tests what arrived. The same function +// serves as net.connect's lookup, which Node calls with `all: true`. +import * as dns from "node:dns"; +import * as net from "node:net"; + +type LookupCallback = ( + err: NodeJS.ErrnoException | null, + address: string | dns.LookupAddress[], + family?: number, +) => void; + +function createSafeLookup(): ( + hostname: string, + opts: dns.LookupOneOptions | dns.LookupAllOptions | number | undefined, + callback: LookupCallback, +) => void { + return function safeLookup(hostname, opts, callback) { + dns.lookup(hostname, opts as dns.LookupOneOptions, (err, address, family) => { + if (err) { + callback(err, address as string, family); + return; + } + if (Array.isArray(address)) { + const v4: dns.LookupAddress[] = []; + for (const entry of address) { + if (entry.address === "10.0.0.1") { + callback(new Error("blocked"), "", 0); + return; + } + if (entry.family === 4) v4.push(entry); + } + callback(null, v4); + return; + } + callback(null, address as string, family); + }); + }; +} + +const lookup = createSafeLookup(); +const show = (address: string | dns.LookupAddress[]): string => + typeof address === "string" ? address : JSON.stringify(address); + +lookup("localhost", { family: 4 }, (err, address, family) => { + console.log("one", err, show(address), family); + lookup("localhost", { family: 4, all: false }, (err2, address2, family2) => { + console.log("all false", err2, show(address2), family2); + lookup("localhost", { all: true }, (err3, addresses) => { + console.log("all true", err3, show(addresses)); + lookup("127.0.0.1", 4, (err4, address4, family4) => { + console.log("family", err4, show(address4), family4); + const server = net.createServer((socket) => socket.end("hello")); + server.listen(0, "127.0.0.1", () => { + const port = (server.address() as net.AddressInfo).port; + const socket = net.connect({ host: "localhost", port, lookup: createSafeLookup() }); + socket.on("data", (chunk: Buffer) => console.log("net", chunk.toString())); + socket.on("close", () => server.close()); + }); + }); + }); + }); +}); diff --git a/tests/fixtures/node-types/lookup-and-header-entries.ts b/tests/fixtures/node-types/lookup-and-header-entries.ts index a87f612d7..dff99b529 100644 --- a/tests/fixtures/node-types/lookup-and-header-entries.ts +++ b/tests/fixtures/node-types/lookup-and-header-entries.ts @@ -18,8 +18,23 @@ function createLookup(): ( ) => void { return function lookup(hostname, opts, callback) { dns.lookup(hostname, opts as dns.LookupOneOptions, (err, address, family) => { - if (err) return callback(err, "", 0); - callback(null, address, family); + if (err) { + callback(err, address as string, family); + return; + } + // With `all: true` Node answers an address list whatever the + // overload the cast selected says. + if (Array.isArray(address)) { + const v4: dns.LookupAddress[] = []; + for (const entry of address) if (entry.family === 4) v4.push(entry); + // The same list read through casts to the declared element type. + const viaCast = (address as dns.LookupAddress[]).map((entry) => entry.address); + const viaShape = address.map((entry) => (entry as { address: string }).address); + console.log("casts", viaCast.join(","), viaShape.join(",")); + callback(null, v4); + return; + } + callback(null, address as string, family); }); }; } @@ -40,8 +55,11 @@ function flatten(input: HeadersLike | undefined): string[] { const lookup = createLookup(); lookup("localhost", { family: 4 }, (err, address, family) => { console.log("one", err, address, family); - lookup("127.0.0.1", 4, (err3, address3, family3) => { - console.log("family", err3, address3, family3); - console.log(flatten({ accept: "text/plain", "x-list": ["a", "b"], "x-skip": undefined }).join(",")); + lookup("localhost", { all: true }, (err2, addresses) => { + console.log("all", err2, JSON.stringify(addresses)); + lookup("127.0.0.1", 4, (err3, address3, family3) => { + console.log("family", err3, address3, family3); + console.log(flatten({ accept: "text/plain", "x-list": ["a", "b"], "x-skip": undefined }).join(",")); + }); }); }); diff --git a/tests/fixtures/npm/cases/opentelemetry-api/main.ts b/tests/fixtures/npm/cases/opentelemetry-api/main.ts new file mode 100644 index 000000000..66a86183b --- /dev/null +++ b/tests/fixtures/npm/cases/opentelemetry-api/main.ts @@ -0,0 +1,26 @@ +// The real @opentelemetry/api (1.9.0, its CommonJS build) with no SDK +// registered: the metrics and trace entry points answer their no-op +// implementations. The package's tsc output opens each module with an +// `exports.X = void 0` preamble and builds its enums through +// `exports.E || (exports.E = {})`, and its index adds a default-export +// object next to the named re-exports. +import { metrics, trace, DiagLogLevel, SpanKind, type Counter } from "@opentelemetry/api"; + +let counter: Counter | undefined; +function getCounter(): Counter { + if (!counter) { + counter = metrics.getMeter("example-meter").createCounter("example.count", { + description: "counts examples", + }); + } + return counter; +} + +getCounter().add(1, { reason: "first" }); +getCounter().add(2); +console.log("meter provider", typeof metrics.getMeterProvider().getMeter); +console.log("levels", DiagLogLevel.ERROR, DiagLogLevel.DEBUG, DiagLogLevel[DiagLogLevel.WARN]); +console.log("span kinds", SpanKind.SERVER, SpanKind[SpanKind.CLIENT]); +const span = trace.getTracer("example-tracer").startSpan("work"); +console.log("span recording", span.isRecording()); +span.end(); diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/LICENSE b/tests/fixtures/npm/node_modules/@opentelemetry/api/LICENSE new file mode 100644 index 000000000..261eeb9e9 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/context.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/context.d.ts new file mode 100644 index 000000000..61caee8da --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/context.d.ts @@ -0,0 +1,41 @@ +import { Context, ContextManager } from '../context/types'; +/** + * Singleton object which represents the entry point to the OpenTelemetry Context API + */ +export declare class ContextAPI { + private static _instance?; + /** Empty private constructor prevents end users from constructing a new instance of the API */ + private constructor(); + /** Get the singleton instance of the Context API */ + static getInstance(): ContextAPI; + /** + * Set the current context manager. + * + * @returns true if the context manager was successfully registered, else false + */ + setGlobalContextManager(contextManager: ContextManager): boolean; + /** + * Get the currently active context + */ + active(): Context; + /** + * Execute a function with an active context + * + * @param context context to be active during function execution + * @param fn function to execute in a context + * @param thisArg optional receiver to be used for calling fn + * @param args optional arguments forwarded to fn + */ + with ReturnType>(context: Context, fn: F, thisArg?: ThisParameterType, ...args: A): ReturnType; + /** + * Bind a context to a target function or event emitter + * + * @param context context to bind to the event emitter or function. Defaults to the currently active context + * @param target function or event emitter to bind + */ + bind(context: Context, target: T): T; + private _getContextManager; + /** Disable and remove the global context manager */ + disable(): void; +} +//# sourceMappingURL=context.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/context.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/context.js new file mode 100644 index 000000000..8af551f82 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/context.js @@ -0,0 +1,81 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ContextAPI = void 0; +const NoopContextManager_1 = require("../context/NoopContextManager"); +const global_utils_1 = require("../internal/global-utils"); +const diag_1 = require("./diag"); +const API_NAME = 'context'; +const NOOP_CONTEXT_MANAGER = new NoopContextManager_1.NoopContextManager(); +/** + * Singleton object which represents the entry point to the OpenTelemetry Context API + */ +class ContextAPI { + /** Empty private constructor prevents end users from constructing a new instance of the API */ + constructor() { } + /** Get the singleton instance of the Context API */ + static getInstance() { + if (!this._instance) { + this._instance = new ContextAPI(); + } + return this._instance; + } + /** + * Set the current context manager. + * + * @returns true if the context manager was successfully registered, else false + */ + setGlobalContextManager(contextManager) { + return (0, global_utils_1.registerGlobal)(API_NAME, contextManager, diag_1.DiagAPI.instance()); + } + /** + * Get the currently active context + */ + active() { + return this._getContextManager().active(); + } + /** + * Execute a function with an active context + * + * @param context context to be active during function execution + * @param fn function to execute in a context + * @param thisArg optional receiver to be used for calling fn + * @param args optional arguments forwarded to fn + */ + with(context, fn, thisArg, ...args) { + return this._getContextManager().with(context, fn, thisArg, ...args); + } + /** + * Bind a context to a target function or event emitter + * + * @param context context to bind to the event emitter or function. Defaults to the currently active context + * @param target function or event emitter to bind + */ + bind(context, target) { + return this._getContextManager().bind(context, target); + } + _getContextManager() { + return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_CONTEXT_MANAGER; + } + /** Disable and remove the global context manager */ + disable() { + this._getContextManager().disable(); + (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance()); + } +} +exports.ContextAPI = ContextAPI; +//# sourceMappingURL=context.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/diag.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/diag.d.ts new file mode 100644 index 000000000..131db1728 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/diag.d.ts @@ -0,0 +1,30 @@ +import { ComponentLoggerOptions, DiagLogFunction, DiagLogger, DiagLoggerApi } from '../diag/types'; +/** + * Singleton object which represents the entry point to the OpenTelemetry internal + * diagnostic API + */ +export declare class DiagAPI implements DiagLogger, DiagLoggerApi { + private static _instance?; + /** Get the singleton instance of the DiagAPI API */ + static instance(): DiagAPI; + /** + * Private internal constructor + * @private + */ + private constructor(); + setLogger: DiagLoggerApi['setLogger']; + /** + * + */ + createComponentLogger: (options: ComponentLoggerOptions) => DiagLogger; + verbose: DiagLogFunction; + debug: DiagLogFunction; + info: DiagLogFunction; + warn: DiagLogFunction; + error: DiagLogFunction; + /** + * Unregister the global logger and return to Noop + */ + disable: () => void; +} +//# sourceMappingURL=diag.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/diag.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/diag.js new file mode 100644 index 000000000..945692323 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/diag.js @@ -0,0 +1,93 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DiagAPI = void 0; +const ComponentLogger_1 = require("../diag/ComponentLogger"); +const logLevelLogger_1 = require("../diag/internal/logLevelLogger"); +const types_1 = require("../diag/types"); +const global_utils_1 = require("../internal/global-utils"); +const API_NAME = 'diag'; +/** + * Singleton object which represents the entry point to the OpenTelemetry internal + * diagnostic API + */ +class DiagAPI { + /** + * Private internal constructor + * @private + */ + constructor() { + function _logProxy(funcName) { + return function (...args) { + const logger = (0, global_utils_1.getGlobal)('diag'); + // shortcut if logger not set + if (!logger) + return; + return logger[funcName](...args); + }; + } + // Using self local variable for minification purposes as 'this' cannot be minified + const self = this; + // DiagAPI specific functions + const setLogger = (logger, optionsOrLogLevel = { logLevel: types_1.DiagLogLevel.INFO }) => { + var _a, _b, _c; + if (logger === self) { + // There isn't much we can do here. + // Logging to the console might break the user application. + // Try to log to self. If a logger was previously registered it will receive the log. + const err = new Error('Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation'); + self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message); + return false; + } + if (typeof optionsOrLogLevel === 'number') { + optionsOrLogLevel = { + logLevel: optionsOrLogLevel, + }; + } + const oldLogger = (0, global_utils_1.getGlobal)('diag'); + const newLogger = (0, logLevelLogger_1.createLogLevelDiagLogger)((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : types_1.DiagLogLevel.INFO, logger); + // There already is an logger registered. We'll let it know before overwriting it. + if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) { + const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : ''; + oldLogger.warn(`Current logger will be overwritten from ${stack}`); + newLogger.warn(`Current logger will overwrite one already registered from ${stack}`); + } + return (0, global_utils_1.registerGlobal)('diag', newLogger, self, true); + }; + self.setLogger = setLogger; + self.disable = () => { + (0, global_utils_1.unregisterGlobal)(API_NAME, self); + }; + self.createComponentLogger = (options) => { + return new ComponentLogger_1.DiagComponentLogger(options); + }; + self.verbose = _logProxy('verbose'); + self.debug = _logProxy('debug'); + self.info = _logProxy('info'); + self.warn = _logProxy('warn'); + self.error = _logProxy('error'); + } + /** Get the singleton instance of the DiagAPI API */ + static instance() { + if (!this._instance) { + this._instance = new DiagAPI(); + } + return this._instance; + } +} +exports.DiagAPI = DiagAPI; +//# sourceMappingURL=diag.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/metrics.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/metrics.d.ts new file mode 100644 index 000000000..5adc1454c --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/metrics.d.ts @@ -0,0 +1,28 @@ +import { Meter, MeterOptions } from '../metrics/Meter'; +import { MeterProvider } from '../metrics/MeterProvider'; +/** + * Singleton object which represents the entry point to the OpenTelemetry Metrics API + */ +export declare class MetricsAPI { + private static _instance?; + /** Empty private constructor prevents end users from constructing a new instance of the API */ + private constructor(); + /** Get the singleton instance of the Metrics API */ + static getInstance(): MetricsAPI; + /** + * Set the current global meter provider. + * Returns true if the meter provider was successfully registered, else false. + */ + setGlobalMeterProvider(provider: MeterProvider): boolean; + /** + * Returns the global meter provider. + */ + getMeterProvider(): MeterProvider; + /** + * Returns a meter from the global meter provider. + */ + getMeter(name: string, version?: string, options?: MeterOptions): Meter; + /** Remove the global meter provider */ + disable(): void; +} +//# sourceMappingURL=metrics.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/metrics.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/metrics.js new file mode 100644 index 000000000..4bbc43318 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/metrics.js @@ -0,0 +1,61 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.MetricsAPI = void 0; +const NoopMeterProvider_1 = require("../metrics/NoopMeterProvider"); +const global_utils_1 = require("../internal/global-utils"); +const diag_1 = require("./diag"); +const API_NAME = 'metrics'; +/** + * Singleton object which represents the entry point to the OpenTelemetry Metrics API + */ +class MetricsAPI { + /** Empty private constructor prevents end users from constructing a new instance of the API */ + constructor() { } + /** Get the singleton instance of the Metrics API */ + static getInstance() { + if (!this._instance) { + this._instance = new MetricsAPI(); + } + return this._instance; + } + /** + * Set the current global meter provider. + * Returns true if the meter provider was successfully registered, else false. + */ + setGlobalMeterProvider(provider) { + return (0, global_utils_1.registerGlobal)(API_NAME, provider, diag_1.DiagAPI.instance()); + } + /** + * Returns the global meter provider. + */ + getMeterProvider() { + return (0, global_utils_1.getGlobal)(API_NAME) || NoopMeterProvider_1.NOOP_METER_PROVIDER; + } + /** + * Returns a meter from the global meter provider. + */ + getMeter(name, version, options) { + return this.getMeterProvider().getMeter(name, version, options); + } + /** Remove the global meter provider */ + disable() { + (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance()); + } +} +exports.MetricsAPI = MetricsAPI; +//# sourceMappingURL=metrics.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/propagation.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/propagation.d.ts new file mode 100644 index 000000000..a22d24d30 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/propagation.d.ts @@ -0,0 +1,49 @@ +import { Context } from '../context/types'; +import { TextMapGetter, TextMapPropagator, TextMapSetter } from '../propagation/TextMapPropagator'; +import { getBaggage, getActiveBaggage, setBaggage, deleteBaggage } from '../baggage/context-helpers'; +import { createBaggage } from '../baggage/utils'; +/** + * Singleton object which represents the entry point to the OpenTelemetry Propagation API + */ +export declare class PropagationAPI { + private static _instance?; + /** Empty private constructor prevents end users from constructing a new instance of the API */ + private constructor(); + /** Get the singleton instance of the Propagator API */ + static getInstance(): PropagationAPI; + /** + * Set the current propagator. + * + * @returns true if the propagator was successfully registered, else false + */ + setGlobalPropagator(propagator: TextMapPropagator): boolean; + /** + * Inject context into a carrier to be propagated inter-process + * + * @param context Context carrying tracing data to inject + * @param carrier carrier to inject context into + * @param setter Function used to set values on the carrier + */ + inject(context: Context, carrier: Carrier, setter?: TextMapSetter): void; + /** + * Extract context from a carrier + * + * @param context Context which the newly created context will inherit from + * @param carrier Carrier to extract context from + * @param getter Function used to extract keys from a carrier + */ + extract(context: Context, carrier: Carrier, getter?: TextMapGetter): Context; + /** + * Return a list of all fields which may be used by the propagator. + */ + fields(): string[]; + /** Remove the global propagator */ + disable(): void; + createBaggage: typeof createBaggage; + getBaggage: typeof getBaggage; + getActiveBaggage: typeof getActiveBaggage; + setBaggage: typeof setBaggage; + deleteBaggage: typeof deleteBaggage; + private _getGlobalPropagator; +} +//# sourceMappingURL=propagation.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/propagation.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/propagation.js new file mode 100644 index 000000000..7f03df81f --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/propagation.js @@ -0,0 +1,89 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PropagationAPI = void 0; +const global_utils_1 = require("../internal/global-utils"); +const NoopTextMapPropagator_1 = require("../propagation/NoopTextMapPropagator"); +const TextMapPropagator_1 = require("../propagation/TextMapPropagator"); +const context_helpers_1 = require("../baggage/context-helpers"); +const utils_1 = require("../baggage/utils"); +const diag_1 = require("./diag"); +const API_NAME = 'propagation'; +const NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator_1.NoopTextMapPropagator(); +/** + * Singleton object which represents the entry point to the OpenTelemetry Propagation API + */ +class PropagationAPI { + /** Empty private constructor prevents end users from constructing a new instance of the API */ + constructor() { + this.createBaggage = utils_1.createBaggage; + this.getBaggage = context_helpers_1.getBaggage; + this.getActiveBaggage = context_helpers_1.getActiveBaggage; + this.setBaggage = context_helpers_1.setBaggage; + this.deleteBaggage = context_helpers_1.deleteBaggage; + } + /** Get the singleton instance of the Propagator API */ + static getInstance() { + if (!this._instance) { + this._instance = new PropagationAPI(); + } + return this._instance; + } + /** + * Set the current propagator. + * + * @returns true if the propagator was successfully registered, else false + */ + setGlobalPropagator(propagator) { + return (0, global_utils_1.registerGlobal)(API_NAME, propagator, diag_1.DiagAPI.instance()); + } + /** + * Inject context into a carrier to be propagated inter-process + * + * @param context Context carrying tracing data to inject + * @param carrier carrier to inject context into + * @param setter Function used to set values on the carrier + */ + inject(context, carrier, setter = TextMapPropagator_1.defaultTextMapSetter) { + return this._getGlobalPropagator().inject(context, carrier, setter); + } + /** + * Extract context from a carrier + * + * @param context Context which the newly created context will inherit from + * @param carrier Carrier to extract context from + * @param getter Function used to extract keys from a carrier + */ + extract(context, carrier, getter = TextMapPropagator_1.defaultTextMapGetter) { + return this._getGlobalPropagator().extract(context, carrier, getter); + } + /** + * Return a list of all fields which may be used by the propagator. + */ + fields() { + return this._getGlobalPropagator().fields(); + } + /** Remove the global propagator */ + disable() { + (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance()); + } + _getGlobalPropagator() { + return (0, global_utils_1.getGlobal)(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR; + } +} +exports.PropagationAPI = PropagationAPI; +//# sourceMappingURL=propagation.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/trace.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/trace.d.ts new file mode 100644 index 000000000..df59fd2f9 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/trace.d.ts @@ -0,0 +1,40 @@ +import { isSpanContextValid, wrapSpanContext } from '../trace/spancontext-utils'; +import { Tracer } from '../trace/tracer'; +import { TracerProvider } from '../trace/tracer_provider'; +import { deleteSpan, getActiveSpan, getSpan, getSpanContext, setSpan, setSpanContext } from '../trace/context-utils'; +/** + * Singleton object which represents the entry point to the OpenTelemetry Tracing API + */ +export declare class TraceAPI { + private static _instance?; + private _proxyTracerProvider; + /** Empty private constructor prevents end users from constructing a new instance of the API */ + private constructor(); + /** Get the singleton instance of the Trace API */ + static getInstance(): TraceAPI; + /** + * Set the current global tracer. + * + * @returns true if the tracer provider was successfully registered, else false + */ + setGlobalTracerProvider(provider: TracerProvider): boolean; + /** + * Returns the global tracer provider. + */ + getTracerProvider(): TracerProvider; + /** + * Returns a tracer from the global tracer provider. + */ + getTracer(name: string, version?: string): Tracer; + /** Remove the global tracer provider */ + disable(): void; + wrapSpanContext: typeof wrapSpanContext; + isSpanContextValid: typeof isSpanContextValid; + deleteSpan: typeof deleteSpan; + getSpan: typeof getSpan; + getActiveSpan: typeof getActiveSpan; + getSpanContext: typeof getSpanContext; + setSpan: typeof setSpan; + setSpanContext: typeof setSpanContext; +} +//# sourceMappingURL=trace.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/trace.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/trace.js new file mode 100644 index 000000000..aa7a9da56 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/api/trace.js @@ -0,0 +1,79 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TraceAPI = void 0; +const global_utils_1 = require("../internal/global-utils"); +const ProxyTracerProvider_1 = require("../trace/ProxyTracerProvider"); +const spancontext_utils_1 = require("../trace/spancontext-utils"); +const context_utils_1 = require("../trace/context-utils"); +const diag_1 = require("./diag"); +const API_NAME = 'trace'; +/** + * Singleton object which represents the entry point to the OpenTelemetry Tracing API + */ +class TraceAPI { + /** Empty private constructor prevents end users from constructing a new instance of the API */ + constructor() { + this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider(); + this.wrapSpanContext = spancontext_utils_1.wrapSpanContext; + this.isSpanContextValid = spancontext_utils_1.isSpanContextValid; + this.deleteSpan = context_utils_1.deleteSpan; + this.getSpan = context_utils_1.getSpan; + this.getActiveSpan = context_utils_1.getActiveSpan; + this.getSpanContext = context_utils_1.getSpanContext; + this.setSpan = context_utils_1.setSpan; + this.setSpanContext = context_utils_1.setSpanContext; + } + /** Get the singleton instance of the Trace API */ + static getInstance() { + if (!this._instance) { + this._instance = new TraceAPI(); + } + return this._instance; + } + /** + * Set the current global tracer. + * + * @returns true if the tracer provider was successfully registered, else false + */ + setGlobalTracerProvider(provider) { + const success = (0, global_utils_1.registerGlobal)(API_NAME, this._proxyTracerProvider, diag_1.DiagAPI.instance()); + if (success) { + this._proxyTracerProvider.setDelegate(provider); + } + return success; + } + /** + * Returns the global tracer provider. + */ + getTracerProvider() { + return (0, global_utils_1.getGlobal)(API_NAME) || this._proxyTracerProvider; + } + /** + * Returns a tracer from the global tracer provider. + */ + getTracer(name, version) { + return this.getTracerProvider().getTracer(name, version); + } + /** Remove the global tracer provider */ + disable() { + (0, global_utils_1.unregisterGlobal)(API_NAME, diag_1.DiagAPI.instance()); + this._proxyTracerProvider = new ProxyTracerProvider_1.ProxyTracerProvider(); + } +} +exports.TraceAPI = TraceAPI; +//# sourceMappingURL=trace.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/context-helpers.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/context-helpers.d.ts new file mode 100644 index 000000000..23750eb61 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/context-helpers.d.ts @@ -0,0 +1,29 @@ +import { Context } from '../context/types'; +import { Baggage } from './types'; +/** + * Retrieve the current baggage from the given context + * + * @param {Context} Context that manage all context values + * @returns {Baggage} Extracted baggage from the context + */ +export declare function getBaggage(context: Context): Baggage | undefined; +/** + * Retrieve the current baggage from the active/current context + * + * @returns {Baggage} Extracted baggage from the context + */ +export declare function getActiveBaggage(): Baggage | undefined; +/** + * Store a baggage in the given context + * + * @param {Context} Context that manage all context values + * @param {Baggage} baggage that will be set in the actual context + */ +export declare function setBaggage(context: Context, baggage: Baggage): Context; +/** + * Delete the baggage stored in the given context + * + * @param {Context} Context that manage all context values + */ +export declare function deleteBaggage(context: Context): Context; +//# sourceMappingURL=context-helpers.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js new file mode 100644 index 000000000..cc0f00bf1 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/context-helpers.js @@ -0,0 +1,63 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.deleteBaggage = exports.setBaggage = exports.getActiveBaggage = exports.getBaggage = void 0; +const context_1 = require("../api/context"); +const context_2 = require("../context/context"); +/** + * Baggage key + */ +const BAGGAGE_KEY = (0, context_2.createContextKey)('OpenTelemetry Baggage Key'); +/** + * Retrieve the current baggage from the given context + * + * @param {Context} Context that manage all context values + * @returns {Baggage} Extracted baggage from the context + */ +function getBaggage(context) { + return context.getValue(BAGGAGE_KEY) || undefined; +} +exports.getBaggage = getBaggage; +/** + * Retrieve the current baggage from the active/current context + * + * @returns {Baggage} Extracted baggage from the context + */ +function getActiveBaggage() { + return getBaggage(context_1.ContextAPI.getInstance().active()); +} +exports.getActiveBaggage = getActiveBaggage; +/** + * Store a baggage in the given context + * + * @param {Context} Context that manage all context values + * @param {Baggage} baggage that will be set in the actual context + */ +function setBaggage(context, baggage) { + return context.setValue(BAGGAGE_KEY, baggage); +} +exports.setBaggage = setBaggage; +/** + * Delete the baggage stored in the given context + * + * @param {Context} Context that manage all context values + */ +function deleteBaggage(context) { + return context.deleteValue(BAGGAGE_KEY); +} +exports.deleteBaggage = deleteBaggage; +//# sourceMappingURL=context-helpers.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.d.ts new file mode 100644 index 000000000..e6b455404 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.d.ts @@ -0,0 +1,12 @@ +import type { Baggage, BaggageEntry } from '../types'; +export declare class BaggageImpl implements Baggage { + private _entries; + constructor(entries?: Map); + getEntry(key: string): BaggageEntry | undefined; + getAllEntries(): [string, BaggageEntry][]; + setEntry(key: string, entry: BaggageEntry): BaggageImpl; + removeEntry(key: string): BaggageImpl; + removeEntries(...keys: string[]): BaggageImpl; + clear(): BaggageImpl; +} +//# sourceMappingURL=baggage-impl.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js new file mode 100644 index 000000000..6f04d4a67 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/baggage-impl.js @@ -0,0 +1,55 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BaggageImpl = void 0; +class BaggageImpl { + constructor(entries) { + this._entries = entries ? new Map(entries) : new Map(); + } + getEntry(key) { + const entry = this._entries.get(key); + if (!entry) { + return undefined; + } + return Object.assign({}, entry); + } + getAllEntries() { + return Array.from(this._entries.entries()).map(([k, v]) => [k, v]); + } + setEntry(key, entry) { + const newBaggage = new BaggageImpl(this._entries); + newBaggage._entries.set(key, entry); + return newBaggage; + } + removeEntry(key) { + const newBaggage = new BaggageImpl(this._entries); + newBaggage._entries.delete(key); + return newBaggage; + } + removeEntries(...keys) { + const newBaggage = new BaggageImpl(this._entries); + for (const key of keys) { + newBaggage._entries.delete(key); + } + return newBaggage; + } + clear() { + return new BaggageImpl(); + } +} +exports.BaggageImpl = BaggageImpl; +//# sourceMappingURL=baggage-impl.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.d.ts new file mode 100644 index 000000000..9cd991c1c --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.d.ts @@ -0,0 +1,5 @@ +/** + * Symbol used to make BaggageEntryMetadata an opaque type + */ +export declare const baggageEntryMetadataSymbol: unique symbol; +//# sourceMappingURL=symbol.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js new file mode 100644 index 000000000..324c216dd --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/internal/symbol.js @@ -0,0 +1,23 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.baggageEntryMetadataSymbol = void 0; +/** + * Symbol used to make BaggageEntryMetadata an opaque type + */ +exports.baggageEntryMetadataSymbol = Symbol('BaggageEntryMetadata'); +//# sourceMappingURL=symbol.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/types.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/types.d.ts new file mode 100644 index 000000000..32fa0ec6b --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/types.d.ts @@ -0,0 +1,60 @@ +import { baggageEntryMetadataSymbol } from './internal/symbol'; +export interface BaggageEntry { + /** `String` value of the `BaggageEntry`. */ + value: string; + /** + * Metadata is an optional string property defined by the W3C baggage specification. + * It currently has no special meaning defined by the specification. + */ + metadata?: BaggageEntryMetadata; +} +/** + * Serializable Metadata defined by the W3C baggage specification. + * It currently has no special meaning defined by the OpenTelemetry or W3C. + */ +export declare type BaggageEntryMetadata = { + toString(): string; +} & { + __TYPE__: typeof baggageEntryMetadataSymbol; +}; +/** + * Baggage represents collection of key-value pairs with optional metadata. + * Each key of Baggage is associated with exactly one value. + * Baggage may be used to annotate and enrich telemetry data. + */ +export interface Baggage { + /** + * Get an entry from Baggage if it exists + * + * @param key The key which identifies the BaggageEntry + */ + getEntry(key: string): BaggageEntry | undefined; + /** + * Get a list of all entries in the Baggage + */ + getAllEntries(): [string, BaggageEntry][]; + /** + * Returns a new baggage with the entries from the current bag and the specified entry + * + * @param key string which identifies the baggage entry + * @param entry BaggageEntry for the given key + */ + setEntry(key: string, entry: BaggageEntry): Baggage; + /** + * Returns a new baggage with the entries from the current bag except the removed entry + * + * @param key key identifying the entry to be removed + */ + removeEntry(key: string): Baggage; + /** + * Returns a new baggage with the entries from the current bag except the removed entries + * + * @param key keys identifying the entries to be removed + */ + removeEntries(...key: string[]): Baggage; + /** + * Returns a new baggage with no entries + */ + clear(): Baggage; +} +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/types.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/types.js new file mode 100644 index 000000000..c428c6d09 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/types.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=types.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/utils.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/utils.d.ts new file mode 100644 index 000000000..9955d9e28 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/utils.d.ts @@ -0,0 +1,15 @@ +import { Baggage, BaggageEntry, BaggageEntryMetadata } from './types'; +/** + * Create a new Baggage with optional entries + * + * @param entries An array of baggage entries the new baggage should contain + */ +export declare function createBaggage(entries?: Record): Baggage; +/** + * Create a serializable BaggageEntryMetadata object from a string. + * + * @param str string metadata. Format is currently not defined by the spec and has no special meaning. + * + */ +export declare function baggageEntryMetadataFromString(str: string): BaggageEntryMetadata; +//# sourceMappingURL=utils.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/utils.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/utils.js new file mode 100644 index 000000000..a0bfbf6c3 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/baggage/utils.js @@ -0,0 +1,51 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.baggageEntryMetadataFromString = exports.createBaggage = void 0; +const diag_1 = require("../api/diag"); +const baggage_impl_1 = require("./internal/baggage-impl"); +const symbol_1 = require("./internal/symbol"); +const diag = diag_1.DiagAPI.instance(); +/** + * Create a new Baggage with optional entries + * + * @param entries An array of baggage entries the new baggage should contain + */ +function createBaggage(entries = {}) { + return new baggage_impl_1.BaggageImpl(new Map(Object.entries(entries))); +} +exports.createBaggage = createBaggage; +/** + * Create a serializable BaggageEntryMetadata object from a string. + * + * @param str string metadata. Format is currently not defined by the spec and has no special meaning. + * + */ +function baggageEntryMetadataFromString(str) { + if (typeof str !== 'string') { + diag.error(`Cannot create baggage metadata from unknown type: ${typeof str}`); + str = ''; + } + return { + __TYPE__: symbol_1.baggageEntryMetadataSymbol, + toString() { + return str; + }, + }; +} +exports.baggageEntryMetadataFromString = baggageEntryMetadataFromString; +//# sourceMappingURL=utils.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Attributes.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Attributes.d.ts new file mode 100644 index 000000000..19994fb2a --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Attributes.d.ts @@ -0,0 +1,15 @@ +/** + * Attributes is a map from string to attribute values. + * + * Note: only the own enumerable keys are counted as valid attribute keys. + */ +export interface Attributes { + [attributeKey: string]: AttributeValue | undefined; +} +/** + * Attribute values may be any non-nullish primitive value except an object. + * + * null or undefined attribute values are invalid and will result in undefined behavior. + */ +export declare type AttributeValue = string | number | boolean | Array | Array | Array; +//# sourceMappingURL=Attributes.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Attributes.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Attributes.js new file mode 100644 index 000000000..684c93db9 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Attributes.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=Attributes.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Exception.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Exception.d.ts new file mode 100644 index 000000000..e175a7fdc --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Exception.d.ts @@ -0,0 +1,26 @@ +interface ExceptionWithCode { + code: string | number; + name?: string; + message?: string; + stack?: string; +} +interface ExceptionWithMessage { + code?: string | number; + message: string; + name?: string; + stack?: string; +} +interface ExceptionWithName { + code?: string | number; + message?: string; + name: string; + stack?: string; +} +/** + * Defines Exception. + * + * string or an object with one of (message or name or code) and optional stack + */ +export declare type Exception = ExceptionWithCode | ExceptionWithMessage | ExceptionWithName | string; +export {}; +//# sourceMappingURL=Exception.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Exception.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Exception.js new file mode 100644 index 000000000..ed450aef6 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Exception.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=Exception.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Time.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Time.d.ts new file mode 100644 index 000000000..cc3c502c1 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Time.d.ts @@ -0,0 +1,20 @@ +/** + * Defines High-Resolution Time. + * + * The first number, HrTime[0], is UNIX Epoch time in seconds since 00:00:00 UTC on 1 January 1970. + * The second number, HrTime[1], represents the partial second elapsed since Unix Epoch time represented by first number in nanoseconds. + * For example, 2021-01-01T12:30:10.150Z in UNIX Epoch time in milliseconds is represented as 1609504210150. + * The first number is calculated by converting and truncating the Epoch time in milliseconds to seconds: + * HrTime[0] = Math.trunc(1609504210150 / 1000) = 1609504210. + * The second number is calculated by converting the digits after the decimal point of the subtraction, (1609504210150 / 1000) - HrTime[0], to nanoseconds: + * HrTime[1] = Number((1609504210.150 - HrTime[0]).toFixed(9)) * 1e9 = 150000000. + * This is represented in HrTime format as [1609504210, 150000000]. + */ +export declare type HrTime = [number, number]; +/** + * Defines TimeInput. + * + * hrtime, epoch milliseconds, performance.now() or Date + */ +export declare type TimeInput = HrTime | number | Date; +//# sourceMappingURL=Time.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Time.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Time.js new file mode 100644 index 000000000..1faaf6983 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/common/Time.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=Time.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context-api.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context-api.d.ts new file mode 100644 index 000000000..650f4eecc --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context-api.d.ts @@ -0,0 +1,4 @@ +import { ContextAPI } from './api/context'; +/** Entrypoint for context API */ +export declare const context: ContextAPI; +//# sourceMappingURL=context-api.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context-api.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context-api.js new file mode 100644 index 000000000..b9aeea932 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context-api.js @@ -0,0 +1,24 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.context = void 0; +// Split module-level variable definition into separate files to allow +// tree-shaking on each api instance. +const context_1 = require("./api/context"); +/** Entrypoint for context API */ +exports.context = context_1.ContextAPI.getInstance(); +//# sourceMappingURL=context-api.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/NoopContextManager.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/NoopContextManager.d.ts new file mode 100644 index 000000000..48a165970 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/NoopContextManager.d.ts @@ -0,0 +1,9 @@ +import * as types from './types'; +export declare class NoopContextManager implements types.ContextManager { + active(): types.Context; + with ReturnType>(_context: types.Context, fn: F, thisArg?: ThisParameterType, ...args: A): ReturnType; + bind(_context: types.Context, target: T): T; + enable(): this; + disable(): this; +} +//# sourceMappingURL=NoopContextManager.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js new file mode 100644 index 000000000..10c6ae1bd --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/NoopContextManager.js @@ -0,0 +1,38 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NoopContextManager = void 0; +const context_1 = require("./context"); +class NoopContextManager { + active() { + return context_1.ROOT_CONTEXT; + } + with(_context, fn, thisArg, ...args) { + return fn.call(thisArg, ...args); + } + bind(_context, target) { + return target; + } + enable() { + return this; + } + disable() { + return this; + } +} +exports.NoopContextManager = NoopContextManager; +//# sourceMappingURL=NoopContextManager.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/context.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/context.d.ts new file mode 100644 index 000000000..8be025940 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/context.d.ts @@ -0,0 +1,6 @@ +import { Context } from './types'; +/** Get a key to uniquely identify a context value */ +export declare function createContextKey(description: string): symbol; +/** The root context is used as the default parent context when there is no active context */ +export declare const ROOT_CONTEXT: Context; +//# sourceMappingURL=context.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/context.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/context.js new file mode 100644 index 000000000..eecc15931 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/context.js @@ -0,0 +1,55 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ROOT_CONTEXT = exports.createContextKey = void 0; +/** Get a key to uniquely identify a context value */ +function createContextKey(description) { + // The specification states that for the same input, multiple calls should + // return different keys. Due to the nature of the JS dependency management + // system, this creates problems where multiple versions of some package + // could hold different keys for the same property. + // + // Therefore, we use Symbol.for which returns the same key for the same input. + return Symbol.for(description); +} +exports.createContextKey = createContextKey; +class BaseContext { + /** + * Construct a new context which inherits values from an optional parent context. + * + * @param parentContext a context from which to inherit values + */ + constructor(parentContext) { + // for minification + const self = this; + self._currentContext = parentContext ? new Map(parentContext) : new Map(); + self.getValue = (key) => self._currentContext.get(key); + self.setValue = (key, value) => { + const context = new BaseContext(self._currentContext); + context._currentContext.set(key, value); + return context; + }; + self.deleteValue = (key) => { + const context = new BaseContext(self._currentContext); + context._currentContext.delete(key); + return context; + }; + } +} +/** The root context is used as the default parent context when there is no active context */ +exports.ROOT_CONTEXT = new BaseContext(); +//# sourceMappingURL=context.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/types.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/types.d.ts new file mode 100644 index 000000000..7e866320c --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/types.d.ts @@ -0,0 +1,52 @@ +export interface Context { + /** + * Get a value from the context. + * + * @param key key which identifies a context value + */ + getValue(key: symbol): unknown; + /** + * Create a new context which inherits from this context and has + * the given key set to the given value. + * + * @param key context key for which to set the value + * @param value value to set for the given key + */ + setValue(key: symbol, value: unknown): Context; + /** + * Return a new context which inherits from this context but does + * not contain a value for the given key. + * + * @param key context key for which to clear a value + */ + deleteValue(key: symbol): Context; +} +export interface ContextManager { + /** + * Get the current active context + */ + active(): Context; + /** + * Run the fn callback with object set as the current active context + * @param context Any object to set as the current active context + * @param fn A callback to be immediately run within a specific context + * @param thisArg optional receiver to be used for calling fn + * @param args optional arguments forwarded to fn + */ + with ReturnType>(context: Context, fn: F, thisArg?: ThisParameterType, ...args: A): ReturnType; + /** + * Bind an object as the current context (or a specific one) + * @param [context] Optionally specify the context which you want to assign + * @param target Any object to which a context need to be set + */ + bind(context: Context, target: T): T; + /** + * Enable context management + */ + enable(): this; + /** + * Disable context management + */ + disable(): this; +} +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/types.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/types.js new file mode 100644 index 000000000..c428c6d09 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/context/types.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=types.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag-api.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag-api.d.ts new file mode 100644 index 000000000..d82fdb18d --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag-api.d.ts @@ -0,0 +1,9 @@ +import { DiagAPI } from './api/diag'; +/** + * Entrypoint for Diag API. + * Defines Diagnostic handler used for internal diagnostic logging operations. + * The default provides a Noop DiagLogger implementation which may be changed via the + * diag.setLogger(logger: DiagLogger) function. + */ +export declare const diag: DiagAPI; +//# sourceMappingURL=diag-api.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag-api.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag-api.js new file mode 100644 index 000000000..cbf28db3c --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag-api.js @@ -0,0 +1,29 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.diag = void 0; +// Split module-level variable definition into separate files to allow +// tree-shaking on each api instance. +const diag_1 = require("./api/diag"); +/** + * Entrypoint for Diag API. + * Defines Diagnostic handler used for internal diagnostic logging operations. + * The default provides a Noop DiagLogger implementation which may be changed via the + * diag.setLogger(logger: DiagLogger) function. + */ +exports.diag = diag_1.DiagAPI.instance(); +//# sourceMappingURL=diag-api.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.d.ts new file mode 100644 index 000000000..f06095031 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.d.ts @@ -0,0 +1,20 @@ +import { ComponentLoggerOptions, DiagLogger } from './types'; +/** + * Component Logger which is meant to be used as part of any component which + * will add automatically additional namespace in front of the log message. + * It will then forward all message to global diag logger + * @example + * const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' }); + * cLogger.debug('test'); + * // @opentelemetry/instrumentation-http test + */ +export declare class DiagComponentLogger implements DiagLogger { + private _namespace; + constructor(props: ComponentLoggerOptions); + debug(...args: any[]): void; + error(...args: any[]): void; + info(...args: any[]): void; + warn(...args: any[]): void; + verbose(...args: any[]): void; +} +//# sourceMappingURL=ComponentLogger.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js new file mode 100644 index 000000000..579b7e68f --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/ComponentLogger.js @@ -0,0 +1,59 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DiagComponentLogger = void 0; +const global_utils_1 = require("../internal/global-utils"); +/** + * Component Logger which is meant to be used as part of any component which + * will add automatically additional namespace in front of the log message. + * It will then forward all message to global diag logger + * @example + * const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' }); + * cLogger.debug('test'); + * // @opentelemetry/instrumentation-http test + */ +class DiagComponentLogger { + constructor(props) { + this._namespace = props.namespace || 'DiagComponentLogger'; + } + debug(...args) { + return logProxy('debug', this._namespace, args); + } + error(...args) { + return logProxy('error', this._namespace, args); + } + info(...args) { + return logProxy('info', this._namespace, args); + } + warn(...args) { + return logProxy('warn', this._namespace, args); + } + verbose(...args) { + return logProxy('verbose', this._namespace, args); + } +} +exports.DiagComponentLogger = DiagComponentLogger; +function logProxy(funcName, namespace, args) { + const logger = (0, global_utils_1.getGlobal)('diag'); + // shortcut if logger not set + if (!logger) { + return; + } + args.unshift(namespace); + return logger[funcName](...args); +} +//# sourceMappingURL=ComponentLogger.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/consoleLogger.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/consoleLogger.d.ts new file mode 100644 index 000000000..fa3db1e31 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/consoleLogger.d.ts @@ -0,0 +1,38 @@ +import { DiagLogger, DiagLogFunction } from './types'; +/** + * A simple Immutable Console based diagnostic logger which will output any messages to the Console. + * If you want to limit the amount of logging to a specific level or lower use the + * {@link createLogLevelDiagLogger} + */ +export declare class DiagConsoleLogger implements DiagLogger { + constructor(); + /** Log an error scenario that was not expected and caused the requested operation to fail. */ + error: DiagLogFunction; + /** + * Log a warning scenario to inform the developer of an issues that should be investigated. + * The requested operation may or may not have succeeded or completed. + */ + warn: DiagLogFunction; + /** + * Log a general informational message, this should not affect functionality. + * This is also the default logging level so this should NOT be used for logging + * debugging level information. + */ + info: DiagLogFunction; + /** + * Log a general debug message that can be useful for identifying a failure. + * Information logged at this level may include diagnostic details that would + * help identify a failure scenario. Useful scenarios would be to log the execution + * order of async operations + */ + debug: DiagLogFunction; + /** + * Log a detailed (verbose) trace level logging that can be used to identify failures + * where debug level logging would be insufficient, this level of tracing can include + * input and output parameters and as such may include PII information passing through + * the API. As such it is recommended that this level of tracing should not be enabled + * in a production environment. + */ + verbose: DiagLogFunction; +} +//# sourceMappingURL=consoleLogger.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js new file mode 100644 index 000000000..1962275ff --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/consoleLogger.js @@ -0,0 +1,57 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DiagConsoleLogger = void 0; +const consoleMap = [ + { n: 'error', c: 'error' }, + { n: 'warn', c: 'warn' }, + { n: 'info', c: 'info' }, + { n: 'debug', c: 'debug' }, + { n: 'verbose', c: 'trace' }, +]; +/** + * A simple Immutable Console based diagnostic logger which will output any messages to the Console. + * If you want to limit the amount of logging to a specific level or lower use the + * {@link createLogLevelDiagLogger} + */ +class DiagConsoleLogger { + constructor() { + function _consoleFunc(funcName) { + return function (...args) { + if (console) { + // Some environments only expose the console when the F12 developer console is open + // eslint-disable-next-line no-console + let theFunc = console[funcName]; + if (typeof theFunc !== 'function') { + // Not all environments support all functions + // eslint-disable-next-line no-console + theFunc = console.log; + } + // One last final check + if (typeof theFunc === 'function') { + return theFunc.apply(console, args); + } + } + }; + } + for (let i = 0; i < consoleMap.length; i++) { + this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c); + } + } +} +exports.DiagConsoleLogger = DiagConsoleLogger; +//# sourceMappingURL=consoleLogger.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.d.ts new file mode 100644 index 000000000..890b9f1ef --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.d.ts @@ -0,0 +1,3 @@ +import { DiagLogger, DiagLogLevel } from '../types'; +export declare function createLogLevelDiagLogger(maxLevel: DiagLogLevel, logger: DiagLogger): DiagLogger; +//# sourceMappingURL=logLevelLogger.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js new file mode 100644 index 000000000..ee1702e5f --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/logLevelLogger.js @@ -0,0 +1,45 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createLogLevelDiagLogger = void 0; +const types_1 = require("../types"); +function createLogLevelDiagLogger(maxLevel, logger) { + if (maxLevel < types_1.DiagLogLevel.NONE) { + maxLevel = types_1.DiagLogLevel.NONE; + } + else if (maxLevel > types_1.DiagLogLevel.ALL) { + maxLevel = types_1.DiagLogLevel.ALL; + } + // In case the logger is null or undefined + logger = logger || {}; + function _filterFunc(funcName, theLevel) { + const theFunc = logger[funcName]; + if (typeof theFunc === 'function' && maxLevel >= theLevel) { + return theFunc.bind(logger); + } + return function () { }; + } + return { + error: _filterFunc('error', types_1.DiagLogLevel.ERROR), + warn: _filterFunc('warn', types_1.DiagLogLevel.WARN), + info: _filterFunc('info', types_1.DiagLogLevel.INFO), + debug: _filterFunc('debug', types_1.DiagLogLevel.DEBUG), + verbose: _filterFunc('verbose', types_1.DiagLogLevel.VERBOSE), + }; +} +exports.createLogLevelDiagLogger = createLogLevelDiagLogger; +//# sourceMappingURL=logLevelLogger.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/noopLogger.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/noopLogger.d.ts new file mode 100644 index 000000000..ac71ee3b5 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/noopLogger.d.ts @@ -0,0 +1,8 @@ +import { DiagLogger } from '../types'; +/** + * Returns a No-Op Diagnostic logger where all messages do nothing. + * @implements {@link DiagLogger} + * @returns {DiagLogger} + */ +export declare function createNoopDiagLogger(): DiagLogger; +//# sourceMappingURL=noopLogger.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/noopLogger.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/noopLogger.js new file mode 100644 index 000000000..409163145 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/internal/noopLogger.js @@ -0,0 +1,35 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createNoopDiagLogger = void 0; +function noopLogFunction() { } +/** + * Returns a No-Op Diagnostic logger where all messages do nothing. + * @implements {@link DiagLogger} + * @returns {DiagLogger} + */ +function createNoopDiagLogger() { + return { + verbose: noopLogFunction, + debug: noopLogFunction, + info: noopLogFunction, + warn: noopLogFunction, + error: noopLogFunction, + }; +} +exports.createNoopDiagLogger = createNoopDiagLogger; +//# sourceMappingURL=noopLogger.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/types.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/types.d.ts new file mode 100644 index 000000000..e992cc59c --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/types.d.ts @@ -0,0 +1,100 @@ +export declare type DiagLogFunction = (message: string, ...args: unknown[]) => void; +/** + * Defines an internal diagnostic logger interface which is used to log internal diagnostic + * messages, you can set the default diagnostic logger via the {@link DiagAPI} setLogger function. + * API provided implementations include :- + * - a No-Op {@link createNoopDiagLogger} + * - a {@link DiagLogLevel} filtering wrapper {@link createLogLevelDiagLogger} + * - a general Console {@link DiagConsoleLogger} version. + */ +export interface DiagLogger { + /** Log an error scenario that was not expected and caused the requested operation to fail. */ + error: DiagLogFunction; + /** + * Log a warning scenario to inform the developer of an issues that should be investigated. + * The requested operation may or may not have succeeded or completed. + */ + warn: DiagLogFunction; + /** + * Log a general informational message, this should not affect functionality. + * This is also the default logging level so this should NOT be used for logging + * debugging level information. + */ + info: DiagLogFunction; + /** + * Log a general debug message that can be useful for identifying a failure. + * Information logged at this level may include diagnostic details that would + * help identify a failure scenario. + * For example: Logging the order of execution of async operations. + */ + debug: DiagLogFunction; + /** + * Log a detailed (verbose) trace level logging that can be used to identify failures + * where debug level logging would be insufficient, this level of tracing can include + * input and output parameters and as such may include PII information passing through + * the API. As such it is recommended that this level of tracing should not be enabled + * in a production environment. + */ + verbose: DiagLogFunction; +} +/** + * Defines the available internal logging levels for the diagnostic logger, the numeric values + * of the levels are defined to match the original values from the initial LogLevel to avoid + * compatibility/migration issues for any implementation that assume the numeric ordering. + */ +export declare enum DiagLogLevel { + /** Diagnostic Logging level setting to disable all logging (except and forced logs) */ + NONE = 0, + /** Identifies an error scenario */ + ERROR = 30, + /** Identifies a warning scenario */ + WARN = 50, + /** General informational log message */ + INFO = 60, + /** General debug log message */ + DEBUG = 70, + /** + * Detailed trace level logging should only be used for development, should only be set + * in a development environment. + */ + VERBOSE = 80, + /** Used to set the logging level to include all logging */ + ALL = 9999 +} +/** + * Defines options for ComponentLogger + */ +export interface ComponentLoggerOptions { + namespace: string; +} +export interface DiagLoggerOptions { + /** + * The {@link DiagLogLevel} used to filter logs sent to the logger. + * + * @defaultValue DiagLogLevel.INFO + */ + logLevel?: DiagLogLevel; + /** + * Setting this value to `true` will suppress the warning message normally emitted when registering a logger when another logger is already registered. + */ + suppressOverrideMessage?: boolean; +} +export interface DiagLoggerApi { + /** + * Set the global DiagLogger and DiagLogLevel. + * If a global diag logger is already set, this will override it. + * + * @param logger - The {@link DiagLogger} instance to set as the default logger. + * @param options - A {@link DiagLoggerOptions} object. If not provided, default values will be set. + * @returns `true` if the logger was successfully registered, else `false` + */ + setLogger(logger: DiagLogger, options?: DiagLoggerOptions): boolean; + /** + * + * @param logger - The {@link DiagLogger} instance to set as the default logger. + * @param logLevel - The {@link DiagLogLevel} used to filter logs sent to the logger. If not provided it will default to {@link DiagLogLevel.INFO}. + * @returns `true` if the logger was successfully registered, else `false` + */ + setLogger(logger: DiagLogger, logLevel?: DiagLogLevel): boolean; +} +//# sourceMappingURL=types.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/types.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/types.js new file mode 100644 index 000000000..c195e45e8 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/diag/types.js @@ -0,0 +1,44 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DiagLogLevel = void 0; +/** + * Defines the available internal logging levels for the diagnostic logger, the numeric values + * of the levels are defined to match the original values from the initial LogLevel to avoid + * compatibility/migration issues for any implementation that assume the numeric ordering. + */ +var DiagLogLevel; +(function (DiagLogLevel) { + /** Diagnostic Logging level setting to disable all logging (except and forced logs) */ + DiagLogLevel[DiagLogLevel["NONE"] = 0] = "NONE"; + /** Identifies an error scenario */ + DiagLogLevel[DiagLogLevel["ERROR"] = 30] = "ERROR"; + /** Identifies a warning scenario */ + DiagLogLevel[DiagLogLevel["WARN"] = 50] = "WARN"; + /** General informational log message */ + DiagLogLevel[DiagLogLevel["INFO"] = 60] = "INFO"; + /** General debug log message */ + DiagLogLevel[DiagLogLevel["DEBUG"] = 70] = "DEBUG"; + /** + * Detailed trace level logging should only be used for development, should only be set + * in a development environment. + */ + DiagLogLevel[DiagLogLevel["VERBOSE"] = 80] = "VERBOSE"; + /** Used to set the logging level to include all logging */ + DiagLogLevel[DiagLogLevel["ALL"] = 9999] = "ALL"; +})(DiagLogLevel = exports.DiagLogLevel || (exports.DiagLogLevel = {})); +//# sourceMappingURL=types.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/index.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/index.d.ts new file mode 100644 index 000000000..bec39657e --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/index.d.ts @@ -0,0 +1,3 @@ +export { wrapTracer, SugaredTracer } from './trace/SugaredTracer'; +export { SugaredSpanOptions } from './trace/SugaredOptions'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/index.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/index.js new file mode 100644 index 000000000..bd611ec0c --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/index.js @@ -0,0 +1,22 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SugaredTracer = exports.wrapTracer = void 0; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var SugaredTracer_1 = require("./trace/SugaredTracer"); +Object.defineProperty(exports, "wrapTracer", { enumerable: true, get: function () { return SugaredTracer_1.wrapTracer; } }); +Object.defineProperty(exports, "SugaredTracer", { enumerable: true, get: function () { return SugaredTracer_1.SugaredTracer; } }); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredOptions.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredOptions.d.ts new file mode 100644 index 000000000..89040affc --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredOptions.d.ts @@ -0,0 +1,13 @@ +import { Span, SpanOptions } from '../../'; +/** + * Options needed for span creation + */ +export interface SugaredSpanOptions extends SpanOptions { + /** + * function to overwrite default exception behavior to record the exception. No exceptions should be thrown in the function. + * @param e Error which triggered this exception + * @param span current span from context + */ + onException?: (e: Error, span: Span) => void; +} +//# sourceMappingURL=SugaredOptions.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredOptions.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredOptions.js new file mode 100644 index 000000000..a18d65b22 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredOptions.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=SugaredOptions.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredTracer.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredTracer.d.ts new file mode 100644 index 000000000..1ba7da921 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredTracer.d.ts @@ -0,0 +1,64 @@ +import { SugaredSpanOptions } from './SugaredOptions'; +import { Context, Span, Tracer } from '../../'; +/** + * return a new SugaredTracer created from the supplied one + * @param tracer + */ +export declare function wrapTracer(tracer: Tracer): SugaredTracer; +export declare class SugaredTracer implements Tracer { + private readonly _tracer; + constructor(tracer: Tracer); + startActiveSpan: Tracer['startActiveSpan']; + startSpan: Tracer['startSpan']; + /** + * Starts a new {@link Span} and calls the given function passing it the + * created span as first argument. + * Additionally, the new span gets set in context and this context is activated + * for the duration of the function call. + * The span will be closed after the function has executed. + * If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown. + * + * @param name The name of the span + * @param [options] SugaredSpanOptions used for span creation + * @param [context] Context to use to extract parent + * @param fn function called in the context of the span and receives the newly created span as an argument + * @returns return value of fn + * @example + * const something = tracer.withActiveSpan('op', span => { + * // do some work + * }); + * @example + * const something = await tracer.withActiveSpan('op', span => { + * // do some async work + * }); + */ + withActiveSpan ReturnType>(name: string, fn: F): ReturnType; + withActiveSpan ReturnType>(name: string, options: SugaredSpanOptions, fn: F): ReturnType; + withActiveSpan ReturnType>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType; + /** + * Starts a new {@link Span} and ends it after execution of fn without setting it on context. + * The span will be closed after the function has executed. + * If an exception occurs, it is recorded, the status is et to ERROR and rethrown. + * + * This method does NOT modify the current Context. + * + * @param name The name of the span + * @param [options] SugaredSpanOptions used for span creation + * @param [context] Context to use to extract parent + * @param fn function called in the context of the span and receives the newly created span as an argument + * @returns Span The newly created span + * @example + * const something = tracer.withSpan('op', span => { + * // do some work + * }); + * @example + * const something = await tracer.withSpan('op', span => { + * // do some async work + * }); + */ + withSpan ReturnType>(name: string, fn: F): ReturnType; + withSpan ReturnType>(name: string, options: SugaredSpanOptions, fn: F): ReturnType; + withSpan ReturnType>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType; + withSpan ReturnType>(name: string, options: SugaredSpanOptions, context: Context, fn: F): ReturnType; +} +//# sourceMappingURL=SugaredTracer.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredTracer.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredTracer.js new file mode 100644 index 000000000..aae624982 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/experimental/trace/SugaredTracer.js @@ -0,0 +1,93 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SugaredTracer = exports.wrapTracer = void 0; +const __1 = require("../../"); +const defaultOnException = (e, span) => { + span.recordException(e); + span.setStatus({ + code: __1.SpanStatusCode.ERROR, + }); +}; +/** + * return a new SugaredTracer created from the supplied one + * @param tracer + */ +function wrapTracer(tracer) { + return new SugaredTracer(tracer); +} +exports.wrapTracer = wrapTracer; +class SugaredTracer { + constructor(tracer) { + this._tracer = tracer; + this.startSpan = tracer.startSpan.bind(this._tracer); + this.startActiveSpan = tracer.startActiveSpan.bind(this._tracer); + } + withActiveSpan(name, arg2, arg3, arg4) { + const { opts, ctx, fn } = massageParams(arg2, arg3, arg4); + return this._tracer.startActiveSpan(name, opts, ctx, (span) => handleFn(span, opts, fn)); + } + withSpan(name, arg2, arg3, arg4) { + const { opts, ctx, fn } = massageParams(arg2, arg3, arg4); + const span = this._tracer.startSpan(name, opts, ctx); + return handleFn(span, opts, fn); + } +} +exports.SugaredTracer = SugaredTracer; +/** + * Massages parameters of withSpan and withActiveSpan to allow signature overwrites + * @param arg + * @param arg2 + * @param arg3 + */ +function massageParams(arg, arg2, arg3) { + let opts; + let ctx; + let fn; + if (!arg2 && !arg3) { + fn = arg; + } + else if (!arg3) { + opts = arg; + fn = arg2; + } + else { + opts = arg; + ctx = arg2; + fn = arg3; + } + opts = opts !== null && opts !== void 0 ? opts : {}; + ctx = ctx !== null && ctx !== void 0 ? ctx : __1.context.active(); + return { opts, ctx, fn }; +} +/** + * Executes fn, returns results and runs onException in the case of exception to allow overwriting of error handling + * @param span + * @param opts + * @param fn + */ +function handleFn(span, opts, fn) { + var _a; + const onException = (_a = opts.onException) !== null && _a !== void 0 ? _a : defaultOnException; + const errorHandler = (e) => { + onException(e, span); + span.end(); + throw e; + }; + try { + const ret = fn(span); + // if fn is an async function, attach a recordException and spanEnd callback to the promise + if (typeof (ret === null || ret === void 0 ? void 0 : ret.then) === 'function') { + return ret.then(val => { + span.end(); + return val; + }, errorHandler); + } + span.end(); + return ret; + } + catch (e) { + // add throw to signal the compiler that this will throw in the inner scope + throw errorHandler(e); + } +} +//# sourceMappingURL=SugaredTracer.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/index.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/index.d.ts new file mode 100644 index 000000000..eea88f226 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/index.d.ts @@ -0,0 +1,54 @@ +export { BaggageEntry, BaggageEntryMetadata, Baggage } from './baggage/types'; +export { baggageEntryMetadataFromString } from './baggage/utils'; +export { Exception } from './common/Exception'; +export { HrTime, TimeInput } from './common/Time'; +export { Attributes, AttributeValue } from './common/Attributes'; +export { createContextKey, ROOT_CONTEXT } from './context/context'; +export { Context, ContextManager } from './context/types'; +export type { ContextAPI } from './api/context'; +export { DiagConsoleLogger } from './diag/consoleLogger'; +export { DiagLogFunction, DiagLogger, DiagLogLevel, ComponentLoggerOptions, DiagLoggerOptions, } from './diag/types'; +export type { DiagAPI } from './api/diag'; +export { createNoopMeter } from './metrics/NoopMeter'; +export { MeterOptions, Meter } from './metrics/Meter'; +export { MeterProvider } from './metrics/MeterProvider'; +export { ValueType, Counter, Gauge, Histogram, MetricOptions, Observable, ObservableCounter, ObservableGauge, ObservableUpDownCounter, UpDownCounter, BatchObservableCallback, MetricAdvice, MetricAttributes, MetricAttributeValue, ObservableCallback, } from './metrics/Metric'; +export { BatchObservableResult, ObservableResult, } from './metrics/ObservableResult'; +export type { MetricsAPI } from './api/metrics'; +export { TextMapPropagator, TextMapSetter, TextMapGetter, defaultTextMapGetter, defaultTextMapSetter, } from './propagation/TextMapPropagator'; +export type { PropagationAPI } from './api/propagation'; +export { SpanAttributes, SpanAttributeValue } from './trace/attributes'; +export { Link } from './trace/link'; +export { ProxyTracer, TracerDelegator } from './trace/ProxyTracer'; +export { ProxyTracerProvider } from './trace/ProxyTracerProvider'; +export { Sampler } from './trace/Sampler'; +export { SamplingDecision, SamplingResult } from './trace/SamplingResult'; +export { SpanContext } from './trace/span_context'; +export { SpanKind } from './trace/span_kind'; +export { Span } from './trace/span'; +export { SpanOptions } from './trace/SpanOptions'; +export { SpanStatus, SpanStatusCode } from './trace/status'; +export { TraceFlags } from './trace/trace_flags'; +export { TraceState } from './trace/trace_state'; +export { createTraceState } from './trace/internal/utils'; +export { TracerProvider } from './trace/tracer_provider'; +export { Tracer } from './trace/tracer'; +export { TracerOptions } from './trace/tracer_options'; +export { isSpanContextValid, isValidTraceId, isValidSpanId, } from './trace/spancontext-utils'; +export { INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT, } from './trace/invalid-span-constants'; +export type { TraceAPI } from './api/trace'; +import { context } from './context-api'; +import { diag } from './diag-api'; +import { metrics } from './metrics-api'; +import { propagation } from './propagation-api'; +import { trace } from './trace-api'; +export { context, diag, metrics, propagation, trace }; +declare const _default: { + context: import("./api/context").ContextAPI; + diag: import("./api/diag").DiagAPI; + metrics: import("./api/metrics").MetricsAPI; + propagation: import("./api/propagation").PropagationAPI; + trace: import("./api/trace").TraceAPI; +}; +export default _default; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/index.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/index.js new file mode 100644 index 000000000..cb0a87232 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/index.js @@ -0,0 +1,81 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.trace = exports.propagation = exports.metrics = exports.diag = exports.context = exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = exports.isValidSpanId = exports.isValidTraceId = exports.isSpanContextValid = exports.createTraceState = exports.TraceFlags = exports.SpanStatusCode = exports.SpanKind = exports.SamplingDecision = exports.ProxyTracerProvider = exports.ProxyTracer = exports.defaultTextMapSetter = exports.defaultTextMapGetter = exports.ValueType = exports.createNoopMeter = exports.DiagLogLevel = exports.DiagConsoleLogger = exports.ROOT_CONTEXT = exports.createContextKey = exports.baggageEntryMetadataFromString = void 0; +var utils_1 = require("./baggage/utils"); +Object.defineProperty(exports, "baggageEntryMetadataFromString", { enumerable: true, get: function () { return utils_1.baggageEntryMetadataFromString; } }); +// Context APIs +var context_1 = require("./context/context"); +Object.defineProperty(exports, "createContextKey", { enumerable: true, get: function () { return context_1.createContextKey; } }); +Object.defineProperty(exports, "ROOT_CONTEXT", { enumerable: true, get: function () { return context_1.ROOT_CONTEXT; } }); +// Diag APIs +var consoleLogger_1 = require("./diag/consoleLogger"); +Object.defineProperty(exports, "DiagConsoleLogger", { enumerable: true, get: function () { return consoleLogger_1.DiagConsoleLogger; } }); +var types_1 = require("./diag/types"); +Object.defineProperty(exports, "DiagLogLevel", { enumerable: true, get: function () { return types_1.DiagLogLevel; } }); +// Metrics APIs +var NoopMeter_1 = require("./metrics/NoopMeter"); +Object.defineProperty(exports, "createNoopMeter", { enumerable: true, get: function () { return NoopMeter_1.createNoopMeter; } }); +var Metric_1 = require("./metrics/Metric"); +Object.defineProperty(exports, "ValueType", { enumerable: true, get: function () { return Metric_1.ValueType; } }); +// Propagation APIs +var TextMapPropagator_1 = require("./propagation/TextMapPropagator"); +Object.defineProperty(exports, "defaultTextMapGetter", { enumerable: true, get: function () { return TextMapPropagator_1.defaultTextMapGetter; } }); +Object.defineProperty(exports, "defaultTextMapSetter", { enumerable: true, get: function () { return TextMapPropagator_1.defaultTextMapSetter; } }); +var ProxyTracer_1 = require("./trace/ProxyTracer"); +Object.defineProperty(exports, "ProxyTracer", { enumerable: true, get: function () { return ProxyTracer_1.ProxyTracer; } }); +var ProxyTracerProvider_1 = require("./trace/ProxyTracerProvider"); +Object.defineProperty(exports, "ProxyTracerProvider", { enumerable: true, get: function () { return ProxyTracerProvider_1.ProxyTracerProvider; } }); +var SamplingResult_1 = require("./trace/SamplingResult"); +Object.defineProperty(exports, "SamplingDecision", { enumerable: true, get: function () { return SamplingResult_1.SamplingDecision; } }); +var span_kind_1 = require("./trace/span_kind"); +Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function () { return span_kind_1.SpanKind; } }); +var status_1 = require("./trace/status"); +Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function () { return status_1.SpanStatusCode; } }); +var trace_flags_1 = require("./trace/trace_flags"); +Object.defineProperty(exports, "TraceFlags", { enumerable: true, get: function () { return trace_flags_1.TraceFlags; } }); +var utils_2 = require("./trace/internal/utils"); +Object.defineProperty(exports, "createTraceState", { enumerable: true, get: function () { return utils_2.createTraceState; } }); +var spancontext_utils_1 = require("./trace/spancontext-utils"); +Object.defineProperty(exports, "isSpanContextValid", { enumerable: true, get: function () { return spancontext_utils_1.isSpanContextValid; } }); +Object.defineProperty(exports, "isValidTraceId", { enumerable: true, get: function () { return spancontext_utils_1.isValidTraceId; } }); +Object.defineProperty(exports, "isValidSpanId", { enumerable: true, get: function () { return spancontext_utils_1.isValidSpanId; } }); +var invalid_span_constants_1 = require("./trace/invalid-span-constants"); +Object.defineProperty(exports, "INVALID_SPANID", { enumerable: true, get: function () { return invalid_span_constants_1.INVALID_SPANID; } }); +Object.defineProperty(exports, "INVALID_TRACEID", { enumerable: true, get: function () { return invalid_span_constants_1.INVALID_TRACEID; } }); +Object.defineProperty(exports, "INVALID_SPAN_CONTEXT", { enumerable: true, get: function () { return invalid_span_constants_1.INVALID_SPAN_CONTEXT; } }); +// Split module-level variable definition into separate files to allow +// tree-shaking on each api instance. +const context_api_1 = require("./context-api"); +Object.defineProperty(exports, "context", { enumerable: true, get: function () { return context_api_1.context; } }); +const diag_api_1 = require("./diag-api"); +Object.defineProperty(exports, "diag", { enumerable: true, get: function () { return diag_api_1.diag; } }); +const metrics_api_1 = require("./metrics-api"); +Object.defineProperty(exports, "metrics", { enumerable: true, get: function () { return metrics_api_1.metrics; } }); +const propagation_api_1 = require("./propagation-api"); +Object.defineProperty(exports, "propagation", { enumerable: true, get: function () { return propagation_api_1.propagation; } }); +const trace_api_1 = require("./trace-api"); +Object.defineProperty(exports, "trace", { enumerable: true, get: function () { return trace_api_1.trace; } }); +// Default export. +exports.default = { + context: context_api_1.context, + diag: diag_api_1.diag, + metrics: metrics_api_1.metrics, + propagation: propagation_api_1.propagation, + trace: trace_api_1.trace, +}; +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/global-utils.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/global-utils.d.ts new file mode 100644 index 000000000..320db9755 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/global-utils.d.ts @@ -0,0 +1,18 @@ +import { MeterProvider } from '../metrics/MeterProvider'; +import { ContextManager } from '../context/types'; +import { DiagLogger } from '../diag/types'; +import { TextMapPropagator } from '../propagation/TextMapPropagator'; +import type { TracerProvider } from '../trace/tracer_provider'; +export declare function registerGlobal(type: Type, instance: OTelGlobalAPI[Type], diag: DiagLogger, allowOverride?: boolean): boolean; +export declare function getGlobal(type: Type): OTelGlobalAPI[Type] | undefined; +export declare function unregisterGlobal(type: keyof OTelGlobalAPI, diag: DiagLogger): void; +declare type OTelGlobalAPI = { + version: string; + diag?: DiagLogger; + trace?: TracerProvider; + context?: ContextManager; + metrics?: MeterProvider; + propagation?: TextMapPropagator; +}; +export {}; +//# sourceMappingURL=global-utils.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/global-utils.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/global-utils.js new file mode 100644 index 000000000..11a1a441d --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/global-utils.js @@ -0,0 +1,64 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.unregisterGlobal = exports.getGlobal = exports.registerGlobal = void 0; +const platform_1 = require("../platform"); +const version_1 = require("../version"); +const semver_1 = require("./semver"); +const major = version_1.VERSION.split('.')[0]; +const GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`); +const _global = platform_1._globalThis; +function registerGlobal(type, instance, diag, allowOverride = false) { + var _a; + const api = (_global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : { + version: version_1.VERSION, + }); + if (!allowOverride && api[type]) { + // already registered an API of this type + const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`); + diag.error(err.stack || err.message); + return false; + } + if (api.version !== version_1.VERSION) { + // All registered APIs must be of the same version exactly + const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${version_1.VERSION}`); + diag.error(err.stack || err.message); + return false; + } + api[type] = instance; + diag.debug(`@opentelemetry/api: Registered a global for ${type} v${version_1.VERSION}.`); + return true; +} +exports.registerGlobal = registerGlobal; +function getGlobal(type) { + var _a, _b; + const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version; + if (!globalVersion || !(0, semver_1.isCompatible)(globalVersion)) { + return; + } + return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type]; +} +exports.getGlobal = getGlobal; +function unregisterGlobal(type, diag) { + diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${version_1.VERSION}.`); + const api = _global[GLOBAL_OPENTELEMETRY_API_KEY]; + if (api) { + delete api[type]; + } +} +exports.unregisterGlobal = unregisterGlobal; +//# sourceMappingURL=global-utils.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/semver.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/semver.d.ts new file mode 100644 index 000000000..d9f4259e4 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/semver.d.ts @@ -0,0 +1,34 @@ +/** + * Create a function to test an API version to see if it is compatible with the provided ownVersion. + * + * The returned function has the following semantics: + * - Exact match is always compatible + * - Major versions must match exactly + * - 1.x package cannot use global 2.x package + * - 2.x package cannot use global 1.x package + * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API + * - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects + * - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3 + * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor + * - Patch and build tag differences are not considered at this time + * + * @param ownVersion version which should be checked against + */ +export declare function _makeCompatibilityCheck(ownVersion: string): (globalVersion: string) => boolean; +/** + * Test an API version to see if it is compatible with this API. + * + * - Exact match is always compatible + * - Major versions must match exactly + * - 1.x package cannot use global 2.x package + * - 2.x package cannot use global 1.x package + * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API + * - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects + * - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3 + * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor + * - Patch and build tag differences are not considered at this time + * + * @param version version of the API requesting an instance of the global API + */ +export declare const isCompatible: (globalVersion: string) => boolean; +//# sourceMappingURL=semver.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/semver.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/semver.js new file mode 100644 index 000000000..7a073b224 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/internal/semver.js @@ -0,0 +1,122 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.isCompatible = exports._makeCompatibilityCheck = void 0; +const version_1 = require("../version"); +const re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/; +/** + * Create a function to test an API version to see if it is compatible with the provided ownVersion. + * + * The returned function has the following semantics: + * - Exact match is always compatible + * - Major versions must match exactly + * - 1.x package cannot use global 2.x package + * - 2.x package cannot use global 1.x package + * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API + * - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects + * - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3 + * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor + * - Patch and build tag differences are not considered at this time + * + * @param ownVersion version which should be checked against + */ +function _makeCompatibilityCheck(ownVersion) { + const acceptedVersions = new Set([ownVersion]); + const rejectedVersions = new Set(); + const myVersionMatch = ownVersion.match(re); + if (!myVersionMatch) { + // we cannot guarantee compatibility so we always return noop + return () => false; + } + const ownVersionParsed = { + major: +myVersionMatch[1], + minor: +myVersionMatch[2], + patch: +myVersionMatch[3], + prerelease: myVersionMatch[4], + }; + // if ownVersion has a prerelease tag, versions must match exactly + if (ownVersionParsed.prerelease != null) { + return function isExactmatch(globalVersion) { + return globalVersion === ownVersion; + }; + } + function _reject(v) { + rejectedVersions.add(v); + return false; + } + function _accept(v) { + acceptedVersions.add(v); + return true; + } + return function isCompatible(globalVersion) { + if (acceptedVersions.has(globalVersion)) { + return true; + } + if (rejectedVersions.has(globalVersion)) { + return false; + } + const globalVersionMatch = globalVersion.match(re); + if (!globalVersionMatch) { + // cannot parse other version + // we cannot guarantee compatibility so we always noop + return _reject(globalVersion); + } + const globalVersionParsed = { + major: +globalVersionMatch[1], + minor: +globalVersionMatch[2], + patch: +globalVersionMatch[3], + prerelease: globalVersionMatch[4], + }; + // if globalVersion has a prerelease tag, versions must match exactly + if (globalVersionParsed.prerelease != null) { + return _reject(globalVersion); + } + // major versions must match + if (ownVersionParsed.major !== globalVersionParsed.major) { + return _reject(globalVersion); + } + if (ownVersionParsed.major === 0) { + if (ownVersionParsed.minor === globalVersionParsed.minor && + ownVersionParsed.patch <= globalVersionParsed.patch) { + return _accept(globalVersion); + } + return _reject(globalVersion); + } + if (ownVersionParsed.minor <= globalVersionParsed.minor) { + return _accept(globalVersion); + } + return _reject(globalVersion); + }; +} +exports._makeCompatibilityCheck = _makeCompatibilityCheck; +/** + * Test an API version to see if it is compatible with this API. + * + * - Exact match is always compatible + * - Major versions must match exactly + * - 1.x package cannot use global 2.x package + * - 2.x package cannot use global 1.x package + * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API + * - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects + * - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3 + * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor + * - Patch and build tag differences are not considered at this time + * + * @param version version of the API requesting an instance of the global API + */ +exports.isCompatible = _makeCompatibilityCheck(version_1.VERSION); +//# sourceMappingURL=semver.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics-api.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics-api.d.ts new file mode 100644 index 000000000..26d539c04 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics-api.d.ts @@ -0,0 +1,4 @@ +import { MetricsAPI } from './api/metrics'; +/** Entrypoint for metrics API */ +export declare const metrics: MetricsAPI; +//# sourceMappingURL=metrics-api.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics-api.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics-api.js new file mode 100644 index 000000000..987f7c25a --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics-api.js @@ -0,0 +1,24 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.metrics = void 0; +// Split module-level variable definition into separate files to allow +// tree-shaking on each api instance. +const metrics_1 = require("./api/metrics"); +/** Entrypoint for metrics API */ +exports.metrics = metrics_1.MetricsAPI.getInstance(); +//# sourceMappingURL=metrics-api.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Meter.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Meter.d.ts new file mode 100644 index 000000000..5e3926b75 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Meter.d.ts @@ -0,0 +1,110 @@ +import { BatchObservableCallback, Counter, Gauge, Histogram, MetricAttributes, MetricOptions, Observable, ObservableCounter, ObservableGauge, ObservableUpDownCounter, UpDownCounter } from './Metric'; +/** + * An interface describes additional metadata of a meter. + */ +export interface MeterOptions { + /** + * The schemaUrl of the meter or instrumentation library + */ + schemaUrl?: string; +} +/** + * An interface to allow the recording metrics. + * + * {@link Metric}s are used for recording pre-defined aggregation (`Counter`), + * or raw values (`Histogram`) in which the aggregation and attributes + * for the exported metric are deferred. + */ +export interface Meter { + /** + * Creates and returns a new `Gauge`. + * @param name the name of the metric. + * @param [options] the metric options. + */ + createGauge(name: string, options?: MetricOptions): Gauge; + /** + * Creates and returns a new `Histogram`. + * @param name the name of the metric. + * @param [options] the metric options. + */ + createHistogram(name: string, options?: MetricOptions): Histogram; + /** + * Creates a new `Counter` metric. Generally, this kind of metric when the + * value is a quantity, the sum is of primary interest, and the event count + * and value distribution are not of primary interest. + * @param name the name of the metric. + * @param [options] the metric options. + */ + createCounter(name: string, options?: MetricOptions): Counter; + /** + * Creates a new `UpDownCounter` metric. UpDownCounter is a synchronous + * instrument and very similar to Counter except that Add(increment) + * supports negative increments. It is generally useful for capturing changes + * in an amount of resources used, or any quantity that rises and falls + * during a request. + * Example uses for UpDownCounter: + *
    + *
  1. count the number of active requests.
    2. + *
  2. count memory in use by instrumenting new and delete.
    3. + *
  3. count queue size by instrumenting enqueue and dequeue.
    4. + *
  4. count semaphore up and down operations.
    5. + *
+ * + * @param name the name of the metric. + * @param [options] the metric options. + */ + createUpDownCounter(name: string, options?: MetricOptions): UpDownCounter; + /** + * Creates a new `ObservableGauge` metric. + * + * The callback SHOULD be safe to be invoked concurrently. + * + * @param name the name of the metric. + * @param [options] the metric options. + */ + createObservableGauge(name: string, options?: MetricOptions): ObservableGauge; + /** + * Creates a new `ObservableCounter` metric. + * + * The callback SHOULD be safe to be invoked concurrently. + * + * @param name the name of the metric. + * @param [options] the metric options. + */ + createObservableCounter(name: string, options?: MetricOptions): ObservableCounter; + /** + * Creates a new `ObservableUpDownCounter` metric. + * + * The callback SHOULD be safe to be invoked concurrently. + * + * @param name the name of the metric. + * @param [options] the metric options. + */ + createObservableUpDownCounter(name: string, options?: MetricOptions): ObservableUpDownCounter; + /** + * Sets up a function that will be called whenever a metric collection is + * initiated. + * + * If the function is already in the list of callbacks for this Observable, + * the function is not added a second time. + * + * Only the associated observables can be observed in the callback. + * Measurements of observables that are not associated observed in the + * callback are dropped. + * + * @param callback the batch observable callback + * @param observables the observables associated with this batch observable callback + */ + addBatchObservableCallback(callback: BatchObservableCallback, observables: Observable[]): void; + /** + * Removes a callback previously registered with {@link Meter.addBatchObservableCallback}. + * + * The callback to be removed is identified using a combination of the callback itself, + * and the set of the observables associated with it. + * + * @param callback the batch observable callback + * @param observables the observables associated with this batch observable callback + */ + removeBatchObservableCallback(callback: BatchObservableCallback, observables: Observable[]): void; +} +//# sourceMappingURL=Meter.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Meter.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Meter.js new file mode 100644 index 000000000..56b930c6e --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Meter.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=Meter.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/MeterProvider.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/MeterProvider.d.ts new file mode 100644 index 000000000..6c08cc317 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/MeterProvider.d.ts @@ -0,0 +1,17 @@ +import { Meter, MeterOptions } from './Meter'; +/** + * A registry for creating named {@link Meter}s. + */ +export interface MeterProvider { + /** + * Returns a Meter, creating one if one with the given name, version, and + * schemaUrl pair is not already created. + * + * @param name The name of the meter or instrumentation library. + * @param version The version of the meter or instrumentation library. + * @param options The options of the meter or instrumentation library. + * @returns Meter A Meter with the given name and version + */ + getMeter(name: string, version?: string, options?: MeterOptions): Meter; +} +//# sourceMappingURL=MeterProvider.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/MeterProvider.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/MeterProvider.js new file mode 100644 index 000000000..e94205e7c --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/MeterProvider.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=MeterProvider.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Metric.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Metric.d.ts new file mode 100644 index 000000000..607b637eb --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Metric.d.ts @@ -0,0 +1,115 @@ +import { Attributes, AttributeValue } from '../common/Attributes'; +import { Context } from '../context/types'; +import { BatchObservableResult, ObservableResult } from './ObservableResult'; +/** + * Advisory options influencing aggregation configuration parameters. + * @experimental + */ +export interface MetricAdvice { + /** + * Hint the explicit bucket boundaries for SDK if the metric is been + * aggregated with a HistogramAggregator. + */ + explicitBucketBoundaries?: number[]; +} +/** + * Options needed for metric creation + */ +export interface MetricOptions { + /** + * The description of the Metric. + * @default '' + */ + description?: string; + /** + * The unit of the Metric values. + * @default '' + */ + unit?: string; + /** + * Indicates the type of the recorded value. + * @default {@link ValueType.DOUBLE} + */ + valueType?: ValueType; + /** + * The advice influencing aggregation configuration parameters. + * @experimental + */ + advice?: MetricAdvice; +} +/** The Type of value. It describes how the data is reported. */ +export declare enum ValueType { + INT = 0, + DOUBLE = 1 +} +/** + * Counter is the most common synchronous instrument. This instrument supports + * an `Add(increment)` function for reporting a sum, and is restricted to + * non-negative increments. The default aggregation is Sum, as for any additive + * instrument. + * + * Example uses for Counter: + *
    + *
  1. count the number of bytes received.
    2. + *
  2. count the number of requests completed.
    3. + *
  3. count the number of accounts created.
    4. + *
  4. count the number of checkpoints run.
    5. + *
  5. count the number of 5xx errors.
    6. + *
      + */ +export interface Counter { + /** + * Increment value of counter by the input. Inputs must not be negative. + */ + add(value: number, attributes?: AttributesTypes, context?: Context): void; +} +export interface UpDownCounter { + /** + * Increment value of counter by the input. Inputs may be negative. + */ + add(value: number, attributes?: AttributesTypes, context?: Context): void; +} +export interface Gauge { + /** + * Records a measurement. + */ + record(value: number, attributes?: AttributesTypes, context?: Context): void; +} +export interface Histogram { + /** + * Records a measurement. Value of the measurement must not be negative. + */ + record(value: number, attributes?: AttributesTypes, context?: Context): void; +} +/** + * @deprecated please use {@link Attributes} + */ +export declare type MetricAttributes = Attributes; +/** + * @deprecated please use {@link AttributeValue} + */ +export declare type MetricAttributeValue = AttributeValue; +/** + * The observable callback for Observable instruments. + */ +export declare type ObservableCallback = (observableResult: ObservableResult) => void | Promise; +/** + * The observable callback for a batch of Observable instruments. + */ +export declare type BatchObservableCallback = (observableResult: BatchObservableResult) => void | Promise; +export interface Observable { + /** + * Sets up a function that will be called whenever a metric collection is initiated. + * + * If the function is already in the list of callbacks for this Observable, the function is not added a second time. + */ + addCallback(callback: ObservableCallback): void; + /** + * Removes a callback previously registered with {@link Observable.addCallback}. + */ + removeCallback(callback: ObservableCallback): void; +} +export declare type ObservableCounter = Observable; +export declare type ObservableUpDownCounter = Observable; +export declare type ObservableGauge = Observable; +//# sourceMappingURL=Metric.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Metric.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Metric.js new file mode 100644 index 000000000..4966c3d51 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/Metric.js @@ -0,0 +1,25 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ValueType = void 0; +/** The Type of value. It describes how the data is reported. */ +var ValueType; +(function (ValueType) { + ValueType[ValueType["INT"] = 0] = "INT"; + ValueType[ValueType["DOUBLE"] = 1] = "DOUBLE"; +})(ValueType = exports.ValueType || (exports.ValueType = {})); +//# sourceMappingURL=Metric.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.d.ts new file mode 100644 index 000000000..bbefa9a74 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.d.ts @@ -0,0 +1,82 @@ +import { Meter } from './Meter'; +import { BatchObservableCallback, Counter, Gauge, Histogram, MetricAttributes, MetricOptions, Observable, ObservableCallback, ObservableCounter, ObservableGauge, ObservableUpDownCounter, UpDownCounter } from './Metric'; +/** + * NoopMeter is a noop implementation of the {@link Meter} interface. It reuses + * constant NoopMetrics for all of its methods. + */ +export declare class NoopMeter implements Meter { + constructor(); + /** + * @see {@link Meter.createGauge} + */ + createGauge(_name: string, _options?: MetricOptions): Gauge; + /** + * @see {@link Meter.createHistogram} + */ + createHistogram(_name: string, _options?: MetricOptions): Histogram; + /** + * @see {@link Meter.createCounter} + */ + createCounter(_name: string, _options?: MetricOptions): Counter; + /** + * @see {@link Meter.createUpDownCounter} + */ + createUpDownCounter(_name: string, _options?: MetricOptions): UpDownCounter; + /** + * @see {@link Meter.createObservableGauge} + */ + createObservableGauge(_name: string, _options?: MetricOptions): ObservableGauge; + /** + * @see {@link Meter.createObservableCounter} + */ + createObservableCounter(_name: string, _options?: MetricOptions): ObservableCounter; + /** + * @see {@link Meter.createObservableUpDownCounter} + */ + createObservableUpDownCounter(_name: string, _options?: MetricOptions): ObservableUpDownCounter; + /** + * @see {@link Meter.addBatchObservableCallback} + */ + addBatchObservableCallback(_callback: BatchObservableCallback, _observables: Observable[]): void; + /** + * @see {@link Meter.removeBatchObservableCallback} + */ + removeBatchObservableCallback(_callback: BatchObservableCallback): void; +} +export declare class NoopMetric { +} +export declare class NoopCounterMetric extends NoopMetric implements Counter { + add(_value: number, _attributes: MetricAttributes): void; +} +export declare class NoopUpDownCounterMetric extends NoopMetric implements UpDownCounter { + add(_value: number, _attributes: MetricAttributes): void; +} +export declare class NoopGaugeMetric extends NoopMetric implements Gauge { + record(_value: number, _attributes: MetricAttributes): void; +} +export declare class NoopHistogramMetric extends NoopMetric implements Histogram { + record(_value: number, _attributes: MetricAttributes): void; +} +export declare class NoopObservableMetric { + addCallback(_callback: ObservableCallback): void; + removeCallback(_callback: ObservableCallback): void; +} +export declare class NoopObservableCounterMetric extends NoopObservableMetric implements ObservableCounter { +} +export declare class NoopObservableGaugeMetric extends NoopObservableMetric implements ObservableGauge { +} +export declare class NoopObservableUpDownCounterMetric extends NoopObservableMetric implements ObservableUpDownCounter { +} +export declare const NOOP_METER: NoopMeter; +export declare const NOOP_COUNTER_METRIC: NoopCounterMetric; +export declare const NOOP_GAUGE_METRIC: NoopGaugeMetric; +export declare const NOOP_HISTOGRAM_METRIC: NoopHistogramMetric; +export declare const NOOP_UP_DOWN_COUNTER_METRIC: NoopUpDownCounterMetric; +export declare const NOOP_OBSERVABLE_COUNTER_METRIC: NoopObservableCounterMetric; +export declare const NOOP_OBSERVABLE_GAUGE_METRIC: NoopObservableGaugeMetric; +export declare const NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC: NoopObservableUpDownCounterMetric; +/** + * Create a no-op Meter + */ +export declare function createNoopMeter(): Meter; +//# sourceMappingURL=NoopMeter.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js new file mode 100644 index 000000000..d40ef036c --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeter.js @@ -0,0 +1,127 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createNoopMeter = exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = exports.NOOP_OBSERVABLE_GAUGE_METRIC = exports.NOOP_OBSERVABLE_COUNTER_METRIC = exports.NOOP_UP_DOWN_COUNTER_METRIC = exports.NOOP_HISTOGRAM_METRIC = exports.NOOP_GAUGE_METRIC = exports.NOOP_COUNTER_METRIC = exports.NOOP_METER = exports.NoopObservableUpDownCounterMetric = exports.NoopObservableGaugeMetric = exports.NoopObservableCounterMetric = exports.NoopObservableMetric = exports.NoopHistogramMetric = exports.NoopGaugeMetric = exports.NoopUpDownCounterMetric = exports.NoopCounterMetric = exports.NoopMetric = exports.NoopMeter = void 0; +/** + * NoopMeter is a noop implementation of the {@link Meter} interface. It reuses + * constant NoopMetrics for all of its methods. + */ +class NoopMeter { + constructor() { } + /** + * @see {@link Meter.createGauge} + */ + createGauge(_name, _options) { + return exports.NOOP_GAUGE_METRIC; + } + /** + * @see {@link Meter.createHistogram} + */ + createHistogram(_name, _options) { + return exports.NOOP_HISTOGRAM_METRIC; + } + /** + * @see {@link Meter.createCounter} + */ + createCounter(_name, _options) { + return exports.NOOP_COUNTER_METRIC; + } + /** + * @see {@link Meter.createUpDownCounter} + */ + createUpDownCounter(_name, _options) { + return exports.NOOP_UP_DOWN_COUNTER_METRIC; + } + /** + * @see {@link Meter.createObservableGauge} + */ + createObservableGauge(_name, _options) { + return exports.NOOP_OBSERVABLE_GAUGE_METRIC; + } + /** + * @see {@link Meter.createObservableCounter} + */ + createObservableCounter(_name, _options) { + return exports.NOOP_OBSERVABLE_COUNTER_METRIC; + } + /** + * @see {@link Meter.createObservableUpDownCounter} + */ + createObservableUpDownCounter(_name, _options) { + return exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC; + } + /** + * @see {@link Meter.addBatchObservableCallback} + */ + addBatchObservableCallback(_callback, _observables) { } + /** + * @see {@link Meter.removeBatchObservableCallback} + */ + removeBatchObservableCallback(_callback) { } +} +exports.NoopMeter = NoopMeter; +class NoopMetric { +} +exports.NoopMetric = NoopMetric; +class NoopCounterMetric extends NoopMetric { + add(_value, _attributes) { } +} +exports.NoopCounterMetric = NoopCounterMetric; +class NoopUpDownCounterMetric extends NoopMetric { + add(_value, _attributes) { } +} +exports.NoopUpDownCounterMetric = NoopUpDownCounterMetric; +class NoopGaugeMetric extends NoopMetric { + record(_value, _attributes) { } +} +exports.NoopGaugeMetric = NoopGaugeMetric; +class NoopHistogramMetric extends NoopMetric { + record(_value, _attributes) { } +} +exports.NoopHistogramMetric = NoopHistogramMetric; +class NoopObservableMetric { + addCallback(_callback) { } + removeCallback(_callback) { } +} +exports.NoopObservableMetric = NoopObservableMetric; +class NoopObservableCounterMetric extends NoopObservableMetric { +} +exports.NoopObservableCounterMetric = NoopObservableCounterMetric; +class NoopObservableGaugeMetric extends NoopObservableMetric { +} +exports.NoopObservableGaugeMetric = NoopObservableGaugeMetric; +class NoopObservableUpDownCounterMetric extends NoopObservableMetric { +} +exports.NoopObservableUpDownCounterMetric = NoopObservableUpDownCounterMetric; +exports.NOOP_METER = new NoopMeter(); +// Synchronous instruments +exports.NOOP_COUNTER_METRIC = new NoopCounterMetric(); +exports.NOOP_GAUGE_METRIC = new NoopGaugeMetric(); +exports.NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric(); +exports.NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric(); +// Asynchronous instruments +exports.NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric(); +exports.NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric(); +exports.NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric(); +/** + * Create a no-op Meter + */ +function createNoopMeter() { + return exports.NOOP_METER; +} +exports.createNoopMeter = createNoopMeter; +//# sourceMappingURL=NoopMeter.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.d.ts new file mode 100644 index 000000000..8b51bc526 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.d.ts @@ -0,0 +1,11 @@ +import { Meter, MeterOptions } from './Meter'; +import { MeterProvider } from './MeterProvider'; +/** + * An implementation of the {@link MeterProvider} which returns an impotent Meter + * for all calls to `getMeter` + */ +export declare class NoopMeterProvider implements MeterProvider { + getMeter(_name: string, _version?: string, _options?: MeterOptions): Meter; +} +export declare const NOOP_METER_PROVIDER: NoopMeterProvider; +//# sourceMappingURL=NoopMeterProvider.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js new file mode 100644 index 000000000..b1c1cc067 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/NoopMeterProvider.js @@ -0,0 +1,31 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NOOP_METER_PROVIDER = exports.NoopMeterProvider = void 0; +const NoopMeter_1 = require("./NoopMeter"); +/** + * An implementation of the {@link MeterProvider} which returns an impotent Meter + * for all calls to `getMeter` + */ +class NoopMeterProvider { + getMeter(_name, _version, _options) { + return NoopMeter_1.NOOP_METER; + } +} +exports.NoopMeterProvider = NoopMeterProvider; +exports.NOOP_METER_PROVIDER = new NoopMeterProvider(); +//# sourceMappingURL=NoopMeterProvider.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/ObservableResult.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/ObservableResult.d.ts new file mode 100644 index 000000000..26563f9ec --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/ObservableResult.d.ts @@ -0,0 +1,31 @@ +import { MetricAttributes, Observable } from './Metric'; +/** + * Interface that is being used in callback function for Observable Metric. + */ +export interface ObservableResult { + /** + * Observe a measurement of the value associated with the given attributes. + * + * @param value The value to be observed. + * @param attributes The attributes associated with the value. If more than + * one values associated with the same attributes values, SDK may pick the + * last one or simply drop the entire observable result. + */ + observe(this: ObservableResult, value: number, attributes?: AttributesTypes): void; +} +/** + * Interface that is being used in batch observable callback function. + */ +export interface BatchObservableResult { + /** + * Observe a measurement of the value associated with the given attributes. + * + * @param metric The observable metric to be observed. + * @param value The value to be observed. + * @param attributes The attributes associated with the value. If more than + * one values associated with the same attributes values, SDK may pick the + * last one or simply drop the entire observable result. + */ + observe(this: BatchObservableResult, metric: Observable, value: number, attributes?: AttributesTypes): void; +} +//# sourceMappingURL=ObservableResult.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/ObservableResult.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/ObservableResult.js new file mode 100644 index 000000000..7e5cbd0ed --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/metrics/ObservableResult.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=ObservableResult.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/globalThis.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/globalThis.d.ts new file mode 100644 index 000000000..e73fd73e5 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/globalThis.d.ts @@ -0,0 +1,10 @@ +/** + * - globalThis (New standard) + * - self (Will return the current window instance for supported browsers) + * - window (fallback for older browser implementations) + * - global (NodeJS implementation) + * - (When all else fails) + */ +/** only globals that common to node and browsers are allowed */ +export declare const _globalThis: typeof globalThis; +//# sourceMappingURL=globalThis.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/globalThis.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/globalThis.js new file mode 100644 index 000000000..15c8d21a7 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/globalThis.js @@ -0,0 +1,38 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports._globalThis = void 0; +// Updates to this file should also be replicated to @opentelemetry/core too. +/** + * - globalThis (New standard) + * - self (Will return the current window instance for supported browsers) + * - window (fallback for older browser implementations) + * - global (NodeJS implementation) + * - (When all else fails) + */ +/** only globals that common to node and browsers are allowed */ +// eslint-disable-next-line node/no-unsupported-features/es-builtins, no-undef +exports._globalThis = typeof globalThis === 'object' + ? globalThis + : typeof self === 'object' + ? self + : typeof window === 'object' + ? window + : typeof global === 'object' + ? global + : {}; +//# sourceMappingURL=globalThis.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/index.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/index.d.ts new file mode 100644 index 000000000..ba20e1232 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/index.d.ts @@ -0,0 +1,2 @@ +export * from './globalThis'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/index.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/index.js new file mode 100644 index 000000000..99fd57c8a --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/browser/index.js @@ -0,0 +1,29 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./globalThis"), exports); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/index.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/index.d.ts new file mode 100644 index 000000000..90595da96 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/index.d.ts @@ -0,0 +1,2 @@ +export * from './node'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/index.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/index.js new file mode 100644 index 000000000..33b834dbf --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/index.js @@ -0,0 +1,29 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./node"), exports); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/globalThis.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/globalThis.d.ts new file mode 100644 index 000000000..e3c83e5d2 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/globalThis.d.ts @@ -0,0 +1,3 @@ +/** only globals that common to node and browsers are allowed */ +export declare const _globalThis: typeof globalThis; +//# sourceMappingURL=globalThis.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js new file mode 100644 index 000000000..82c4e3949 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js @@ -0,0 +1,22 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports._globalThis = void 0; +/** only globals that common to node and browsers are allowed */ +// eslint-disable-next-line node/no-unsupported-features/es-builtins +exports._globalThis = typeof globalThis === 'object' ? globalThis : global; +//# sourceMappingURL=globalThis.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/index.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/index.d.ts new file mode 100644 index 000000000..ba20e1232 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/index.d.ts @@ -0,0 +1,2 @@ +export * from './globalThis'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/index.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/index.js new file mode 100644 index 000000000..99fd57c8a --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/platform/node/index.js @@ -0,0 +1,29 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./globalThis"), exports); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation-api.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation-api.d.ts new file mode 100644 index 000000000..e12b51ba7 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation-api.d.ts @@ -0,0 +1,4 @@ +import { PropagationAPI } from './api/propagation'; +/** Entrypoint for propagation API */ +export declare const propagation: PropagationAPI; +//# sourceMappingURL=propagation-api.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation-api.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation-api.js new file mode 100644 index 000000000..f014fb4a0 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation-api.js @@ -0,0 +1,24 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.propagation = void 0; +// Split module-level variable definition into separate files to allow +// tree-shaking on each api instance. +const propagation_1 = require("./api/propagation"); +/** Entrypoint for propagation API */ +exports.propagation = propagation_1.PropagationAPI.getInstance(); +//# sourceMappingURL=propagation-api.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.d.ts new file mode 100644 index 000000000..398021f3b --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.d.ts @@ -0,0 +1,13 @@ +import { Context } from '../context/types'; +import { TextMapPropagator } from './TextMapPropagator'; +/** + * No-op implementations of {@link TextMapPropagator}. + */ +export declare class NoopTextMapPropagator implements TextMapPropagator { + /** Noop inject function does nothing */ + inject(_context: Context, _carrier: unknown): void; + /** Noop extract function does nothing and returns the input context */ + extract(context: Context, _carrier: unknown): Context; + fields(): string[]; +} +//# sourceMappingURL=NoopTextMapPropagator.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js new file mode 100644 index 000000000..3f395829c --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/NoopTextMapPropagator.js @@ -0,0 +1,34 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NoopTextMapPropagator = void 0; +/** + * No-op implementations of {@link TextMapPropagator}. + */ +class NoopTextMapPropagator { + /** Noop inject function does nothing */ + inject(_context, _carrier) { } + /** Noop extract function does nothing and returns the input context */ + extract(context, _carrier) { + return context; + } + fields() { + return []; + } +} +exports.NoopTextMapPropagator = NoopTextMapPropagator; +//# sourceMappingURL=NoopTextMapPropagator.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.d.ts new file mode 100644 index 000000000..dc39367bf --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.d.ts @@ -0,0 +1,84 @@ +import { Context } from '../context/types'; +/** + * Injects `Context` into and extracts it from carriers that travel + * in-band across process boundaries. Encoding is expected to conform to the + * HTTP Header Field semantics. Values are often encoded as RPC/HTTP request + * headers. + * + * The carrier of propagated data on both the client (injector) and server + * (extractor) side is usually an object such as http headers. Propagation is + * usually implemented via library-specific request interceptors, where the + * client-side injects values and the server-side extracts them. + */ +export interface TextMapPropagator { + /** + * Injects values from a given `Context` into a carrier. + * + * OpenTelemetry defines a common set of format values (TextMapPropagator), + * and each has an expected `carrier` type. + * + * @param context the Context from which to extract values to transmit over + * the wire. + * @param carrier the carrier of propagation fields, such as http request + * headers. + * @param setter an optional {@link TextMapSetter}. If undefined, values will be + * set by direct object assignment. + */ + inject(context: Context, carrier: Carrier, setter: TextMapSetter): void; + /** + * Given a `Context` and a carrier, extract context values from a + * carrier and return a new context, created from the old context, with the + * extracted values. + * + * @param context the Context from which to extract values to transmit over + * the wire. + * @param carrier the carrier of propagation fields, such as http request + * headers. + * @param getter an optional {@link TextMapGetter}. If undefined, keys will be all + * own properties, and keys will be accessed by direct object access. + */ + extract(context: Context, carrier: Carrier, getter: TextMapGetter): Context; + /** + * Return a list of all fields which may be used by the propagator. + */ + fields(): string[]; +} +/** + * A setter is specified by the caller to define a specific method + * to set key/value pairs on the carrier within a propagator. + */ +export interface TextMapSetter { + /** + * Callback used to set a key/value pair on an object. + * + * Should be called by the propagator each time a key/value pair + * should be set, and should set that key/value pair on the propagator. + * + * @param carrier object or class which carries key/value pairs + * @param key string key to modify + * @param value value to be set to the key on the carrier + */ + set(carrier: Carrier, key: string, value: string): void; +} +/** + * A getter is specified by the caller to define a specific method + * to get the value of a key from a carrier. + */ +export interface TextMapGetter { + /** + * Get a list of all keys available on the carrier. + * + * @param carrier + */ + keys(carrier: Carrier): string[]; + /** + * Get the value of a specific key from the carrier. + * + * @param carrier + * @param key + */ + get(carrier: Carrier, key: string): undefined | string | string[]; +} +export declare const defaultTextMapGetter: TextMapGetter; +export declare const defaultTextMapSetter: TextMapSetter; +//# sourceMappingURL=TextMapPropagator.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js new file mode 100644 index 000000000..513f33c62 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/propagation/TextMapPropagator.js @@ -0,0 +1,41 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.defaultTextMapSetter = exports.defaultTextMapGetter = void 0; +exports.defaultTextMapGetter = { + get(carrier, key) { + if (carrier == null) { + return undefined; + } + return carrier[key]; + }, + keys(carrier) { + if (carrier == null) { + return []; + } + return Object.keys(carrier); + }, +}; +exports.defaultTextMapSetter = { + set(carrier, key, value) { + if (carrier == null) { + return; + } + carrier[key] = value; + }, +}; +//# sourceMappingURL=TextMapPropagator.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace-api.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace-api.d.ts new file mode 100644 index 000000000..b4751a7f8 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace-api.d.ts @@ -0,0 +1,4 @@ +import { TraceAPI } from './api/trace'; +/** Entrypoint for trace API */ +export declare const trace: TraceAPI; +//# sourceMappingURL=trace-api.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace-api.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace-api.js new file mode 100644 index 000000000..c8bbe93a8 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace-api.js @@ -0,0 +1,24 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.trace = void 0; +// Split module-level variable definition into separate files to allow +// tree-shaking on each api instance. +const trace_1 = require("./api/trace"); +/** Entrypoint for trace API */ +exports.trace = trace_1.TraceAPI.getInstance(); +//# sourceMappingURL=trace-api.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.d.ts new file mode 100644 index 000000000..ce569f0c5 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.d.ts @@ -0,0 +1,28 @@ +import { Exception } from '../common/Exception'; +import { TimeInput } from '../common/Time'; +import { SpanAttributes } from './attributes'; +import { Span } from './span'; +import { SpanContext } from './span_context'; +import { SpanStatus } from './status'; +import { Link } from './link'; +/** + * The NonRecordingSpan is the default {@link Span} that is used when no Span + * implementation is available. All operations are no-op including context + * propagation. + */ +export declare class NonRecordingSpan implements Span { + private readonly _spanContext; + constructor(_spanContext?: SpanContext); + spanContext(): SpanContext; + setAttribute(_key: string, _value: unknown): this; + setAttributes(_attributes: SpanAttributes): this; + addEvent(_name: string, _attributes?: SpanAttributes): this; + addLink(_link: Link): this; + addLinks(_links: Link[]): this; + setStatus(_status: SpanStatus): this; + updateName(_name: string): this; + end(_endTime?: TimeInput): void; + isRecording(): boolean; + recordException(_exception: Exception, _time?: TimeInput): void; +} +//# sourceMappingURL=NonRecordingSpan.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js new file mode 100644 index 000000000..6d3e6eea8 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NonRecordingSpan.js @@ -0,0 +1,69 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NonRecordingSpan = void 0; +const invalid_span_constants_1 = require("./invalid-span-constants"); +/** + * The NonRecordingSpan is the default {@link Span} that is used when no Span + * implementation is available. All operations are no-op including context + * propagation. + */ +class NonRecordingSpan { + constructor(_spanContext = invalid_span_constants_1.INVALID_SPAN_CONTEXT) { + this._spanContext = _spanContext; + } + // Returns a SpanContext. + spanContext() { + return this._spanContext; + } + // By default does nothing + setAttribute(_key, _value) { + return this; + } + // By default does nothing + setAttributes(_attributes) { + return this; + } + // By default does nothing + addEvent(_name, _attributes) { + return this; + } + addLink(_link) { + return this; + } + addLinks(_links) { + return this; + } + // By default does nothing + setStatus(_status) { + return this; + } + // By default does nothing + updateName(_name) { + return this; + } + // By default does nothing + end(_endTime) { } + // isRecording always returns false for NonRecordingSpan. + isRecording() { + return false; + } + // By default does nothing + recordException(_exception, _time) { } +} +exports.NonRecordingSpan = NonRecordingSpan; +//# sourceMappingURL=NonRecordingSpan.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracer.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracer.d.ts new file mode 100644 index 000000000..0e059c990 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracer.d.ts @@ -0,0 +1,14 @@ +import { Context } from '../context/types'; +import { Span } from './span'; +import { SpanOptions } from './SpanOptions'; +import { Tracer } from './tracer'; +/** + * No-op implementations of {@link Tracer}. + */ +export declare class NoopTracer implements Tracer { + startSpan(name: string, options?: SpanOptions, context?: Context): Span; + startActiveSpan ReturnType>(name: string, fn: F): ReturnType; + startActiveSpan ReturnType>(name: string, opts: SpanOptions | undefined, fn: F): ReturnType; + startActiveSpan ReturnType>(name: string, opts: SpanOptions | undefined, ctx: Context | undefined, fn: F): ReturnType; +} +//# sourceMappingURL=NoopTracer.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js new file mode 100644 index 000000000..0a823aa56 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracer.js @@ -0,0 +1,75 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NoopTracer = void 0; +const context_1 = require("../api/context"); +const context_utils_1 = require("../trace/context-utils"); +const NonRecordingSpan_1 = require("./NonRecordingSpan"); +const spancontext_utils_1 = require("./spancontext-utils"); +const contextApi = context_1.ContextAPI.getInstance(); +/** + * No-op implementations of {@link Tracer}. + */ +class NoopTracer { + // startSpan starts a noop span. + startSpan(name, options, context = contextApi.active()) { + const root = Boolean(options === null || options === void 0 ? void 0 : options.root); + if (root) { + return new NonRecordingSpan_1.NonRecordingSpan(); + } + const parentFromContext = context && (0, context_utils_1.getSpanContext)(context); + if (isSpanContext(parentFromContext) && + (0, spancontext_utils_1.isSpanContextValid)(parentFromContext)) { + return new NonRecordingSpan_1.NonRecordingSpan(parentFromContext); + } + else { + return new NonRecordingSpan_1.NonRecordingSpan(); + } + } + startActiveSpan(name, arg2, arg3, arg4) { + let opts; + let ctx; + let fn; + if (arguments.length < 2) { + return; + } + else if (arguments.length === 2) { + fn = arg2; + } + else if (arguments.length === 3) { + opts = arg2; + fn = arg3; + } + else { + opts = arg2; + ctx = arg3; + fn = arg4; + } + const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active(); + const span = this.startSpan(name, opts, parentContext); + const contextWithSpanSet = (0, context_utils_1.setSpan)(parentContext, span); + return contextApi.with(contextWithSpanSet, fn, undefined, span); + } +} +exports.NoopTracer = NoopTracer; +function isSpanContext(spanContext) { + return (typeof spanContext === 'object' && + typeof spanContext['spanId'] === 'string' && + typeof spanContext['traceId'] === 'string' && + typeof spanContext['traceFlags'] === 'number'); +} +//# sourceMappingURL=NoopTracer.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.d.ts new file mode 100644 index 000000000..ec0fe7920 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.d.ts @@ -0,0 +1,13 @@ +import { Tracer } from './tracer'; +import { TracerOptions } from './tracer_options'; +import { TracerProvider } from './tracer_provider'; +/** + * An implementation of the {@link TracerProvider} which returns an impotent + * Tracer for all calls to `getTracer`. + * + * All operations are no-op. + */ +export declare class NoopTracerProvider implements TracerProvider { + getTracer(_name?: string, _version?: string, _options?: TracerOptions): Tracer; +} +//# sourceMappingURL=NoopTracerProvider.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js new file mode 100644 index 000000000..c9e08d635 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/NoopTracerProvider.js @@ -0,0 +1,32 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NoopTracerProvider = void 0; +const NoopTracer_1 = require("./NoopTracer"); +/** + * An implementation of the {@link TracerProvider} which returns an impotent + * Tracer for all calls to `getTracer`. + * + * All operations are no-op. + */ +class NoopTracerProvider { + getTracer(_name, _version, _options) { + return new NoopTracer_1.NoopTracer(); + } +} +exports.NoopTracerProvider = NoopTracerProvider; +//# sourceMappingURL=NoopTracerProvider.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.d.ts new file mode 100644 index 000000000..116cc5c1f --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.d.ts @@ -0,0 +1,27 @@ +import { Context } from '../context/types'; +import { Span } from './span'; +import { SpanOptions } from './SpanOptions'; +import { Tracer } from './tracer'; +import { TracerOptions } from './tracer_options'; +/** + * Proxy tracer provided by the proxy tracer provider + */ +export declare class ProxyTracer implements Tracer { + private _provider; + readonly name: string; + readonly version?: string | undefined; + readonly options?: TracerOptions | undefined; + private _delegate?; + constructor(_provider: TracerDelegator, name: string, version?: string | undefined, options?: TracerOptions | undefined); + startSpan(name: string, options?: SpanOptions, context?: Context): Span; + startActiveSpan unknown>(_name: string, _options: F | SpanOptions, _context?: F | Context, _fn?: F): ReturnType; + /** + * Try to get a tracer from the proxy tracer provider. + * If the proxy tracer provider has no delegate, return a noop tracer. + */ + private _getTracer; +} +export interface TracerDelegator { + getDelegateTracer(name: string, version?: string, options?: TracerOptions): Tracer | undefined; +} +//# sourceMappingURL=ProxyTracer.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js new file mode 100644 index 000000000..667768010 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracer.js @@ -0,0 +1,55 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ProxyTracer = void 0; +const NoopTracer_1 = require("./NoopTracer"); +const NOOP_TRACER = new NoopTracer_1.NoopTracer(); +/** + * Proxy tracer provided by the proxy tracer provider + */ +class ProxyTracer { + constructor(_provider, name, version, options) { + this._provider = _provider; + this.name = name; + this.version = version; + this.options = options; + } + startSpan(name, options, context) { + return this._getTracer().startSpan(name, options, context); + } + startActiveSpan(_name, _options, _context, _fn) { + const tracer = this._getTracer(); + return Reflect.apply(tracer.startActiveSpan, tracer, arguments); + } + /** + * Try to get a tracer from the proxy tracer provider. + * If the proxy tracer provider has no delegate, return a noop tracer. + */ + _getTracer() { + if (this._delegate) { + return this._delegate; + } + const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options); + if (!tracer) { + return NOOP_TRACER; + } + this._delegate = tracer; + return this._delegate; + } +} +exports.ProxyTracer = ProxyTracer; +//# sourceMappingURL=ProxyTracer.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.d.ts new file mode 100644 index 000000000..ee7eafa94 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.d.ts @@ -0,0 +1,25 @@ +import { Tracer } from './tracer'; +import { TracerProvider } from './tracer_provider'; +import { TracerOptions } from './tracer_options'; +/** + * Tracer provider which provides {@link ProxyTracer}s. + * + * Before a delegate is set, tracers provided are NoOp. + * When a delegate is set, traces are provided from the delegate. + * When a delegate is set after tracers have already been provided, + * all tracers already provided will use the provided delegate implementation. + */ +export declare class ProxyTracerProvider implements TracerProvider { + private _delegate?; + /** + * Get a {@link ProxyTracer} + */ + getTracer(name: string, version?: string, options?: TracerOptions): Tracer; + getDelegate(): TracerProvider; + /** + * Set the delegate tracer provider + */ + setDelegate(delegate: TracerProvider): void; + getDelegateTracer(name: string, version?: string, options?: TracerOptions): Tracer | undefined; +} +//# sourceMappingURL=ProxyTracerProvider.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js new file mode 100644 index 000000000..75ec910de --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/ProxyTracerProvider.js @@ -0,0 +1,54 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ProxyTracerProvider = void 0; +const ProxyTracer_1 = require("./ProxyTracer"); +const NoopTracerProvider_1 = require("./NoopTracerProvider"); +const NOOP_TRACER_PROVIDER = new NoopTracerProvider_1.NoopTracerProvider(); +/** + * Tracer provider which provides {@link ProxyTracer}s. + * + * Before a delegate is set, tracers provided are NoOp. + * When a delegate is set, traces are provided from the delegate. + * When a delegate is set after tracers have already been provided, + * all tracers already provided will use the provided delegate implementation. + */ +class ProxyTracerProvider { + /** + * Get a {@link ProxyTracer} + */ + getTracer(name, version, options) { + var _a; + return ((_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer_1.ProxyTracer(this, name, version, options)); + } + getDelegate() { + var _a; + return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER; + } + /** + * Set the delegate tracer provider + */ + setDelegate(delegate) { + this._delegate = delegate; + } + getDelegateTracer(name, version, options) { + var _a; + return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options); + } +} +exports.ProxyTracerProvider = ProxyTracerProvider; +//# sourceMappingURL=ProxyTracerProvider.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/Sampler.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/Sampler.d.ts new file mode 100644 index 000000000..c847eaf36 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/Sampler.d.ts @@ -0,0 +1,31 @@ +import { Context } from '../context/types'; +import { SpanAttributes } from './attributes'; +import { Link } from './link'; +import { SamplingResult } from './SamplingResult'; +import { SpanKind } from './span_kind'; +/** + * @deprecated use the one declared in @opentelemetry/sdk-trace-base instead. + * This interface represent a sampler. Sampling is a mechanism to control the + * noise and overhead introduced by OpenTelemetry by reducing the number of + * samples of traces collected and sent to the backend. + */ +export interface Sampler { + /** + * Checks whether span needs to be created and tracked. + * + * @param context Parent Context which may contain a span. + * @param traceId of the span to be created. It can be different from the + * traceId in the {@link SpanContext}. Typically in situations when the + * span to be created starts a new trace. + * @param spanName of the span to be created. + * @param spanKind of the span to be created. + * @param attributes Initial set of SpanAttributes for the Span being constructed. + * @param links Collection of links that will be associated with the Span to + * be created. Typically useful for batch operations. + * @returns a {@link SamplingResult}. + */ + shouldSample(context: Context, traceId: string, spanName: string, spanKind: SpanKind, attributes: SpanAttributes, links: Link[]): SamplingResult; + /** Returns the sampler name or short description with the configuration. */ + toString(): string; +} +//# sourceMappingURL=Sampler.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/Sampler.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/Sampler.js new file mode 100644 index 000000000..6034482e4 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/Sampler.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=Sampler.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SamplingResult.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SamplingResult.d.ts new file mode 100644 index 000000000..f2bb495ff --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SamplingResult.d.ts @@ -0,0 +1,49 @@ +import { SpanAttributes } from './attributes'; +import { TraceState } from './trace_state'; +/** + * @deprecated use the one declared in @opentelemetry/sdk-trace-base instead. + * A sampling decision that determines how a {@link Span} will be recorded + * and collected. + */ +export declare enum SamplingDecision { + /** + * `Span.isRecording() === false`, span will not be recorded and all events + * and attributes will be dropped. + */ + NOT_RECORD = 0, + /** + * `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags} + * MUST NOT be set. + */ + RECORD = 1, + /** + * `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags} + * MUST be set. + */ + RECORD_AND_SAMPLED = 2 +} +/** + * @deprecated use the one declared in @opentelemetry/sdk-trace-base instead. + * A sampling result contains a decision for a {@link Span} and additional + * attributes the sampler would like to added to the Span. + */ +export interface SamplingResult { + /** + * A sampling decision, refer to {@link SamplingDecision} for details. + */ + decision: SamplingDecision; + /** + * The list of attributes returned by SamplingResult MUST be immutable. + * Caller may call {@link Sampler}.shouldSample any number of times and + * can safely cache the returned value. + */ + attributes?: Readonly; + /** + * A {@link TraceState} that will be associated with the {@link Span} through + * the new {@link SpanContext}. Samplers SHOULD return the TraceState from + * the passed-in {@link Context} if they do not intend to change it. Leaving + * the value undefined will also leave the TraceState unchanged. + */ + traceState?: TraceState; +} +//# sourceMappingURL=SamplingResult.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js new file mode 100644 index 000000000..6df6b3bf9 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SamplingResult.js @@ -0,0 +1,42 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SamplingDecision = void 0; +/** + * @deprecated use the one declared in @opentelemetry/sdk-trace-base instead. + * A sampling decision that determines how a {@link Span} will be recorded + * and collected. + */ +var SamplingDecision; +(function (SamplingDecision) { + /** + * `Span.isRecording() === false`, span will not be recorded and all events + * and attributes will be dropped. + */ + SamplingDecision[SamplingDecision["NOT_RECORD"] = 0] = "NOT_RECORD"; + /** + * `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags} + * MUST NOT be set. + */ + SamplingDecision[SamplingDecision["RECORD"] = 1] = "RECORD"; + /** + * `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags} + * MUST be set. + */ + SamplingDecision[SamplingDecision["RECORD_AND_SAMPLED"] = 2] = "RECORD_AND_SAMPLED"; +})(SamplingDecision = exports.SamplingDecision || (exports.SamplingDecision = {})); +//# sourceMappingURL=SamplingResult.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SpanOptions.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SpanOptions.d.ts new file mode 100644 index 000000000..c8045689b --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SpanOptions.d.ts @@ -0,0 +1,23 @@ +import { TimeInput } from '../common/Time'; +import { SpanAttributes } from './attributes'; +import { Link } from './link'; +import { SpanKind } from './span_kind'; +/** + * Options needed for span creation + */ +export interface SpanOptions { + /** + * The SpanKind of a span + * @default {@link SpanKind.INTERNAL} + */ + kind?: SpanKind; + /** A span's attributes */ + attributes?: SpanAttributes; + /** {@link Link}s span to other spans */ + links?: Link[]; + /** A manually specified start time for the created `Span` object. */ + startTime?: TimeInput; + /** The new span should be a root span. (Ignore parent from context). */ + root?: boolean; +} +//# sourceMappingURL=SpanOptions.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SpanOptions.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SpanOptions.js new file mode 100644 index 000000000..cb582305b --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/SpanOptions.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=SpanOptions.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/attributes.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/attributes.d.ts new file mode 100644 index 000000000..a2a5d2a2f --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/attributes.d.ts @@ -0,0 +1,10 @@ +import { Attributes, AttributeValue } from '../common/Attributes'; +/** + * @deprecated please use {@link Attributes} + */ +export declare type SpanAttributes = Attributes; +/** + * @deprecated please use {@link AttributeValue} + */ +export declare type SpanAttributeValue = AttributeValue; +//# sourceMappingURL=attributes.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/attributes.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/attributes.js new file mode 100644 index 000000000..c6eb97a3c --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/attributes.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=attributes.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/context-utils.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/context-utils.d.ts new file mode 100644 index 000000000..f35f79421 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/context-utils.d.ts @@ -0,0 +1,41 @@ +import { Context } from '../context/types'; +import { Span } from './span'; +import { SpanContext } from './span_context'; +/** + * Return the span if one exists + * + * @param context context to get span from + */ +export declare function getSpan(context: Context): Span | undefined; +/** + * Gets the span from the current context, if one exists. + */ +export declare function getActiveSpan(): Span | undefined; +/** + * Set the span on a context + * + * @param context context to use as parent + * @param span span to set active + */ +export declare function setSpan(context: Context, span: Span): Context; +/** + * Remove current span stored in the context + * + * @param context context to delete span from + */ +export declare function deleteSpan(context: Context): Context; +/** + * Wrap span context in a NoopSpan and set as span in a new + * context + * + * @param context context to set active span on + * @param spanContext span context to be wrapped + */ +export declare function setSpanContext(context: Context, spanContext: SpanContext): Context; +/** + * Get the span context of the span if it exists. + * + * @param context context to get values from + */ +export declare function getSpanContext(context: Context): SpanContext | undefined; +//# sourceMappingURL=context-utils.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/context-utils.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/context-utils.js new file mode 100644 index 000000000..d7e9c3a3b --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/context-utils.js @@ -0,0 +1,82 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getSpanContext = exports.setSpanContext = exports.deleteSpan = exports.setSpan = exports.getActiveSpan = exports.getSpan = void 0; +const context_1 = require("../context/context"); +const NonRecordingSpan_1 = require("./NonRecordingSpan"); +const context_2 = require("../api/context"); +/** + * span key + */ +const SPAN_KEY = (0, context_1.createContextKey)('OpenTelemetry Context Key SPAN'); +/** + * Return the span if one exists + * + * @param context context to get span from + */ +function getSpan(context) { + return context.getValue(SPAN_KEY) || undefined; +} +exports.getSpan = getSpan; +/** + * Gets the span from the current context, if one exists. + */ +function getActiveSpan() { + return getSpan(context_2.ContextAPI.getInstance().active()); +} +exports.getActiveSpan = getActiveSpan; +/** + * Set the span on a context + * + * @param context context to use as parent + * @param span span to set active + */ +function setSpan(context, span) { + return context.setValue(SPAN_KEY, span); +} +exports.setSpan = setSpan; +/** + * Remove current span stored in the context + * + * @param context context to delete span from + */ +function deleteSpan(context) { + return context.deleteValue(SPAN_KEY); +} +exports.deleteSpan = deleteSpan; +/** + * Wrap span context in a NoopSpan and set as span in a new + * context + * + * @param context context to set active span on + * @param spanContext span context to be wrapped + */ +function setSpanContext(context, spanContext) { + return setSpan(context, new NonRecordingSpan_1.NonRecordingSpan(spanContext)); +} +exports.setSpanContext = setSpanContext; +/** + * Get the span context of the span if it exists. + * + * @param context context to get values from + */ +function getSpanContext(context) { + var _a; + return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext(); +} +exports.getSpanContext = getSpanContext; +//# sourceMappingURL=context-utils.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.d.ts new file mode 100644 index 000000000..9ed5ecb71 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.d.ts @@ -0,0 +1,22 @@ +import { TraceState } from '../trace_state'; +/** + * TraceState must be a class and not a simple object type because of the spec + * requirement (https://www.w3.org/TR/trace-context/#tracestate-field). + * + * Here is the list of allowed mutations: + * - New key-value pair should be added into the beginning of the list + * - The value of any key can be updated. Modified keys MUST be moved to the + * beginning of the list. + */ +export declare class TraceStateImpl implements TraceState { + private _internalState; + constructor(rawTraceState?: string); + set(key: string, value: string): TraceStateImpl; + unset(key: string): TraceStateImpl; + get(key: string): string | undefined; + serialize(): string; + private _parse; + private _keys; + private _clone; +} +//# sourceMappingURL=tracestate-impl.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js new file mode 100644 index 000000000..93c0289c1 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-impl.js @@ -0,0 +1,103 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TraceStateImpl = void 0; +const tracestate_validators_1 = require("./tracestate-validators"); +const MAX_TRACE_STATE_ITEMS = 32; +const MAX_TRACE_STATE_LEN = 512; +const LIST_MEMBERS_SEPARATOR = ','; +const LIST_MEMBER_KEY_VALUE_SPLITTER = '='; +/** + * TraceState must be a class and not a simple object type because of the spec + * requirement (https://www.w3.org/TR/trace-context/#tracestate-field). + * + * Here is the list of allowed mutations: + * - New key-value pair should be added into the beginning of the list + * - The value of any key can be updated. Modified keys MUST be moved to the + * beginning of the list. + */ +class TraceStateImpl { + constructor(rawTraceState) { + this._internalState = new Map(); + if (rawTraceState) + this._parse(rawTraceState); + } + set(key, value) { + // TODO: Benchmark the different approaches(map vs list) and + // use the faster one. + const traceState = this._clone(); + if (traceState._internalState.has(key)) { + traceState._internalState.delete(key); + } + traceState._internalState.set(key, value); + return traceState; + } + unset(key) { + const traceState = this._clone(); + traceState._internalState.delete(key); + return traceState; + } + get(key) { + return this._internalState.get(key); + } + serialize() { + return this._keys() + .reduce((agg, key) => { + agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + this.get(key)); + return agg; + }, []) + .join(LIST_MEMBERS_SEPARATOR); + } + _parse(rawTraceState) { + if (rawTraceState.length > MAX_TRACE_STATE_LEN) + return; + this._internalState = rawTraceState + .split(LIST_MEMBERS_SEPARATOR) + .reverse() // Store in reverse so new keys (.set(...)) will be placed at the beginning + .reduce((agg, part) => { + const listMember = part.trim(); // Optional Whitespace (OWS) handling + const i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER); + if (i !== -1) { + const key = listMember.slice(0, i); + const value = listMember.slice(i + 1, part.length); + if ((0, tracestate_validators_1.validateKey)(key) && (0, tracestate_validators_1.validateValue)(value)) { + agg.set(key, value); + } + else { + // TODO: Consider to add warning log + } + } + return agg; + }, new Map()); + // Because of the reverse() requirement, trunc must be done after map is created + if (this._internalState.size > MAX_TRACE_STATE_ITEMS) { + this._internalState = new Map(Array.from(this._internalState.entries()) + .reverse() // Use reverse same as original tracestate parse chain + .slice(0, MAX_TRACE_STATE_ITEMS)); + } + } + _keys() { + return Array.from(this._internalState.keys()).reverse(); + } + _clone() { + const traceState = new TraceStateImpl(); + traceState._internalState = new Map(this._internalState); + return traceState; + } +} +exports.TraceStateImpl = TraceStateImpl; +//# sourceMappingURL=tracestate-impl.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.d.ts new file mode 100644 index 000000000..4917f99d1 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.d.ts @@ -0,0 +1,15 @@ +/** + * Key is opaque string up to 256 characters printable. It MUST begin with a + * lowercase letter, and can only contain lowercase letters a-z, digits 0-9, + * underscores _, dashes -, asterisks *, and forward slashes /. + * For multi-tenant vendor scenarios, an at sign (@) can be used to prefix the + * vendor name. Vendors SHOULD set the tenant ID at the beginning of the key. + * see https://www.w3.org/TR/trace-context/#key + */ +export declare function validateKey(key: string): boolean; +/** + * Value is opaque string up to 256 characters printable ASCII RFC0020 + * characters (i.e., the range 0x20 to 0x7E) except comma , and =. + */ +export declare function validateValue(value: string): boolean; +//# sourceMappingURL=tracestate-validators.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js new file mode 100644 index 000000000..3e370449b --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/tracestate-validators.js @@ -0,0 +1,46 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.validateValue = exports.validateKey = void 0; +const VALID_KEY_CHAR_RANGE = '[_0-9a-z-*/]'; +const VALID_KEY = `[a-z]${VALID_KEY_CHAR_RANGE}{0,255}`; +const VALID_VENDOR_KEY = `[a-z0-9]${VALID_KEY_CHAR_RANGE}{0,240}@[a-z]${VALID_KEY_CHAR_RANGE}{0,13}`; +const VALID_KEY_REGEX = new RegExp(`^(?:${VALID_KEY}|${VALID_VENDOR_KEY})$`); +const VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/; +const INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/; +/** + * Key is opaque string up to 256 characters printable. It MUST begin with a + * lowercase letter, and can only contain lowercase letters a-z, digits 0-9, + * underscores _, dashes -, asterisks *, and forward slashes /. + * For multi-tenant vendor scenarios, an at sign (@) can be used to prefix the + * vendor name. Vendors SHOULD set the tenant ID at the beginning of the key. + * see https://www.w3.org/TR/trace-context/#key + */ +function validateKey(key) { + return VALID_KEY_REGEX.test(key); +} +exports.validateKey = validateKey; +/** + * Value is opaque string up to 256 characters printable ASCII RFC0020 + * characters (i.e., the range 0x20 to 0x7E) except comma , and =. + */ +function validateValue(value) { + return (VALID_VALUE_BASE_REGEX.test(value) && + !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value)); +} +exports.validateValue = validateValue; +//# sourceMappingURL=tracestate-validators.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/utils.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/utils.d.ts new file mode 100644 index 000000000..e3b51fe45 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/utils.d.ts @@ -0,0 +1,3 @@ +import { TraceState } from '../trace_state'; +export declare function createTraceState(rawTraceState?: string): TraceState; +//# sourceMappingURL=utils.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/utils.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/utils.js new file mode 100644 index 000000000..3d954190b --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/internal/utils.js @@ -0,0 +1,24 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createTraceState = void 0; +const tracestate_impl_1 = require("./tracestate-impl"); +function createTraceState(rawTraceState) { + return new tracestate_impl_1.TraceStateImpl(rawTraceState); +} +exports.createTraceState = createTraceState; +//# sourceMappingURL=utils.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.d.ts new file mode 100644 index 000000000..e32dab9d6 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.d.ts @@ -0,0 +1,5 @@ +import { SpanContext } from './span_context'; +export declare const INVALID_SPANID = "0000000000000000"; +export declare const INVALID_TRACEID = "00000000000000000000000000000000"; +export declare const INVALID_SPAN_CONTEXT: SpanContext; +//# sourceMappingURL=invalid-span-constants.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js new file mode 100644 index 000000000..77fb79e97 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/invalid-span-constants.js @@ -0,0 +1,27 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.INVALID_SPAN_CONTEXT = exports.INVALID_TRACEID = exports.INVALID_SPANID = void 0; +const trace_flags_1 = require("./trace_flags"); +exports.INVALID_SPANID = '0000000000000000'; +exports.INVALID_TRACEID = '00000000000000000000000000000000'; +exports.INVALID_SPAN_CONTEXT = { + traceId: exports.INVALID_TRACEID, + spanId: exports.INVALID_SPANID, + traceFlags: trace_flags_1.TraceFlags.NONE, +}; +//# sourceMappingURL=invalid-span-constants.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/link.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/link.d.ts new file mode 100644 index 000000000..8fc010627 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/link.d.ts @@ -0,0 +1,26 @@ +import { SpanAttributes } from './attributes'; +import { SpanContext } from './span_context'; +/** + * A pointer from the current {@link Span} to another span in the same trace or + * in a different trace. + * Few examples of Link usage. + * 1. Batch Processing: A batch of elements may contain elements associated + * with one or more traces/spans. Since there can only be one parent + * SpanContext, Link is used to keep reference to SpanContext of all + * elements in the batch. + * 2. Public Endpoint: A SpanContext in incoming client request on a public + * endpoint is untrusted from service provider perspective. In such case it + * is advisable to start a new trace with appropriate sampling decision. + * However, it is desirable to associate incoming SpanContext to new trace + * initiated on service provider side so two traces (from Client and from + * Service Provider) can be correlated. + */ +export interface Link { + /** The {@link SpanContext} of a linked span. */ + context: SpanContext; + /** A set of {@link SpanAttributes} on the link. */ + attributes?: SpanAttributes; + /** Count of attributes of the link that were dropped due to collection limits */ + droppedAttributesCount?: number; +} +//# sourceMappingURL=link.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/link.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/link.js new file mode 100644 index 000000000..8036a6346 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/link.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=link.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span.d.ts new file mode 100644 index 000000000..28c6442db --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span.d.ts @@ -0,0 +1,120 @@ +import { Exception } from '../common/Exception'; +import { TimeInput } from '../common/Time'; +import { SpanAttributes, SpanAttributeValue } from './attributes'; +import { SpanContext } from './span_context'; +import { SpanStatus } from './status'; +import { Link } from './link'; +/** + * An interface that represents a span. A span represents a single operation + * within a trace. Examples of span might include remote procedure calls or a + * in-process function calls to sub-components. A Trace has a single, top-level + * "root" Span that in turn may have zero or more child Spans, which in turn + * may have children. + * + * Spans are created by the {@link Tracer.startSpan} method. + */ +export interface Span { + /** + * Returns the {@link SpanContext} object associated with this Span. + * + * Get an immutable, serializable identifier for this span that can be used + * to create new child spans. Returned SpanContext is usable even after the + * span ends. + * + * @returns the SpanContext object associated with this Span. + */ + spanContext(): SpanContext; + /** + * Sets an attribute to the span. + * + * Sets a single Attribute with the key and value passed as arguments. + * + * @param key the key for this attribute. + * @param value the value for this attribute. Setting a value null or + * undefined is invalid and will result in undefined behavior. + */ + setAttribute(key: string, value: SpanAttributeValue): this; + /** + * Sets attributes to the span. + * + * @param attributes the attributes that will be added. + * null or undefined attribute values + * are invalid and will result in undefined behavior. + */ + setAttributes(attributes: SpanAttributes): this; + /** + * Adds an event to the Span. + * + * @param name the name of the event. + * @param [attributesOrStartTime] the attributes that will be added; these are + * associated with this event. Can be also a start time + * if type is {@type TimeInput} and 3rd param is undefined + * @param [startTime] start time of the event. + */ + addEvent(name: string, attributesOrStartTime?: SpanAttributes | TimeInput, startTime?: TimeInput): this; + /** + * Adds a single link to the span. + * + * Links added after the creation will not affect the sampling decision. + * It is preferred span links be added at span creation. + * + * @param link the link to add. + */ + addLink(link: Link): this; + /** + * Adds multiple links to the span. + * + * Links added after the creation will not affect the sampling decision. + * It is preferred span links be added at span creation. + * + * @param links the links to add. + */ + addLinks(links: Link[]): this; + /** + * Sets a status to the span. If used, this will override the default Span + * status. Default is {@link SpanStatusCode.UNSET}. SetStatus overrides the value + * of previous calls to SetStatus on the Span. + * + * @param status the SpanStatus to set. + */ + setStatus(status: SpanStatus): this; + /** + * Updates the Span name. + * + * This will override the name provided via {@link Tracer.startSpan}. + * + * Upon this update, any sampling behavior based on Span name will depend on + * the implementation. + * + * @param name the Span name. + */ + updateName(name: string): this; + /** + * Marks the end of Span execution. + * + * Call to End of a Span MUST not have any effects on child spans. Those may + * still be running and can be ended later. + * + * Do not return `this`. The Span generally should not be used after it + * is ended so chaining is not desired in this context. + * + * @param [endTime] the time to set as Span's end time. If not provided, + * use the current time as the span's end time. + */ + end(endTime?: TimeInput): void; + /** + * Returns the flag whether this span will be recorded. + * + * @returns true if this Span is active and recording information like events + * with the `AddEvent` operation and attributes using `setAttributes`. + */ + isRecording(): boolean; + /** + * Sets exception as a span event + * @param exception the exception the only accepted values are string or Error + * @param [time] the time to set as Span's event time. If not provided, + * use the current time. + */ + recordException(exception: Exception, time?: TimeInput): void; +} +//# sourceMappingURL=span.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span.js new file mode 100644 index 000000000..b50af4627 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=span.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_context.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_context.d.ts new file mode 100644 index 000000000..f30933a1f --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_context.d.ts @@ -0,0 +1,53 @@ +import { TraceState } from './trace_state'; +/** + * A SpanContext represents the portion of a {@link Span} which must be + * serialized and propagated along side of a {@link Baggage}. + */ +export interface SpanContext { + /** + * The ID of the trace that this span belongs to. It is worldwide unique + * with practically sufficient probability by being made as 16 randomly + * generated bytes, encoded as a 32 lowercase hex characters corresponding to + * 128 bits. + */ + traceId: string; + /** + * The ID of the Span. It is globally unique with practically sufficient + * probability by being made as 8 randomly generated bytes, encoded as a 16 + * lowercase hex characters corresponding to 64 bits. + */ + spanId: string; + /** + * Only true if the SpanContext was propagated from a remote parent. + */ + isRemote?: boolean; + /** + * Trace flags to propagate. + * + * It is represented as 1 byte (bitmap). Bit to represent whether trace is + * sampled or not. When set, the least significant bit documents that the + * caller may have recorded trace data. A caller who does not record trace + * data out-of-band leaves this flag unset. + * + * see {@link TraceFlags} for valid flag values. + */ + traceFlags: number; + /** + * Tracing-system-specific info to propagate. + * + * The tracestate field value is a `list` as defined below. The `list` is a + * series of `list-members` separated by commas `,`, and a list-member is a + * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs + * surrounding `list-members` are ignored. There can be a maximum of 32 + * `list-members` in a `list`. + * More Info: https://www.w3.org/TR/trace-context/#tracestate-field + * + * Examples: + * Single tracing system (generic format): + * tracestate: rojo=00f067aa0ba902b7 + * Multiple tracing systems (with different formatting): + * tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE + */ + traceState?: TraceState; +} +//# sourceMappingURL=span_context.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_context.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_context.js new file mode 100644 index 000000000..4b7976ce7 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_context.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=span_context.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_kind.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_kind.d.ts new file mode 100644 index 000000000..a89846f65 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_kind.d.ts @@ -0,0 +1,27 @@ +export declare enum SpanKind { + /** Default value. Indicates that the span is used internally. */ + INTERNAL = 0, + /** + * Indicates that the span covers server-side handling of an RPC or other + * remote request. + */ + SERVER = 1, + /** + * Indicates that the span covers the client-side wrapper around an RPC or + * other remote request. + */ + CLIENT = 2, + /** + * Indicates that the span describes producer sending a message to a + * broker. Unlike client and server, there is no direct critical path latency + * relationship between producer and consumer spans. + */ + PRODUCER = 3, + /** + * Indicates that the span describes consumer receiving a message from a + * broker. Unlike client and server, there is no direct critical path latency + * relationship between producer and consumer spans. + */ + CONSUMER = 4 +} +//# sourceMappingURL=span_kind.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_kind.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_kind.js new file mode 100644 index 000000000..9c06e2c25 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/span_kind.js @@ -0,0 +1,46 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SpanKind = void 0; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var SpanKind; +(function (SpanKind) { + /** Default value. Indicates that the span is used internally. */ + SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL"; + /** + * Indicates that the span covers server-side handling of an RPC or other + * remote request. + */ + SpanKind[SpanKind["SERVER"] = 1] = "SERVER"; + /** + * Indicates that the span covers the client-side wrapper around an RPC or + * other remote request. + */ + SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT"; + /** + * Indicates that the span describes producer sending a message to a + * broker. Unlike client and server, there is no direct critical path latency + * relationship between producer and consumer spans. + */ + SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER"; + /** + * Indicates that the span describes consumer receiving a message from a + * broker. Unlike client and server, there is no direct critical path latency + * relationship between producer and consumer spans. + */ + SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER"; +})(SpanKind = exports.SpanKind || (exports.SpanKind = {})); +//# sourceMappingURL=span_kind.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.d.ts new file mode 100644 index 000000000..f19111148 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.d.ts @@ -0,0 +1,17 @@ +import { Span } from './span'; +import { SpanContext } from './span_context'; +export declare function isValidTraceId(traceId: string): boolean; +export declare function isValidSpanId(spanId: string): boolean; +/** + * Returns true if this {@link SpanContext} is valid. + * @return true if this {@link SpanContext} is valid. + */ +export declare function isSpanContextValid(spanContext: SpanContext): boolean; +/** + * Wrap the given {@link SpanContext} in a new non-recording {@link Span} + * + * @param spanContext span context to be wrapped + * @returns a new non-recording {@link Span} with the provided context + */ +export declare function wrapSpanContext(spanContext: SpanContext): Span; +//# sourceMappingURL=spancontext-utils.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js new file mode 100644 index 000000000..dc88f5e6f --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/spancontext-utils.js @@ -0,0 +1,49 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.wrapSpanContext = exports.isSpanContextValid = exports.isValidSpanId = exports.isValidTraceId = void 0; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +const invalid_span_constants_1 = require("./invalid-span-constants"); +const NonRecordingSpan_1 = require("./NonRecordingSpan"); +const VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i; +const VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i; +function isValidTraceId(traceId) { + return VALID_TRACEID_REGEX.test(traceId) && traceId !== invalid_span_constants_1.INVALID_TRACEID; +} +exports.isValidTraceId = isValidTraceId; +function isValidSpanId(spanId) { + return VALID_SPANID_REGEX.test(spanId) && spanId !== invalid_span_constants_1.INVALID_SPANID; +} +exports.isValidSpanId = isValidSpanId; +/** + * Returns true if this {@link SpanContext} is valid. + * @return true if this {@link SpanContext} is valid. + */ +function isSpanContextValid(spanContext) { + return (isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId)); +} +exports.isSpanContextValid = isSpanContextValid; +/** + * Wrap the given {@link SpanContext} in a new non-recording {@link Span} + * + * @param spanContext span context to be wrapped + * @returns a new non-recording {@link Span} with the provided context + */ +function wrapSpanContext(spanContext) { + return new NonRecordingSpan_1.NonRecordingSpan(spanContext); +} +exports.wrapSpanContext = wrapSpanContext; +//# sourceMappingURL=spancontext-utils.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/status.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/status.d.ts new file mode 100644 index 000000000..ab19a68f7 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/status.d.ts @@ -0,0 +1,25 @@ +export interface SpanStatus { + /** The status code of this message. */ + code: SpanStatusCode; + /** A developer-facing error message. */ + message?: string; +} +/** + * An enumeration of status codes. + */ +export declare enum SpanStatusCode { + /** + * The default status. + */ + UNSET = 0, + /** + * The operation has been validated by an Application developer or + * Operator to have completed successfully. + */ + OK = 1, + /** + * The operation contains an error. + */ + ERROR = 2 +} +//# sourceMappingURL=status.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/status.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/status.js new file mode 100644 index 000000000..50cbdef8e --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/status.js @@ -0,0 +1,23 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SpanStatusCode = void 0; +/** + * An enumeration of status codes. + */ +var SpanStatusCode; +(function (SpanStatusCode) { + /** + * The default status. + */ + SpanStatusCode[SpanStatusCode["UNSET"] = 0] = "UNSET"; + /** + * The operation has been validated by an Application developer or + * Operator to have completed successfully. + */ + SpanStatusCode[SpanStatusCode["OK"] = 1] = "OK"; + /** + * The operation contains an error. + */ + SpanStatusCode[SpanStatusCode["ERROR"] = 2] = "ERROR"; +})(SpanStatusCode = exports.SpanStatusCode || (exports.SpanStatusCode = {})); +//# sourceMappingURL=status.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_flags.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_flags.d.ts new file mode 100644 index 000000000..11288ba95 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_flags.d.ts @@ -0,0 +1,7 @@ +export declare enum TraceFlags { + /** Represents no flag set. */ + NONE = 0, + /** Bit to represent whether trace is sampled in trace flags. */ + SAMPLED = 1 +} +//# sourceMappingURL=trace_flags.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_flags.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_flags.js new file mode 100644 index 000000000..f8d4dd8a9 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_flags.js @@ -0,0 +1,26 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.TraceFlags = void 0; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var TraceFlags; +(function (TraceFlags) { + /** Represents no flag set. */ + TraceFlags[TraceFlags["NONE"] = 0] = "NONE"; + /** Bit to represent whether trace is sampled in trace flags. */ + TraceFlags[TraceFlags["SAMPLED"] = 1] = "SAMPLED"; +})(TraceFlags = exports.TraceFlags || (exports.TraceFlags = {})); +//# sourceMappingURL=trace_flags.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_state.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_state.d.ts new file mode 100644 index 000000000..f275b8bed --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_state.d.ts @@ -0,0 +1,38 @@ +export interface TraceState { + /** + * Create a new TraceState which inherits from this TraceState and has the + * given key set. + * The new entry will always be added in the front of the list of states. + * + * @param key key of the TraceState entry. + * @param value value of the TraceState entry. + */ + set(key: string, value: string): TraceState; + /** + * Return a new TraceState which inherits from this TraceState but does not + * contain the given key. + * + * @param key the key for the TraceState entry to be removed. + */ + unset(key: string): TraceState; + /** + * Returns the value to which the specified key is mapped, or `undefined` if + * this map contains no mapping for the key. + * + * @param key with which the specified value is to be associated. + * @returns the value to which the specified key is mapped, or `undefined` if + * this map contains no mapping for the key. + */ + get(key: string): string | undefined; + /** + * Serializes the TraceState to a `list` as defined below. The `list` is a + * series of `list-members` separated by commas `,`, and a list-member is a + * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs + * surrounding `list-members` are ignored. There can be a maximum of 32 + * `list-members` in a `list`. + * + * @returns the serialized string. + */ + serialize(): string; +} +//# sourceMappingURL=trace_state.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_state.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_state.js new file mode 100644 index 000000000..139703815 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/trace_state.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=trace_state.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer.d.ts new file mode 100644 index 000000000..25090899e --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer.d.ts @@ -0,0 +1,71 @@ +import { Context } from '../context/types'; +import { Span } from './span'; +import { SpanOptions } from './SpanOptions'; +/** + * Tracer provides an interface for creating {@link Span}s. + */ +export interface Tracer { + /** + * Starts a new {@link Span}. Start the span without setting it on context. + * + * This method do NOT modify the current Context. + * + * @param name The name of the span + * @param [options] SpanOptions used for span creation + * @param [context] Context to use to extract parent + * @returns Span The newly created span + * @example + * const span = tracer.startSpan('op'); + * span.setAttribute('key', 'value'); + * span.end(); + */ + startSpan(name: string, options?: SpanOptions, context?: Context): Span; + /** + * Starts a new {@link Span} and calls the given function passing it the + * created span as first argument. + * Additionally the new span gets set in context and this context is activated + * for the duration of the function call. + * + * @param name The name of the span + * @param [options] SpanOptions used for span creation + * @param [context] Context to use to extract parent + * @param fn function called in the context of the span and receives the newly created span as an argument + * @returns return value of fn + * @example + * const something = tracer.startActiveSpan('op', span => { + * try { + * do some work + * span.setStatus({code: SpanStatusCode.OK}); + * return something; + * } catch (err) { + * span.setStatus({ + * code: SpanStatusCode.ERROR, + * message: err.message, + * }); + * throw err; + * } finally { + * span.end(); + * } + * }); + * + * @example + * const span = tracer.startActiveSpan('op', span => { + * try { + * do some work + * return span; + * } catch (err) { + * span.setStatus({ + * code: SpanStatusCode.ERROR, + * message: err.message, + * }); + * throw err; + * } + * }); + * do some more work + * span.end(); + */ + startActiveSpan unknown>(name: string, fn: F): ReturnType; + startActiveSpan unknown>(name: string, options: SpanOptions, fn: F): ReturnType; + startActiveSpan unknown>(name: string, options: SpanOptions, context: Context, fn: F): ReturnType; +} +//# sourceMappingURL=tracer.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer.js new file mode 100644 index 000000000..d710ef9ac --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=tracer.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_options.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_options.d.ts new file mode 100644 index 000000000..f3bbccfc2 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_options.d.ts @@ -0,0 +1,10 @@ +/** + * An interface describes additional metadata of a tracer. + */ +export interface TracerOptions { + /** + * The schemaUrl of the tracer or instrumentation library + */ + schemaUrl?: string; +} +//# sourceMappingURL=tracer_options.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_options.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_options.js new file mode 100644 index 000000000..3547251a2 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_options.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=tracer_options.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_provider.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_provider.d.ts new file mode 100644 index 000000000..9b2f7a954 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_provider.d.ts @@ -0,0 +1,21 @@ +import { Tracer } from './tracer'; +import { TracerOptions } from './tracer_options'; +/** + * A registry for creating named {@link Tracer}s. + */ +export interface TracerProvider { + /** + * Returns a Tracer, creating one if one with the given name and version is + * not already created. + * + * This function may return different Tracer types (e.g. + * {@link NoopTracerProvider} vs. a functional tracer). + * + * @param name The name of the tracer or instrumentation library. + * @param version The version of the tracer or instrumentation library. + * @param options The options of the tracer or instrumentation library. + * @returns Tracer A Tracer with the given name and version + */ + getTracer(name: string, version?: string, options?: TracerOptions): Tracer; +} +//# sourceMappingURL=tracer_provider.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_provider.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_provider.js new file mode 100644 index 000000000..4c511db95 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/trace/tracer_provider.js @@ -0,0 +1,18 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=tracer_provider.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/version.d.ts b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/version.d.ts new file mode 100644 index 000000000..40f036592 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/version.d.ts @@ -0,0 +1,2 @@ +export declare const VERSION = "1.9.0"; +//# sourceMappingURL=version.d.ts.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/version.js b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/version.js new file mode 100644 index 000000000..3c7179413 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/build/src/version.js @@ -0,0 +1,21 @@ +"use strict"; +/* + * Copyright The OpenTelemetry Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +Object.defineProperty(exports, "__esModule", { value: true }); +exports.VERSION = void 0; +// this is autogenerated file, see scripts/version-update.js +exports.VERSION = '1.9.0'; +//# sourceMappingURL=version.js.map \ No newline at end of file diff --git a/tests/fixtures/npm/node_modules/@opentelemetry/api/package.json b/tests/fixtures/npm/node_modules/@opentelemetry/api/package.json new file mode 100644 index 000000000..f7ba45f96 --- /dev/null +++ b/tests/fixtures/npm/node_modules/@opentelemetry/api/package.json @@ -0,0 +1,113 @@ +{ + "name": "@opentelemetry/api", + "version": "1.9.0", + "description": "Public API for OpenTelemetry", + "main": "build/src/index.js", + "module": "build/esm/index.js", + "esnext": "build/esnext/index.js", + "types": "build/src/index.d.ts", + "browser": { + "./src/platform/index.ts": "./src/platform/browser/index.ts", + "./build/esm/platform/index.js": "./build/esm/platform/browser/index.js", + "./build/esnext/platform/index.js": "./build/esnext/platform/browser/index.js", + "./build/src/platform/index.js": "./build/src/platform/browser/index.js" + }, + "exports": { + ".": { + "module": "./build/esm/index.js", + "esnext": "./build/esnext/index.js", + "types": "./build/src/index.d.ts", + "default": "./build/src/index.js" + }, + "./experimental": { + "module": "./build/esm/experimental/index.js", + "esnext": "./build/esnext/experimental/index.js", + "types": "./build/src/experimental/index.d.ts", + "default": "./build/src/experimental/index.js" + } + }, + "repository": "open-telemetry/opentelemetry-js", + "scripts": { + "clean": "tsc --build --clean tsconfig.json tsconfig.esm.json tsconfig.esnext.json", + "codecov:browser": "nyc report --reporter=json && codecov -f coverage/*.json -p ../", + "codecov:webworker": "nyc report --reporter=json && codecov -f coverage/*.json -p ../", + "codecov": "nyc report --reporter=json && codecov -f coverage/*.json -p ../", + "precompile": "cross-var lerna run version --scope $npm_package_name --include-dependencies", + "compile": "tsc --build tsconfig.json tsconfig.esm.json tsconfig.esnext.json", + "docs": "typedoc", + "docs:deploy": "gh-pages --dist docs/out", + "docs:test": "linkinator docs/out --silent && linkinator docs/*.md *.md --markdown --silent", + "lint:fix": "eslint . --ext .ts --fix", + "lint": "eslint . --ext .ts", + "test:browser": "karma start --single-run", + "test": "nyc ts-mocha -p tsconfig.json 'test/**/*.test.ts'", + "test:eol": "ts-mocha -p tsconfig.json 'test/**/*.test.ts'", + "test:webworker": "karma start karma.worker.js --single-run", + "cycle-check": "dpdm --exit-code circular:1 src/index.ts", + "version": "node ../scripts/version-update.js", + "prewatch": "npm run precompile", + "watch": "tsc --build --watch tsconfig.json tsconfig.esm.json tsconfig.esnext.json", + "peer-api-check": "node ../scripts/peer-api-check.js" + }, + "keywords": [ + "opentelemetry", + "nodejs", + "browser", + "tracing", + "profiling", + "stats", + "monitoring" + ], + "author": "OpenTelemetry Authors", + "license": "Apache-2.0", + "engines": { + "node": ">=8.0.0" + }, + "files": [ + "build/esm/**/*.js", + "build/esm/**/*.js.map", + "build/esm/**/*.d.ts", + "build/esnext/**/*.js", + "build/esnext/**/*.js.map", + "build/esnext/**/*.d.ts", + "build/src/**/*.js", + "build/src/**/*.js.map", + "build/src/**/*.d.ts", + "LICENSE", + "README.md" + ], + "publishConfig": { + "access": "public" + }, + "devDependencies": { + "@types/mocha": "10.0.6", + "@types/node": "18.6.5", + "@types/sinon": "17.0.3", + "@types/webpack": "5.28.5", + "@types/webpack-env": "1.16.3", + "babel-plugin-istanbul": "6.1.1", + "codecov": "3.8.3", + "cross-var": "1.1.0", + "dpdm": "3.13.1", + "karma": "6.4.3", + "karma-chrome-launcher": "3.1.0", + "karma-coverage": "2.2.1", + "karma-mocha": "2.0.1", + "karma-mocha-webworker": "1.3.0", + "karma-spec-reporter": "0.0.36", + "karma-webpack": "5.0.1", + "lerna": "6.6.2", + "memfs": "3.5.3", + "mocha": "10.2.0", + "nyc": "15.1.0", + "sinon": "15.1.2", + "ts-loader": "9.5.1", + "ts-mocha": "10.0.0", + "typescript": "4.4.4", + "unionfs": "4.5.4", + "webpack": "5.89.0" + }, + "homepage": "https://github.com/open-telemetry/opentelemetry-js/tree/main/api", + "sideEffects": false, + "gitHead": "c4d3351b6b3f5593c8d7cbfec97b45cea9fe1511" +}