@dxos/log 0.4.9 → 0.4.10-main.068c3d8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dxos/log",
-  "version": "0.4.9",
+  "version": "0.4.10-main.068c3d8",
   "description": "Logger",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
@@ -24,8 +24,8 @@
     "lodash.omit": "^4.5.0",
     "lodash.pick": "^4.4.0",
     "lodash.pickby": "^4.6.0",
-    "@dxos/node-std": "0.4.9",
-    "@dxos/util": "0.4.9"
+    "@dxos/node-std": "0.4.10-main.068c3d8",
+    "@dxos/util": "0.4.10-main.068c3d8"
   },
   "devDependencies": {
     "@swc-node/sourcemap-support": "^0.2.0",

package/src/context.ts

@@ -64,7 +64,7 @@ export const getContextFromEntry = (entry: LogEntry): Record<string, any> | unde
 
   if (entry.error) {
     const errorContext = (entry.error as any).context;
-    context = Object.assign(context ?? {}, { error: entry.error.stack, ...errorContext });
+    context = Object.assign(context ?? {}, { error: entry.error, ...errorContext });
   }
 
   return context && Object.keys(context).length > 0 ? context : undefined;

package/src/decorators.ts

@@ -2,6 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
+import chalk from 'chalk';
 import { inspect } from 'node:util';
 
 import type { LogMethods } from './log';
@@ -14,8 +15,11 @@ export const createMethodLogDecorator =
   (arg0?: never, arg1?: never, meta?: CallMetadata): MethodDecorator =>
   (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
     const method = descriptor.value!;
+    const methodName = propertyKey as string;
     descriptor.value = function (this: any, ...args: any) {
       const combinedMeta = {
+        F: '',
+        L: 0,
         ...(meta ?? {}),
         S: this as any,
       } as CallMetadata;
@@ -28,43 +32,117 @@ export const createMethodLogDecorator =
 
         if (isThenable(result)) {
           const id = nextPromiseId++;
-          log.info(`${propertyKey as string}(${formattedArgs}) => Promise { #${id} }`, {}, combinedMeta);
+          logAsyncBegin(log, methodName, formattedArgs, id, combinedMeta);
           result.then(
             (resolvedValue) => {
-              if (resolvedValue !== undefined) {
-                log.info(
-                  `✅ resolve #${id} ${(performance.now() - startTime).toFixed(0)}ms => ${inspect(
-                    resolvedValue,
-                    false,
-                    1,
-                    true,
-                  )}`,
-                  {},
-                  combinedMeta,
-                );
-              } else {
-                log.info(`✅ resolve #${id} ${(performance.now() - startTime).toFixed(0)}ms`, {}, combinedMeta);
-              }
+              logAsyncResolved(log, methodName, resolvedValue, id, startTime, combinedMeta);
             },
             (err) => {
-              log.info(`🔥 reject #${id} #${(performance.now() - startTime).toFixed(0)}ms => ${err}`, {}, combinedMeta);
+              logAsyncRejected(log, methodName, err, id, startTime, combinedMeta);
             },
           );
         } else {
-          log.info(
-            `${propertyKey as string}(${formattedArgs}) => ${inspect(result, false, 1, true)}`,
-            {},
-            combinedMeta,
-          );
+          logSyncCall(log, methodName, formattedArgs, result, combinedMeta);
         }
 
         return result;
-      } catch (err) {
-        log.error(`${propertyKey as string}(${formattedArgs}) 🔥 ${err}`, {}, combinedMeta);
+      } catch (err: any) {
+        logSyncError(log, methodName, formattedArgs, err, combinedMeta);
         throw err;
       }
     };
-    Object.defineProperty(descriptor.value, 'name', { value: (propertyKey as string) + '$log' });
+    Object.defineProperty(descriptor.value, 'name', { value: methodName + '$log' });
   };
 
 const isThenable = (obj: any): obj is Promise<unknown> => obj && typeof obj.then === 'function';
