feat(std/log): inline and deferred statement resolution logging (#5192)

1 files changed, 135 insertions, 7 deletions

diff --git a/std/log/logger_test.ts b/std/log/logger_test.ts
index 44b0edd06..b2e3cdab1 100644
--- a/std/log/logger_test.ts
+++ b/std/log/logger_test.ts
@@ -1,6 +1,6 @@
 // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
 const { test } = Deno;
-import { assertEquals } from "../testing/asserts.ts";
+import { assertEquals, assert } from "../testing/asserts.ts";
 import { LogRecord, Logger } from "./logger.ts";
 import { LogLevels, LevelName } from "./levels.ts";
 import { BaseHandler } from "./handlers.ts";
@@ -36,7 +36,7 @@ test("customHandler", function (): void {
   const handler = new TestHandler("DEBUG");
   const logger = new Logger("DEBUG", [handler]);
 
-  logger.debug("foo", 1, 2);
+  const inlineData: string = logger.debug("foo", 1, 2);
 
   const record = handler.records[0];
   assertEquals(record.msg, "foo");
@@ -45,17 +45,23 @@ test("customHandler", function (): void {
   assertEquals(record.levelName, "DEBUG");
 
   assertEquals(handler.messages, ["DEBUG foo"]);
+  assertEquals(inlineData!, "foo");
 });
 
 test("logFunctions", function (): void {
   const doLog = (level: LevelName): TestHandler => {
     const handler = new TestHandler(level);
     const logger = new Logger(level, [handler]);
-    logger.debug("foo");
-    logger.info("bar");
-    logger.warning("baz");
-    logger.error("boo");
-    logger.critical("doo");
+    const debugData = logger.debug("foo");
+    const infoData = logger.info("bar");
+    const warningData = logger.warning("baz");
+    const errorData = logger.error("boo");
+    const criticalData = logger.critical("doo");
+    assertEquals(debugData, "foo");
+    assertEquals(infoData, "bar");
+    assertEquals(warningData, "baz");
+    assertEquals(errorData, "boo");
+    assertEquals(criticalData, "doo");
     return handler;
   };
 
@@ -91,3 +97,125 @@ test("logFunctions", function (): void {
 
   assertEquals(handler.messages, ["CRITICAL doo"]);
 });
+
+test("String resolver fn will not execute if msg will not be logged", function (): void {
+  const handler = new TestHandler("ERROR");
+  const logger = new Logger("ERROR", [handler]);
+  let called = false;
+
+  const expensiveFunction = (): string => {
+    called = true;
+    return "expensive function result";
+  };
+
+  const inlineData: string | undefined = logger.debug(expensiveFunction, 1, 2);
+  assert(!called);
+  assertEquals(inlineData, undefined);
+});
+
+test("String resolver fn resolves as expected", function (): void {
+  const handler = new TestHandler("ERROR");
+  const logger = new Logger("ERROR", [handler]);
+  const expensiveFunction = (x: number): string => {
+    return "expensive function result " + x;
+  };
+
+  const firstInlineData = logger.error(() => expensiveFunction(5));
+  const secondInlineData = logger.error(() => expensiveFunction(12), 1, "abc");
+  assertEquals(firstInlineData, "expensive function result 5");
+  assertEquals(secondInlineData, "expensive function result 12");
+});
+
+test("All types map correctly to log strings and are returned as is", function (): void {
+  const handler = new TestHandler("DEBUG");
+  const logger = new Logger("DEBUG", [handler]);
+  const sym = Symbol();
+  const syma = Symbol("a");
+  const fn = (): string => {
+    return "abc";
+  };
+
+  // string
+  const data1: string = logger.debug("abc");
+  assertEquals(data1, "abc");
+  const data2: string = logger.debug("def", 1);
+  assertEquals(data2, "def");
+  assertEquals(handler.messages[0], "DEBUG abc");
+  assertEquals(handler.messages[1], "DEBUG def");
+
+  // null
+  const data3: null = logger.info(null);
+  assertEquals(data3, null);
+  const data4: null = logger.info(null, 1);
+  assertEquals(data4, null);
+  assertEquals(handler.messages[2], "INFO null");
+  assertEquals(handler.messages[3], "INFO null");
+
+  // number
+  const data5: number = logger.warning(3);
+  assertEquals(data5, 3);
+  const data6: number = logger.warning(3, 1);
+  assertEquals(data6, 3);
+  assertEquals(handler.messages[4], "WARNING 3");
+  assertEquals(handler.messages[5], "WARNING 3");
+
+  // bigint
+  const data7: bigint = logger.error(5n);
+  assertEquals(data7, 5n);
+  const data8: bigint = logger.error(5n, 1);
+  assertEquals(data8, 5n);
+  assertEquals(handler.messages[6], "ERROR 5");
+  assertEquals(handler.messages[7], "ERROR 5");
+
+  // boolean
+  const data9: boolean = logger.critical(true);
+  assertEquals(data9, true);
+  const data10: boolean = logger.critical(false, 1);
+  assertEquals(data10, false);
+  assertEquals(handler.messages[8], "CRITICAL true");
+  assertEquals(handler.messages[9], "CRITICAL false");
+
+  // undefined
+  const data11: undefined = logger.debug(undefined);
+  assertEquals(data11, undefined);
+  const data12: undefined = logger.debug(undefined, 1);
+  assertEquals(data12, undefined);
+  assertEquals(handler.messages[10], "DEBUG undefined");
+  assertEquals(handler.messages[11], "DEBUG undefined");
+
+  // symbol
+  const data13: symbol = logger.info(sym);
+  assertEquals(data13, sym);
+  const data14: symbol = logger.info(syma, 1);
+  assertEquals(data14, syma);
+  assertEquals(handler.messages[12], "INFO Symbol()");
+  assertEquals(handler.messages[13], "INFO Symbol(a)");
+
+  // function
+  const data15: string | undefined = logger.warning(fn);
+  assertEquals(data15, "abc");
+  const data16: string | undefined = logger.warning(fn, 1);
+  assertEquals(data16, "abc");
+  assertEquals(handler.messages[14], "WARNING abc");
+  assertEquals(handler.messages[15], "WARNING abc");
+
+  // object
+  const data17: { payload: string; other: number } = logger.error({
+    payload: "data",
+    other: 123,
+  });
+  assertEquals(data17, {
+    payload: "data",
+    other: 123,
+  });
+  const data18: { payload: string; other: number } = logger.error(
+    { payload: "data", other: 123 },
+    1
+  );
+  assertEquals(data18, {
+    payload: "data",
+    other: 123,
+  });
+  assertEquals(handler.messages[16], 'ERROR {"payload":"data","other":123}');
+  assertEquals(handler.messages[17], 'ERROR {"payload":"data","other":123}');
+});