Feat(functions): added colored logs to tracing functions

packages/functions/package.json

@@ -13,7 +13,8 @@
     "test": "bash ../../scripts/test/test.sh"
   },
   "dependencies": {
-    "@sliit-foss/module-logger": "1.1.5",
+    "@sliit-foss/module-logger": "1.2.3",
+    "chalk": "4.1.2",
     "express-http-context": "1.2.4"
   },
   "repository": {

packages/functions/src/traced.js

@@ -1,4 +1,5 @@
 import { performance } from "perf_hooks";
+import { default as chalk } from "chalk";
 import { moduleLogger } from "@sliit-foss/module-logger";
 import { fnName as _fnName } from "./utils";
 
@@ -15,11 +16,18 @@ export const _traced = (fn, loggable = {}, fnName) => {
   }
   const completionLog = () => {
     !disableTracing &&
-      logger.info(`${fnName} execution completed - execution_time : ${performance.now() - startTime}ms`, loggable);
+      logger.info(
+        `${fnName} execution completed - ${chalk.bold(chalk.magentaBright("execution_time"))} : ${chalk.bold(
+          `${performance.now() - startTime}ms`
+        )}`,
+        loggable
+      );
   };
   const failureLog = (err) => {
     if (!disableTracing && !err.isLogged) {
-      logger.error(`${fnName} execution failed - error: ${err.message} - stack: ${err.stack}`);
+      logger.error(
+        `${fnName} execution failed - ${chalk.bold("error")}: ${err.message} - ${chalk.bold("stack")}: ${err.stack}`
+      );
       err.isLogged = true;
     }
     throw err;

packages/functions/src/utils/index.js

@@ -1,11 +1,15 @@
+import chalk from "chalk";
+
 export const fnName = (fn) => {
   let name = fn.name;
   while (1) {
     const replaced = name?.replace("bound", "");
     if (name.startsWith("bound") && replaced?.startsWith(" ")) name = replaced?.trim();
     else break;
   }
-  if (!name) return "Unnamed function";
+  if (!name) return coloredFnName("Unnamed function");
   if (name.startsWith(" ")) return name.slice(1);
-  return name;
+  return coloredFnName(name);
 };
+
+export const coloredFnName = (fn) => chalk.bold(chalk.magentaBright(fn));

packages/functions/test/async.test.js

@@ -1,6 +1,7 @@
 const { mockLogger } = require("./__mocks__");
 
 const { asyncHandler, tracedAsyncHandler } = require("../src");
+const { coloredFnName } = require("../src/utils");
 
 beforeEach(() => {
   jest.clearAllMocks();
@@ -31,7 +32,7 @@ describe("asyncHandler", () => {
     await tracedAsyncHandler(function testTracedFunction() {
       return "test";
     })(mockReq, mockRes, mockNext);
-    expect(mockLogger.info).toBeCalledWith("testTracedFunction execution initiated", {});
+    expect(mockLogger.info).toBeCalledWith(`${coloredFnName("testTracedFunction")} execution initiated`, {});
     expect(mockNext).toBeCalled();
   });
 });

packages/functions/test/traced.test.js

@@ -1,6 +1,7 @@
 const { mockLogger } = require("./__mocks__");
 
 const { traced, trace, cleanTrace, cleanTraced } = require("../src");
+const { coloredFnName } = require("../src/utils");
 
 beforeEach(() => {
   jest.clearAllMocks();
@@ -14,25 +15,25 @@ describe("traced", () => {
       return _mockResult;
     })();
     expect(res).toStrictEqual(_mockResult);
-    expect(mockLogger.info).toBeCalledWith("testFunction execution initiated", {});
+    expect(mockLogger.info).toBeCalledWith(`${coloredFnName("testFunction")} execution initiated`, {});
   });
   test("test async function", async () => {
     const res = await traced(async function testFunction() {
       return _mockResult;
     })();
     expect(res).toStrictEqual(_mockResult);
-    expect(mockLogger.info).toBeCalledWith("testFunction execution initiated", {});
+    expect(mockLogger.info).toBeCalledWith(`${coloredFnName("testFunction")} execution initiated`, {});
   });
   test("test arrow function", () => {
     const testArrowFunction = () => _mockResult;
     const res = traced(testArrowFunction)();
     expect(res).toStrictEqual(_mockResult);
-    expect(mockLogger.info).toBeCalledWith("testArrowFunction execution initiated", {});
+    expect(mockLogger.info).toBeCalledWith(`${coloredFnName("testArrowFunction")} execution initiated`, {});
   });
   test("test unnamed function", () => {
     const res = traced(() => _mockResult)();
     expect(res).toStrictEqual(_mockResult);
-    expect(mockLogger.info).toBeCalledWith("Unnamed function execution initiated", {});
+    expect(mockLogger.info).toBeCalledWith(`${coloredFnName("Unnamed function")} execution initiated`, {});
   });
   test("test disabled tracing", () => {
     process.env.DISABLE_FUNCTION_TRACING = "true";
@@ -61,7 +62,7 @@ describe("trace", () => {
       return _mockResult;
     });
     expect(res).toStrictEqual(_mockResult);
-    expect(mockLogger.info).toBeCalledWith("foo execution initiated", {});
+    expect(mockLogger.info).toBeCalledWith(`${coloredFnName("foo")} execution initiated`, {});
   });
 });
 
@@ -71,7 +72,7 @@ describe("clean-trace", () => {
       return _mockResult;
     });
     expect(res).toStrictEqual(_mockResult);
-    expect(mockLogger.info).toBeCalledWith("namedFunction execution initiated", {});
+    expect(mockLogger.info).toBeCalledWith(`${coloredFnName("namedFunction")} execution initiated`, {});
   });
   test("test unnamed function", () => {
     const res = cleanTrace(() => _mockResult);
@@ -86,7 +87,7 @@ describe("clean-traced", () => {
       return _mockResult;
     })();
     expect(res).toStrictEqual(_mockResult);
-    expect(mockLogger.info).toBeCalledWith("namedFunction execution initiated", {});
+    expect(mockLogger.info).toBeCalledWith(`${coloredFnName("namedFunction")} execution initiated`, {});
   });
   test("test unnamed function", () => {
     const res = cleanTraced(() => _mockResult)();