+
+const logSyncCall = (
+  log: LogMethods,
+  methodName: string,
+  formattedArgs: string,
+  result: unknown,
+  combinedMeta: CallMetadata,
+) => {
+  log.info(
+    `.${formatFunction(methodName)} (${formattedArgs}) ${chalk.gray('resolve')} ${inspect(result, false, 1, true)}`,
+    {},
+    combinedMeta,
+  );
+};
+
+const logSyncError = (
+  log: LogMethods,
+  methodName: string,
+  formattedArgs: string,
+  err: Error,
+  combinedMeta: CallMetadata,
+) => {
+  log.error(`.${formatFunction(methodName)} (${formattedArgs}) 🔥 ${err}`, {}, combinedMeta);
+};
+
+const logAsyncBegin = (
+  log: LogMethods,
+  methodName: string,
+  formattedArgs: string,
+  promiseId: number,
+  combinedMeta: CallMetadata,
+) => {
+  log.info(
+    `.${formatFunction(methodName)} ↴ (${formattedArgs}) ${chalk.gray('=>')} ${formatPromise(promiseId)}`,
+    {},
+    combinedMeta,
+  );
+};
+
+const logAsyncResolved = (
+  log: LogMethods,
+  methodName: string,
+  resolvedValue: unknown | undefined,
+  promiseId: number,
+  startTime: number,
+  combinedMeta: CallMetadata,
+) => {
+  if (resolvedValue !== undefined) {
+    log.info(
+      `.${formatFunction(methodName)} ↲ ${greenCheck} ${chalk.gray('resolve')} ${formatPromise(promiseId)} ${formatTimeElapsed(startTime)} ${chalk.gray('=>')} ${inspect(
+        resolvedValue,
+        false,
+        1,
+        true,
+      )}`,
+      {},
+      combinedMeta,
+    );
+  } else {
+    log.info(
+      `.${formatFunction(methodName)} ↲ ${greenCheck} ${chalk.gray('resolve')} ${formatPromise(promiseId)} ${formatTimeElapsed(startTime)}`,
+      {},
+      combinedMeta,
+    );
+  }
+};
+
+const logAsyncRejected = (
+  log: LogMethods,
+  methodName: string,
+  err: Error,
+  promiseId: number,
+  startTime: number,
+  combinedMeta: CallMetadata,
+) => {
+  log.info(
+    `.${formatFunction(methodName)} ↲ 🔥 ${chalk.gray('reject')} ${formatPromise(promiseId)} ${formatTimeElapsed(startTime)} ${chalk.gray('=>')} ${err}`,
+    {},
+    combinedMeta,
+  );
+};
+
+const greenCheck = chalk.green('✔');
+
+const formatTimeElapsed = (startTime: number) => chalk.gray(`${(performance.now() - startTime).toFixed(0)}ms`);
+
+const COLOR_FUNCTION = [220, 220, 170] as const;
+
+const formatFunction = (name: string) => chalk.bold(chalk.rgb(...COLOR_FUNCTION)(name));
+
+const formatPromise = (id: number) => chalk.blue(`Promise#${id}`);

package/src/log.ts

