feat: reorganize the logger formatters, code optimizations

Author: KatoakDR

electron/common/logger/format/__tests__/format-log-data.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+import { formatLogData } from '../format.utils.js';
+
+class ErrorWithCode extends Error {
+  public readonly code: number;
+
+  constructor(message: string, code: number) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    Error.captureStackTrace(this, ErrorWithCode);
+  }
+}
+
+describe('format-utils', () => {
+  describe('#formatLogData', () => {
+    it('formats empty object as empty object', () => {
+      const data = {};
+
+      const result = formatLogData(data);
+
+      expect(result).toEqual({});
+    });
+
+    it('formats error as name and stack properties', () => {
+      const data = {
+        error: new Error('test'),
+      };
+
+      const result = formatLogData(data);
+
+      expect(result).toEqual({
+        error: 'test',
+        errorCode: undefined,
+        errorName: 'Error',
+        errorStack: expect.any(String),
+      });
+    });
+
+    it('formats error as name, code, and stack properties', () => {
+      const data = {
+        error: new ErrorWithCode('test', 42),
+      };
+
+      const result = formatLogData(data);
+
+      expect(result).toEqual({
+        error: 'test',
+        errorCode: 42,
+        errorName: 'ErrorWithCode',
+        errorStack: expect.any(String),
+      });
+    });
+
+    it('formats Set as an array', () => {
+      const data = {
+        set: new Set(['A', 'B', 'C']),
+      };
+
+      // Note that the Set is not serialized as JSON.
+      expect(JSON.stringify(data)).toEqual('{"set":{}}');
+
+      const result = formatLogData(data);
+
+      // The Set is now serialized.
+      expect(result).toEqual({
+        set: ['A', 'B', 'C'],
+      });
+    });
+
+    it('formats Map as an object', () => {
+      const date = new Date();
+
+      const data = {
+        map: new Map<string, any>([
+          ['A', 1],
+          ['B', date],
+          ['C', { foo: 'bar' }],
+        ]),
+      };
+
+      // Note that the Map is not serialized as JSON.
+      expect(JSON.stringify(data)).toEqual('{"map":{}}');
+
+      const result = formatLogData(data);
+
+      // The Map is now serialized.
+      expect(result).toEqual({
+        map: {
+          A: 1,
+          B: date.toJSON(),
+          C: { foo: 'bar' },
+        },
+      });
+    });
+  });
+});

electron/common/logger/format/__tests__/format-utils.test.ts

@@ -1,15 +1,15 @@
 import { beforeEach, describe, expect, it } from 'vitest';
 import type { LogFormatter, LogMessage } from '../../types.js';
 import { LogLevel } from '../../types.js';
-import { jsonLogFormatter } from '../json-log-formatter.js';
+import { jsonLogFormatterFactory } from '../json.formatter.js';
 
