tabletcommand-logger 3.2.7 → 4.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.cspell/project-words.txt +28 -0
- package/CLAUDE.md +150 -0
- package/README.md +111 -1
- package/build/index.js +11 -3
- package/build/index.js.map +1 -1
- package/build/logger-types.js +3 -0
- package/build/logger-types.js.map +1 -0
- package/build/middleware/logger.js +94 -149
- package/build/middleware/logger.js.map +1 -1
- package/build/middleware/status-logger.js.map +1 -1
- package/build/otel.js +54 -0
- package/build/otel.js.map +1 -0
- package/build/pino-logger.js +97 -0
- package/build/pino-logger.js.map +1 -0
- package/build/redaction.js +351 -0
- package/build/redaction.js.map +1 -0
- package/build/test/logger-factory.js +207 -0
- package/build/test/logger-factory.js.map +1 -0
- package/build/test/middleware-logger.js +282 -0
- package/build/test/middleware-logger.js.map +1 -1
- package/build/test/middleware-status-logger.js.map +1 -1
- package/build/test/otel-mixin.js +139 -0
- package/build/test/otel-mixin.js.map +1 -0
- package/build/test/redaction.js +293 -0
- package/build/test/redaction.js.map +1 -0
- package/build/test/signature.js +111 -0
- package/build/test/signature.js.map +1 -0
- package/build/winston-logger.js +18 -47
- package/build/winston-logger.js.map +1 -1
- package/definitions/index.d.ts +5 -2
- package/definitions/index.d.ts.map +1 -1
- package/definitions/logger-types.d.ts +38 -0
- package/definitions/logger-types.d.ts.map +1 -0
- package/definitions/middleware/logger.d.ts +4 -6
- package/definitions/middleware/logger.d.ts.map +1 -1
- package/definitions/middleware/status-logger.d.ts +2 -2
- package/definitions/middleware/status-logger.d.ts.map +1 -1
- package/definitions/otel.d.ts +8 -0
- package/definitions/otel.d.ts.map +1 -0
- package/definitions/pino-logger.d.ts +6 -0
- package/definitions/pino-logger.d.ts.map +1 -0
- package/definitions/redaction.d.ts +25 -0
- package/definitions/redaction.d.ts.map +1 -0
- package/definitions/test/logger-factory.d.ts +2 -0
- package/definitions/test/logger-factory.d.ts.map +1 -0
- package/definitions/test/otel-mixin.d.ts +2 -0
- package/definitions/test/otel-mixin.d.ts.map +1 -0
- package/definitions/test/redaction.d.ts +2 -0
- package/definitions/test/redaction.d.ts.map +1 -0
- package/definitions/test/signature.d.ts +2 -0
- package/definitions/test/signature.d.ts.map +1 -0
- package/definitions/winston-logger.d.ts +2 -13
- package/definitions/winston-logger.d.ts.map +1 -1
- package/eslint.config.mjs +1 -0
- package/package.json +17 -5
- package/src/index.ts +6 -3
- package/src/logger-types.ts +50 -0
- package/src/middleware/logger.ts +101 -164
- package/src/middleware/status-logger.ts +2 -4
- package/src/otel.ts +57 -0
- package/src/pino-logger.ts +110 -0
- package/src/redaction.ts +368 -0
- package/src/test/logger-factory.ts +216 -0
- package/src/test/middleware-logger.ts +321 -2
- package/src/test/middleware-status-logger.ts +2 -2
- package/src/test/otel-mixin.ts +119 -0
- package/src/test/redaction.ts +409 -0
- package/src/test/signature.ts +126 -0
- package/src/winston-logger.ts +2 -72
- package/tabletcommand-logger-4.0.0.tgz +0 -0
|
@@ -1,9 +1,12 @@
|
|
|
1
1
|
import { assert } from "chai";
|
|
2
2
|
import { EventEmitter } from "node:events";
|
|
3
|
+
import http from "node:http";
|
|
3
4
|
import { describe, it, describe as context } from "node:test";
|
|
5
|
+
import { Writable } from "node:stream";
|
|
4
6
|
import { Request, Response } from "express";
|
|
5
|
-
import {
|
|
7
|
+
import { StrictLogger } from "../logger-types";
|
|
6
8
|
import loggerMiddleware, { redactHeaders, redactOriginalURL, redactQuery } from "../middleware/logger";
|
|
9
|
+
import logger from "../pino-logger";
|
|
7
10
|
|
|
8
11
|
// cspell:ignore tcmobile
|
|
9
12
|
|
|
@@ -64,6 +67,28 @@ describe("Logger Middleware", function() {
|
|
|
64
67
|
assert.deepEqual(sut, { cookie: "" });
|
|
65
68
|
});
|
|
66
69
|
|
|
70
|
+
it("redacts set-cookie header leaving attributes intact", function() {
|
|
71
|
+
const sutString = redactHeaders({
|
|
72
|
+
"set-cookie": "session=SECRET_TOKEN; Path=/; Domain=.tabletcommand.com; Max-Age=3600; HttpOnly; Secure; SameSite=None",
|
|
73
|
+
} as unknown as Request["headers"]);
|
|
74
|
+
assert.deepEqual(sutString, {
|
|
75
|
+
"set-cookie": "session=<redacted>; Path=/; Domain=.tabletcommand.com; Max-Age=3600; HttpOnly; Secure; SameSite=None",
|
|
76
|
+
} as unknown as Request["headers"]);
|
|
77
|
+
|
|
78
|
+
const sutArray = redactHeaders({
|
|
79
|
+
"set-cookie": [
|
|
80
|
+
"session=SECRET123; Path=/; HttpOnly; Secure; SameSite=None",
|
|
81
|
+
"remember=VAL456; Path=/; HttpOnly",
|
|
82
|
+
],
|
|
83
|
+
});
|
|
84
|
+
assert.deepEqual(sutArray, {
|
|
85
|
+
"set-cookie": [
|
|
86
|
+
"session=<redacted>; Path=/; HttpOnly; Secure; SameSite=None",
|
|
87
|
+
"remember=<redacted>; Path=/; HttpOnly",
|
|
88
|
+
],
|
|
89
|
+
});
|
|
90
|
+
});
|
|
91
|
+
|
|
67
92
|
it("matches the header name without case", function() {
|
|
68
93
|
const sut = redactHeaders({
|
|
69
94
|
Cookie: `seneca-login=${sample}`,
|
|
@@ -262,7 +287,7 @@ describe("Logger Middleware", function() {
|
|
|
262
287
|
info: (msg: Record<string, unknown>) => {
|
|
263
288
|
line = msg;
|
|
264
289
|
},
|
|
265
|
-
} as unknown as
|
|
290
|
+
} as unknown as StrictLogger;
|
|
266
291
|
const res = new EventEmitter() as unknown as Response;
|
|
267
292
|
res.statusCode = 200;
|
|
268
293
|
|
|
@@ -287,4 +312,298 @@ describe("Logger Middleware", function() {
|
|
|
287
312
|
});
|
|
288
313
|
});
|
|
289
314
|
});
|
|
315
|
+
|
|
316
|
+
context("pino-http integration with real logger", () => {
|
|
317
|
+
it("redacts response set-cookie and authorization headers (H1)", async () => {
|
|
318
|
+
const lines: Record<string, unknown>[] = [];
|
|
319
|
+
const capture = new Writable({
|
|
320
|
+
write(chunk: Buffer | string, _encoding: string, callback: (error?: Error | null) => void) {
|
|
321
|
+
try {
|
|
322
|
+
lines.push(JSON.parse(chunk.toString()) as Record<string, unknown>);
|
|
323
|
+
} catch {
|
|
324
|
+
// ignore
|
|
325
|
+
}
|
|
326
|
+
callback();
|
|
327
|
+
},
|
|
328
|
+
});
|
|
329
|
+
|
|
330
|
+
const log = logger({ name: "test-response-redaction" }, capture);
|
|
331
|
+
const middleware = loggerMiddleware(log as StrictLogger);
|
|
332
|
+
|
|
333
|
+
const server = http.createServer((req, res) => {
|
|
334
|
+
middleware(req as unknown as Request, res as unknown as Response, () => {
|
|
335
|
+
res.setHeader(
|
|
336
|
+
"set-cookie",
|
|
337
|
+
"session=SECRET; Path=/; Domain=.tabletcommand.com; Max-Age=3600; HttpOnly; Secure; SameSite=None"
|
|
338
|
+
);
|
|
339
|
+
res.setHeader("authorization", "Bearer SECRET12345");
|
|
340
|
+
res.statusCode = 200;
|
|
341
|
+
res.end("ok");
|
|
342
|
+
});
|
|
343
|
+
});
|
|
344
|
+
|
|
345
|
+
await new Promise<void>((resolve, reject) => {
|
|
346
|
+
server.listen(0, () => {
|
|
347
|
+
const address = server.address();
|
|
348
|
+
if (!address || typeof address === "string") {
|
|
349
|
+
server.close();
|
|
350
|
+
return reject(new Error("Unable to bind test server"));
|
|
351
|
+
}
|
|
352
|
+
const port = address.port;
|
|
353
|
+
http.get(`http://127.0.0.1:${port}/test`, (res) => {
|
|
354
|
+
res.resume();
|
|
355
|
+
res.on("end", () => {
|
|
356
|
+
server.close(() => resolve());
|
|
357
|
+
});
|
|
358
|
+
}).on("error", (err) => {
|
|
359
|
+
server.close(() => reject(err));
|
|
360
|
+
});
|
|
361
|
+
});
|
|
362
|
+
});
|
|
363
|
+
|
|
364
|
+
assert.equal(lines.length, 1);
|
|
365
|
+
const line = lines[0];
|
|
366
|
+
const resObj = line.res as { statusCode: number; headers: Record<string, unknown> };
|
|
367
|
+
assert.isDefined(resObj);
|
|
368
|
+
assert.equal(resObj.statusCode, 200);
|
|
369
|
+
const setCookie = String(resObj.headers["set-cookie"]);
|
|
370
|
+
assert.include(setCookie, "session=<redacted>");
|
|
371
|
+
assert.notInclude(setCookie, "SECRET");
|
|
372
|
+
assert.include(setCookie, "SameSite=None");
|
|
373
|
+
assert.include(setCookie, "HttpOnly");
|
|
374
|
+
assert.include(setCookie, "Secure");
|
|
375
|
+
assert.include(setCookie, "Path=/");
|
|
376
|
+
assert.include(setCookie, "Domain=.tabletcommand.com");
|
|
377
|
+
assert.include(setCookie, "Max-Age=3600");
|
|
378
|
+
assert.equal(resObj.headers.authorization, "Bearer SECRET1");
|
|
379
|
+
});
|
|
380
|
+
|
|
381
|
+
it("redacts credentials in request login body (M2)", async () => {
|
|
382
|
+
const lines: Record<string, unknown>[] = [];
|
|
383
|
+
const capture = new Writable({
|
|
384
|
+
write(chunk: Buffer | string, _encoding: string, callback: (error?: Error | null) => void) {
|
|
385
|
+
try {
|
|
386
|
+
lines.push(JSON.parse(chunk.toString()) as Record<string, unknown>);
|
|
387
|
+
} catch {
|
|
388
|
+
// ignore
|
|
389
|
+
}
|
|
390
|
+
callback();
|
|
391
|
+
},
|
|
392
|
+
});
|
|
393
|
+
|
|
394
|
+
const log = logger({ name: "test-login-body" }, capture);
|
|
395
|
+
const middleware = loggerMiddleware(log as StrictLogger);
|
|
396
|
+
|
|
397
|
+
const server = http.createServer((req, res) => {
|
|
398
|
+
(req as Request).body = {
|
|
399
|
+
username: "alice",
|
|
400
|
+
password: "mySecretPassword123",
|
|
401
|
+
};
|
|
402
|
+
middleware(req as unknown as Request, res as unknown as Response, () => {
|
|
403
|
+
res.statusCode = 200;
|
|
404
|
+
res.end("ok");
|
|
405
|
+
});
|
|
406
|
+
});
|
|
407
|
+
|
|
408
|
+
await new Promise<void>((resolve, reject) => {
|
|
409
|
+
server.listen(0, () => {
|
|
410
|
+
const address = server.address();
|
|
411
|
+
if (!address || typeof address === "string") {
|
|
412
|
+
server.close();
|
|
413
|
+
return reject(new Error("Unable to bind test server"));
|
|
414
|
+
}
|
|
415
|
+
const port = address.port;
|
|
416
|
+
const postReq = http.request(
|
|
417
|
+
`http://127.0.0.1:${port}/login`,
|
|
418
|
+
{ method: "POST" },
|
|
419
|
+
(res) => {
|
|
420
|
+
res.resume();
|
|
421
|
+
res.on("end", () => {
|
|
422
|
+
server.close(() => resolve());
|
|
423
|
+
});
|
|
424
|
+
}
|
|
425
|
+
);
|
|
426
|
+
postReq.on("error", (err) => {
|
|
427
|
+
server.close(() => reject(err));
|
|
428
|
+
});
|
|
429
|
+
postReq.end();
|
|
430
|
+
});
|
|
431
|
+
});
|
|
432
|
+
|
|
433
|
+
assert.equal(lines.length, 1);
|
|
434
|
+
const line = lines[0];
|
|
435
|
+
const reqObj = line.req as { body: { username: string; password: string } };
|
|
436
|
+
assert.isDefined(reqObj);
|
|
437
|
+
assert.equal(reqObj.body.username, "alice");
|
|
438
|
+
assert.equal(reqObj.body.password, "<redacted>");
|
|
439
|
+
});
|
|
440
|
+
|
|
441
|
+
it("redacts secrets inside array of objects in request body (M2)", async () => {
|
|
442
|
+
const lines: Record<string, unknown>[] = [];
|
|
443
|
+
const capture = new Writable({
|
|
444
|
+
write(chunk: Buffer | string, _encoding: string, callback: (error?: Error | null) => void) {
|
|
445
|
+
try {
|
|
446
|
+
lines.push(JSON.parse(chunk.toString()) as Record<string, unknown>);
|
|
447
|
+
} catch {
|
|
448
|
+
// ignore
|
|
449
|
+
}
|
|
450
|
+
callback();
|
|
451
|
+
},
|
|
452
|
+
});
|
|
453
|
+
|
|
454
|
+
const log = logger({ name: "test-array-body" }, capture);
|
|
455
|
+
const middleware = loggerMiddleware(log as StrictLogger);
|
|
456
|
+
|
|
457
|
+
const server = http.createServer((req, res) => {
|
|
458
|
+
(req as Request).body = {
|
|
459
|
+
items: [
|
|
460
|
+
{ apikey: "abcdef1234567" },
|
|
461
|
+
],
|
|
462
|
+
};
|
|
463
|
+
middleware(req as unknown as Request, res as unknown as Response, () => {
|
|
464
|
+
res.statusCode = 200;
|
|
465
|
+
res.end("ok");
|
|
466
|
+
});
|
|
467
|
+
});
|
|
468
|
+
|
|
469
|
+
await new Promise<void>((resolve, reject) => {
|
|
470
|
+
server.listen(0, () => {
|
|
471
|
+
const address = server.address();
|
|
472
|
+
if (!address || typeof address === "string") {
|
|
473
|
+
server.close();
|
|
474
|
+
return reject(new Error("Unable to bind test server"));
|
|
475
|
+
}
|
|
476
|
+
const port = address.port;
|
|
477
|
+
const postReq = http.request(
|
|
478
|
+
`http://127.0.0.1:${port}/items`,
|
|
479
|
+
{ method: "POST" },
|
|
480
|
+
(res) => {
|
|
481
|
+
res.resume();
|
|
482
|
+
res.on("end", () => {
|
|
483
|
+
server.close(() => resolve());
|
|
484
|
+
});
|
|
485
|
+
}
|
|
486
|
+
);
|
|
487
|
+
postReq.on("error", (err) => {
|
|
488
|
+
server.close(() => reject(err));
|
|
489
|
+
});
|
|
490
|
+
postReq.end();
|
|
491
|
+
});
|
|
492
|
+
});
|
|
493
|
+
|
|
494
|
+
assert.equal(lines.length, 1);
|
|
495
|
+
const line = lines[0];
|
|
496
|
+
const reqObj = line.req as { body: { items: { apikey: string }[] } };
|
|
497
|
+
assert.isDefined(reqObj);
|
|
498
|
+
assert.equal(reqObj.body.items[0].apikey, "abcdef1");
|
|
499
|
+
});
|
|
500
|
+
|
|
501
|
+
it("logs a body parsed after the middleware, and each field once", async () => {
|
|
502
|
+
const raw: string[] = [];
|
|
503
|
+
const capture = new Writable({
|
|
504
|
+
write(chunk: Buffer | string, _encoding: string, callback: (error?: Error | null) => void) {
|
|
505
|
+
raw.push(chunk.toString());
|
|
506
|
+
callback();
|
|
507
|
+
},
|
|
508
|
+
});
|
|
509
|
+
|
|
510
|
+
const log = logger({ name: "test-late-body" }, capture);
|
|
511
|
+
const middleware = loggerMiddleware(log as StrictLogger);
|
|
512
|
+
|
|
513
|
+
const server = http.createServer((req, res) => {
|
|
514
|
+
middleware(req as unknown as Request, res as unknown as Response, () => {
|
|
515
|
+
// Stands in for express.json() mounted after the logger.
|
|
516
|
+
(req as Request).body = { username: "alice", password: "mySecretPassword123" };
|
|
517
|
+
res.statusCode = 404;
|
|
518
|
+
res.end("missing");
|
|
519
|
+
});
|
|
520
|
+
});
|
|
521
|
+
|
|
522
|
+
await new Promise<void>((resolve, reject) => {
|
|
523
|
+
server.listen(0, () => {
|
|
524
|
+
const address = server.address();
|
|
525
|
+
if (!address || typeof address === "string") {
|
|
526
|
+
server.close();
|
|
527
|
+
return reject(new Error("Unable to bind test server"));
|
|
528
|
+
}
|
|
529
|
+
const postReq = http.request(
|
|
530
|
+
`http://127.0.0.1:${address.port}/login?apikey=abcdef1234567`,
|
|
531
|
+
{ method: "POST" },
|
|
532
|
+
(res) => {
|
|
533
|
+
res.resume();
|
|
534
|
+
res.on("end", () => {
|
|
535
|
+
server.close(() => resolve());
|
|
536
|
+
});
|
|
537
|
+
}
|
|
538
|
+
);
|
|
539
|
+
postReq.on("error", (err) => {
|
|
540
|
+
server.close(() => reject(err));
|
|
541
|
+
});
|
|
542
|
+
postReq.end();
|
|
543
|
+
});
|
|
544
|
+
});
|
|
545
|
+
|
|
546
|
+
assert.equal(raw.length, 1);
|
|
547
|
+
const text = raw[0];
|
|
548
|
+
// Top-level keys only: "method" also appears inside req.
|
|
549
|
+
for (const key of ["status", "url", "remoteAddress", "httpVersion", "req"]) {
|
|
550
|
+
const count = text.split(`"${key}":`).length - 1;
|
|
551
|
+
assert.equal(count, 1, `expected one "${key}" key in ${text}`);
|
|
552
|
+
}
|
|
553
|
+
|
|
554
|
+
const line = JSON.parse(text) as Record<string, unknown>;
|
|
555
|
+
assert.equal(line.status, 404);
|
|
556
|
+
assert.equal(line.method, "POST");
|
|
557
|
+
assert.equal(line.url, "/login?apikey=abcdef1");
|
|
558
|
+
const reqObj = line.req as { body: { username: string; password: string }; originalUrl: string };
|
|
559
|
+
assert.equal(reqObj.body.username, "alice");
|
|
560
|
+
assert.equal(reqObj.body.password, "<redacted>");
|
|
561
|
+
assert.equal(reqObj.originalUrl, "/login?apikey=abcdef1");
|
|
562
|
+
assert.equal((line.res as { statusCode: number }).statusCode, 404);
|
|
563
|
+
});
|
|
564
|
+
|
|
565
|
+
it("gives handlers a req.log that writes through the logger", async () => {
|
|
566
|
+
const lines: Record<string, unknown>[] = [];
|
|
567
|
+
const capture = new Writable({
|
|
568
|
+
write(chunk: Buffer | string, _encoding: string, callback: (error?: Error | null) => void) {
|
|
569
|
+
lines.push(JSON.parse(chunk.toString()) as Record<string, unknown>);
|
|
570
|
+
callback();
|
|
571
|
+
},
|
|
572
|
+
});
|
|
573
|
+
|
|
574
|
+
const log = logger({ name: "test-req-log" }, capture);
|
|
575
|
+
const middleware = loggerMiddleware(log as StrictLogger);
|
|
576
|
+
|
|
577
|
+
const server = http.createServer((req, res) => {
|
|
578
|
+
middleware(req as unknown as Request, res as unknown as Response, () => {
|
|
579
|
+
(req as Request).log.info({ step: "handler" }, "inside handler");
|
|
580
|
+
res.end("ok");
|
|
581
|
+
});
|
|
582
|
+
});
|
|
583
|
+
|
|
584
|
+
await new Promise<void>((resolve, reject) => {
|
|
585
|
+
server.listen(0, () => {
|
|
586
|
+
const address = server.address();
|
|
587
|
+
if (!address || typeof address === "string") {
|
|
588
|
+
server.close();
|
|
589
|
+
return reject(new Error("Unable to bind test server"));
|
|
590
|
+
}
|
|
591
|
+
http.get(`http://127.0.0.1:${address.port}/x`, (res) => {
|
|
592
|
+
res.resume();
|
|
593
|
+
res.on("end", () => {
|
|
594
|
+
server.close(() => resolve());
|
|
595
|
+
});
|
|
596
|
+
}).on("error", (err) => {
|
|
597
|
+
server.close(() => reject(err));
|
|
598
|
+
});
|
|
599
|
+
});
|
|
600
|
+
});
|
|
601
|
+
|
|
602
|
+
assert.equal(lines.length, 2);
|
|
603
|
+
assert.equal(lines[0].msg, "inside handler");
|
|
604
|
+
assert.equal(lines[0].service, "test-req-log");
|
|
605
|
+
assert.isDefined(lines[0].reqId);
|
|
606
|
+
assert.equal(lines[0].reqId, lines[1].reqId);
|
|
607
|
+
});
|
|
608
|
+
});
|
|
290
609
|
});
|
|
@@ -2,7 +2,7 @@ import { assert } from "chai";
|
|
|
2
2
|
import { EventEmitter } from "node:events";
|
|
3
3
|
import { describe, it, describe as context } from "node:test";
|
|
4
4
|
import { Request, Response } from "express";
|
|
5
|
-
import {
|
|
5
|
+
import { StrictLogger } from "../logger-types";
|
|
6
6
|
import statusLogger from "../middleware/status-logger";
|
|
7
7
|
|
|
8
8
|
describe("Status Logger Middleware", function() {
|
|
@@ -16,7 +16,7 @@ describe("Status Logger Middleware", function() {
|
|
|
16
16
|
info: (msg: Record<string, unknown>) => {
|
|
17
17
|
line = msg;
|
|
18
18
|
},
|
|
19
|
-
} as unknown as
|
|
19
|
+
} as unknown as StrictLogger;
|
|
20
20
|
const res = new EventEmitter() as unknown as Response;
|
|
21
21
|
res.statusCode = 200;
|
|
22
22
|
res.json = () => res;
|
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
import { assert } from "chai";
|
|
2
|
+
import { describe, it } from "node:test";
|
|
3
|
+
import { Writable } from "node:stream";
|
|
4
|
+
import Module from "node:module";
|
|
5
|
+
import * as otel from "@opentelemetry/api";
|
|
6
|
+
import logger from "../pino-logger";
|
|
7
|
+
import { getOtelTraceContext, resetOtelForTesting } from "../otel";
|
|
8
|
+
|
|
9
|
+
describe("OpenTelemetry Mixin", () => {
|
|
10
|
+
function createCaptureStream(lines: Record<string, unknown>[]) {
|
|
11
|
+
return new Writable({
|
|
12
|
+
write(chunk: Buffer | string, _encoding: string, callback: (error?: Error | null) => void) {
|
|
13
|
+
try {
|
|
14
|
+
lines.push(JSON.parse(chunk.toString()) as Record<string, unknown>);
|
|
15
|
+
} catch {
|
|
16
|
+
// ignore
|
|
17
|
+
}
|
|
18
|
+
callback();
|
|
19
|
+
},
|
|
20
|
+
});
|
|
21
|
+
}
|
|
22
|
+
|
|
23
|
+
it("does not inject trace fields when no span is active", () => {
|
|
24
|
+
const lines: Record<string, unknown>[] = [];
|
|
25
|
+
const log = logger(
|
|
26
|
+
{ name: "test", logToConsole: true },
|
|
27
|
+
createCaptureStream(lines)
|
|
28
|
+
);
|
|
29
|
+
|
|
30
|
+
log?.info("plain message without active span");
|
|
31
|
+
|
|
32
|
+
assert.equal(lines.length, 1);
|
|
33
|
+
assert.isUndefined(lines[0].trace_id);
|
|
34
|
+
assert.isUndefined(lines[0].span_id);
|
|
35
|
+
assert.equal(lines[0].msg, "plain message without active span");
|
|
36
|
+
});
|
|
37
|
+
|
|
38
|
+
it("injects trace_id and span_id when an active span is present", () => {
|
|
39
|
+
const lines: Record<string, unknown>[] = [];
|
|
40
|
+
const log = logger(
|
|
41
|
+
{ name: "test", logToConsole: true },
|
|
42
|
+
createCaptureStream(lines)
|
|
43
|
+
);
|
|
44
|
+
|
|
45
|
+
const origGetActiveSpan = otel.trace.getActiveSpan;
|
|
46
|
+
// Mock an active span
|
|
47
|
+
(otel.trace as any).getActiveSpan = () => ({
|
|
48
|
+
spanContext: () => ({
|
|
49
|
+
traceId: "4bf92f3577b34da6a3ce929d0e0e4736",
|
|
50
|
+
spanId: "00f067aa0ba902b7",
|
|
51
|
+
traceFlags: 1,
|
|
52
|
+
}),
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
try {
|
|
56
|
+
log?.info({ detail: "test" }, "message with active trace span");
|
|
57
|
+
|
|
58
|
+
assert.equal(lines.length, 1);
|
|
59
|
+
assert.equal(lines[0].trace_id, "4bf92f3577b34da6a3ce929d0e0e4736");
|
|
60
|
+
assert.equal(lines[0].span_id, "00f067aa0ba902b7");
|
|
61
|
+
assert.equal(lines[0].trace_flags, "1");
|
|
62
|
+
assert.equal(lines[0].detail, "test");
|
|
63
|
+
} finally {
|
|
64
|
+
(otel.trace as any).getActiveSpan = origGetActiveSpan;
|
|
65
|
+
}
|
|
66
|
+
});
|
|
67
|
+
|
|
68
|
+
it("does not inject all-zero trace IDs when an inactive or NonRecordingSpan is returned", () => {
|
|
69
|
+
const lines: Record<string, unknown>[] = [];
|
|
70
|
+
const log = logger(
|
|
71
|
+
{ name: "test", logToConsole: true },
|
|
72
|
+
createCaptureStream(lines)
|
|
73
|
+
);
|
|
74
|
+
|
|
75
|
+
const origGetActiveSpan = otel.trace.getActiveSpan;
|
|
76
|
+
// Mock NonRecordingSpan with invalid all-zero IDs
|
|
77
|
+
(otel.trace as any).getActiveSpan = () => ({
|
|
78
|
+
spanContext: () => ({
|
|
79
|
+
traceId: "00000000000000000000000000000000",
|
|
80
|
+
spanId: "0000000000000000",
|
|
81
|
+
traceFlags: 0,
|
|
82
|
+
}),
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
try {
|
|
86
|
+
log?.info({ detail: "test" }, "message with invalid/zero span");
|
|
87
|
+
|
|
88
|
+
assert.equal(lines.length, 1);
|
|
89
|
+
assert.isUndefined(lines[0].trace_id);
|
|
90
|
+
assert.isUndefined(lines[0].span_id);
|
|
91
|
+
assert.isUndefined(lines[0].trace_flags);
|
|
92
|
+
assert.equal(lines[0].detail, "test");
|
|
93
|
+
} finally {
|
|
94
|
+
(otel.trace as any).getActiveSpan = origGetActiveSpan;
|
|
95
|
+
}
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
it("gracefully returns empty object when @opentelemetry/api cannot be resolved", () => {
|
|
99
|
+
const mod = Module as unknown as { _resolveFilename: (request: string, ...args: unknown[]) => string };
|
|
100
|
+
const origResolve = mod._resolveFilename;
|
|
101
|
+
mod._resolveFilename = function (request: string, ...args: unknown[]) {
|
|
102
|
+
if (request === "@opentelemetry/api") {
|
|
103
|
+
const err = new Error("Cannot find module @opentelemetry/api") as Error & { code: string };
|
|
104
|
+
err.code = "MODULE_NOT_FOUND";
|
|
105
|
+
throw err;
|
|
106
|
+
}
|
|
107
|
+
return origResolve.call(this, request, ...args);
|
|
108
|
+
};
|
|
109
|
+
|
|
110
|
+
try {
|
|
111
|
+
resetOtelForTesting();
|
|
112
|
+
const ctx = getOtelTraceContext();
|
|
113
|
+
assert.deepEqual(ctx, {});
|
|
114
|
+
} finally {
|
|
115
|
+
mod._resolveFilename = origResolve;
|
|
116
|
+
resetOtelForTesting();
|
|
117
|
+
}
|
|
118
|
+
});
|
|
119
|
+
});
|