@@ -71,7 +71,7 @@ const createLog = (): LogImp => {
   log.error = (...params) => processLog(LogLevel.ERROR, ...params);
 
   // Catch only shows error message, not stacktrace.
-  log.catch = (error: Error | any, context, meta) => processLog(LogLevel.ERROR, error.stack, context, meta, error);
+  log.catch = (error: Error | any, context, meta) => processLog(LogLevel.ERROR, error.message, context, meta, error);
 
   // Show break.
   log.break = () => log.info('——————————————————————————————————————————————————');

package/src/processors/browser-processor.ts

@@ -58,7 +58,7 @@ const APP_BROWSER_PROCESSOR: LogProcessor = (config, entry) => {
     const filename = getRelativeFilename(entry.meta.F);
     const filepath = `${LOG_BROWSER_PREFIX.replace(/\/$/, '')}/${filename}`;
     // TODO(burdon): Line numbers not working for app link, even with colons.
-    //   https://stackoverflow.com/a/54459820/2804332
+    //  https://stackoverflow.com/a/54459820/2804332
     link = `${filepath}#L${entry.meta.L}`;
   }
 

package/src/processors/common.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export const getRelativeFilename = (filename: string) => {
+  // TODO(burdon): Hack uses "packages" as an anchor (pre-parse NX?)
+  // Including `packages/` part of the path so that excluded paths (e.g. from dist) are clickable in vscode.
+  const match = filename.match(/.+\/(packages\/.+\/.+)/);
+  if (match) {
+    const [, filePath] = match;
+    return filePath;
+  }
+
+  return filename;
+};

package/src/processors/console-processor.ts

@@ -8,6 +8,7 @@ import { inspect } from 'node:util';
 
 import { getPrototypeSpecificInstanceId } from '@dxos/util';
 
+import { getRelativeFilename } from './common';
 import { type LogConfig, LogLevel, shortLevelName } from '../config';
 import { getContextFromEntry, type LogProcessor, shouldLog } from '../context';
 
@@ -24,18 +25,6 @@ export const truncate = (text?: string, length = 0, right = false) => {
   return right ? str.padStart(length, ' ') : str.padEnd(length, ' ');
 };
 
-const getRelativeFilename = (filename: string) => {
-  // TODO(burdon): Hack uses "packages" as an anchor (pre-parse NX?)
-  // Including `packages/` part of the path so that excluded paths (e.g. from dist) are clickable in vscode.
-  const match = filename.match(/.+\/(packages\/.+\/.+)/);
-  if (match) {
-    const [, filePath] = match;
-    return filePath;
-  }
-
-  return filename;
-};
-
 // TODO(burdon): Optional package name.
 // TODO(burdon): Show exceptions on one line.
 export type FormatParts = {
@@ -53,10 +42,9 @@ export type Formatter = (config: LogConfig, parts: FormatParts) => (string | und
 
 export const DEFAULT_FORMATTER: Formatter = (
   config,
-  { path, line, timestamp, level, message, context, error, scope },
-) => {
+  { path, line, level, message, context, error, scope },
+): string[] => {
   const column = config.options?.formatter?.column;
-
   const filepath = path !== undefined && line !== undefined ? chalk.grey(`${path}:${line}`) : undefined;
 
   let instance;
@@ -86,11 +74,13 @@ export const DEFAULT_FORMATTER: Formatter = (
       ];
 };
 
-export const SHORT_FORMATTER: Formatter = (config, { path, level, message }) => [
-  chalk.grey(truncate(path, 16, true)), // NOTE: Breaks terminal linking.
-  chalk[LEVEL_COLORS[level]](shortLevelName[level]),
-  message,
-];
+export const SHORT_FORMATTER: Formatter = (config, { path, level, message }) => {
+  return [
+    chalk.grey(truncate(path, 16, true)), // NOTE: Breaks terminal linking.
+    chalk[LEVEL_COLORS[level]](shortLevelName[level]),
+    message,
+  ];
+};
 
 // TODO(burdon): Config option.
 const formatter = DEFAULT_FORMATTER;

package/src/processors/file-processor.ts

@@ -5,35 +5,78 @@
 import { appendFileSync, mkdirSync, openSync } from 'node:fs';
 import { dirname } from 'node:path';
 
-import { jsonify } from '@dxos/util';
+import { jsonlogify } from '@dxos/util';
 
-import { LogLevel } from '../config';
-import { type LogProcessor, getContextFromEntry } from '../context';
+import { getRelativeFilename } from './common';
+import { type LogFilter, LogLevel } from '../config';
+import { type LogProcessor, getContextFromEntry, shouldLog } from '../context';
 
-export const createFileProcessor = ({ path, levels }: { path: string; levels: LogLevel[] }): LogProcessor => {
+// Amount of time to retry writing after encountering EAGAIN before giving up.
+const EAGAIN_MAX_DURATION = 1000;
+/**
+ * Create a file processor.
+ * @param path - Path to log file to create or append to, or existing open file descriptor e.g. stdout.
+ * @param levels - Log levels to process. Takes preference over Filters.
+ * @param filters - Filters to apply.
+ */
+export const createFileProcessor = ({
+  pathOrFd,
+  levels,
+  filters,
+}: {
+  pathOrFd: string | number;
+  levels: LogLevel[];
+  filters?: LogFilter[];
+}): LogProcessor => {
   let fd: number | undefined;
 
   return (config, entry) => {
-    if (!levels.includes(entry.level)) {
+    if (levels.length > 0 && !levels.includes(entry.level)) {
       return;
     }
-    if (!fd) {
+    if (!shouldLog(entry, filters)) {
+      return;
+    }
+    if (typeof pathOrFd === 'number') {
+      fd = pathOrFd;
+    } else {
       try {
-        mkdirSync(dirname(path));
+        mkdirSync(dirname(pathOrFd));
       } catch {}
-      fd = openSync(path, 'w');
+      fd = openSync(pathOrFd, 'w');
     }
 
     const record = {
       ...entry,
       timestamp: Date.now(),
-      meta: {
-        file: entry.meta?.F,
-        line: entry.meta?.L,
-      },
-      context: jsonify(getContextFromEntry(entry)),
+      ...(entry.meta ? { meta: { file: getRelativeFilename(entry.meta.F), line: entry.meta.L } } : {}),
+      context: jsonlogify(getContextFromEntry(entry)),
     };
-    appendFileSync(fd, JSON.stringify(record) + '\n');
+    let retryTS: number = 0;
+
+    // Retry writing if EAGAIN is encountered.
+    //
+    // Node may set stdout and stderr to non-blocking. https://github.com/nodejs/node/issues/42826
+    // This can cause EAGAIN errors when writing to them.
+    // In order to not drop logs, make log methods asynchronous, or deal with buffering/delayed writes, spin until write succeeds.
+
+    while (true) {
+      try {
+        return appendFileSync(fd, JSON.stringify(record) + '\n');
+      } catch (err: any) {
+        if (err.code !== 'EAGAIN') {
+          throw err;
+        }
+        if (retryTS === 0) {
+          retryTS = performance.now();
+        } else {
+          if (performance.now() - retryTS > EAGAIN_MAX_DURATION) {
+            console.log(`could not write after ${EAGAIN_MAX_DURATION}ms of EAGAIN failures, giving up`);
+            throw err;
+          }
+        }
+      }
+    }
   };
 };
 
@@ -47,6 +90,6 @@ const getLogFilePath = () => {
 };
 
 export const FILE_PROCESSOR: LogProcessor = createFileProcessor({
-  path: getLogFilePath(),
+  pathOrFd: getLogFilePath(),
   levels: [LogLevel.ERROR, LogLevel.WARN, LogLevel.INFO, LogLevel.TRACE],
 });