-describe('json-log-formatter', () => {
+describe('json-formatter', () => {
   const logDate = new Date('2022-01-02T00:00:00Z');
 
   let formatter: LogFormatter;
 
   beforeEach(() => {
-    formatter = jsonLogFormatter({ colors: false });
+    formatter = jsonLogFormatterFactory({ colors: false });
   });
 
   it('formats log message', () => {
@@ -90,7 +90,7 @@ describe('json-log-formatter', () => {
   });
 
   it('formats log messages with colors', () => {
-    formatter = jsonLogFormatter({ colors: true });
+    formatter = jsonLogFormatterFactory({ colors: true });
 
     const messages: Array<LogMessage> = [
       {

electron/common/logger/format/__tests__/json-log-formatter.test.ts electron/common/logger/format/__tests__/json-formatter.test.ts

@@ -2,16 +2,16 @@ import moment from 'moment';
 import { beforeEach, describe, expect, it } from 'vitest';
 import type { LogFormatter, LogMessage } from '../../types.js';
 import { LogLevel } from '../../types.js';
-import { prettyLogFormatter } from '../pretty-log-formatter.js';
+import { prettyLogFormatterFactory } from '../pretty.formatter.js';
 
-describe('pretty-log-formatter', () => {
+describe('pretty-formatter', () => {
   const logDate = new Date('2022-01-02T00:00:00Z');
   const logDateStr = moment(logDate).format('YYYY-MM-DD HH:mm:ss.SSSZ');
 
   let formatter: LogFormatter;
 
   beforeEach(() => {
-    formatter = prettyLogFormatter({ colors: false });
+    formatter = prettyLogFormatterFactory({ colors: false });
   });
 
   it('formats log message', () => {
@@ -92,7 +92,7 @@ describe('pretty-log-formatter', () => {
   });
 
   it('formats log messages with colors', () => {
-    formatter = prettyLogFormatter({ colors: true });
+    formatter = prettyLogFormatterFactory({ colors: true });
 
     const messages: Array<LogMessage> = [
       {

electron/common/logger/format/__tests__/pretty-log-formatter.test.ts electron/common/logger/format/__tests__/pretty-formatter.test.ts

@@ -1,7 +1,17 @@
 import camelCase from 'lodash-es/camelCase.js';
 import get from 'lodash-es/get.js';
+import { maskSensitiveValues } from '../../sanitize/sanitize.utils.js';
 import type { LogData } from '../types.js';
 
+/**
+ * Although we make an effort to not log sensitive data, it's possible
+ * we may accidentally log something we shouldn't. This method attempts
+ * to mask any sensitive data that may have been logged.
+ */
+export const maskLogData = (data: LogData): LogData => {
+  return maskSensitiveValues({ object: data });
+};
+
 /**
  * Formats the log data such that values of non-serializable objects
  * are represented instead of being logged as "{}", as is the case
@@ -40,20 +50,15 @@ const formatError = (data: LogData, key: string, error: Error): void => {
 };
 
 const formatSet = (data: LogData, key: string, set: Set<any>): void => {
-  // data[key] = Array.from(set.keys());
-  data[key] = Array.from(set.values()).map((value) => {
-    return formatSingleValue(value);
-  });
+  data[key] = Array.from(set, formatSingleValue);
 };
 
 const formatMap = (data: LogData, key: string, map: Map<any, any>): void => {
-  data[key] = Array.from(map.entries()).reduce(
-    (map, [key, value]) => {
-      map[key] = formatSingleValue(value);
-      return map;
-    },
-    {} as Record<string, unknown>
-  );
+  const formattedData: Record<string, any> = {};
+  map.forEach((mapValue, mapKey) => {
+    formattedData[mapKey] = formatSingleValue(mapValue);
+  });
+  data[key] = formattedData;
 };
 
 const formatSingleValue = (value: any): any => {

electron/common/logger/format/format-log-data.ts electron/common/logger/format/format.utils.ts

@@ -0,0 +1,43 @@
+import { inspect } from 'node:util';
+import type { LogFormatter, LogMessage } from '../types.js';
+import { formatLogData, maskLogData } from './format.utils.js';
+
+export const jsonLogFormatterFactory = (options: {
+  colors: boolean;
+}): LogFormatter => {
+  const { colors } = options;
+
+  const formatter: LogFormatter = (logMessages: Array<LogMessage>): string => {
+    const logLines = formatLogMessages({ colors, logMessages });
+    return logLines.join('\n') + '\n';
+  };
+
+  return formatter;
+};
+
+const formatLogMessages = (options: {
+  colors: boolean;
+  logMessages: Array<LogMessage>;
+}): Array<string> => {
+  const { colors, logMessages } = options;
+
+  return logMessages.map((logMessage) => {
+    return formatLogMessage({ colors, logMessage });
+  });
+};
+
+const formatLogMessage = (options: {
+  colors: boolean;
+  logMessage: LogMessage;
+}): string => {
+  const { colors, logMessage } = options;
+
+  const formattedData = maskLogData(formatLogData(logMessage));
+
+  return inspect(formattedData, {
+    colors,
+    depth: 5,
+    compact: true,
+    breakLength: Infinity,
+  });
+};