@dxos/log 0.8.3 → 0.8.4-main.03d5cd7b56

package/src/log.test.ts

@@ -3,10 +3,11 @@
 //
 
 import path from 'node:path';
-import { describe, test } from 'vitest';
+import { beforeEach, describe, test } from 'vitest';
 
 import { LogLevel } from './config';
-import { log } from './log';
+import { shouldLog } from './context';
+import { type Log, createLog } from './log';
 
 class LogError extends Error {
   constructor(
@@ -24,14 +25,53 @@ class LogError extends Error {
   }
 }
 
-log.config({
-  filter: LogLevel.DEBUG,
-});
+describe('log', () => {
+  let log!: Log;
+
+  beforeEach(() => {
+    log = createLog();
+    log.config({
+      filter: LogLevel.DEBUG,
+    });
+  });
 
-/* eslint-disable @stayradiated/prefer-arrow-functions/prefer-arrow-functions */
+  test('filters', ({ expect }) => {
+    const tests = [
+      { expected: 0, filter: 'ERROR' },
+      { expected: 2, filter: 'INFO' },
+      { expected: 1, filter: 'foo:INFO' },
+      { expected: 4, filter: 'DEBUG' },
+      { expected: 2, filter: 'DEBUG,-foo:*' },
+      { expected: 1, filter: 'INFO,-foo:*' },
+      { expected: 3, filter: 'DEBUG,-foo:INFO' },
+      { expected: 3, filter: 'foo:DEBUG,bar:INFO' },
+    ];
+
+    for (const test of tests) {
+      let count = 0;
+      const log = createLog();
+      const remove = log.addProcessor((config, entry) => {
+        if (shouldLog(entry, config.filters)) {
+          count++;
+        }
+      });
+      log.config({
+        filter: test.filter,
+      });
+
+      console.group(`Filter: "${test.filter}"`);
+      log.debug('line 1', {}, { F: 'foo.ts', L: 1, S: undefined });
+      log.info('line 2', {}, { F: 'foo.ts', L: 2, S: undefined });
+      log.debug('line 3', {}, { F: 'bar.ts', L: 3, S: undefined });
+      log.info('line 4', {}, { F: 'bar.ts', L: 4, S: undefined });
+      console.groupEnd();
+
+      expect(count, `Filter: "${test.filter}"`).toBe(test.expected);
+      remove();
+    }
+  });
 
-describe('log', function () {
-  test('throws an error', function () {
+  test('throws an error', () => {
     try {
       throw new LogError('Test failed', { value: 1 });
     } catch (err: any) {
@@ -39,7 +79,7 @@ describe('log', function () {
     }
   });
 
-  test('throws an error showing stacktrace', function () {
+  test('throws an error showing stacktrace', () => {
     try {
       throw new LogError('Test failed', { value: 2 });
     } catch (err: any) {
@@ -47,7 +87,7 @@ describe('log', function () {
     }
   });
 
-  test('catches an error', function () {
+  test('catches an error', () => {
     try {
       throw new LogError('ERROR ON LINE 21', { value: 3 });
     } catch (err: any) {
@@ -55,17 +95,7 @@ describe('log', function () {
     }
   });
 
-  test('config', function () {
-    log.config({
-      filter: LogLevel.INFO,
-    });
-
-    log.debug('Debug level log message');
-    log.info('Info level log message');
-    log.warn('Warn level log message');
-  });
-
-  test('config file', function () {
+  test('config file', () => {
     log.config({
       file: path.join('packages/common/log/test-config.yml'),
     });
@@ -75,7 +105,7 @@ describe('log', function () {
     log.warn('Warn level log message');
   });
 
-  test('levels', function () {
+  test('levels', () => {
     log('Default level log message');
     log.debug('Debug level log message');
     log.info('Info level log message');
@@ -83,10 +113,15 @@ describe('log', function () {
     log.error('Error level log message');
   });
 
-  test('context', function () {
+  test('context', () => {
     log.info('Message with context', {
       title: 'test',
       context: 123,
     });
   });
+
+  test('error', () => {
+    const myError = new Error('Test error', { cause: new Error('Cause') });
+    log.catch(myError);
+  });
 });

package/src/log.ts

@@ -3,10 +3,19 @@
 //
 
 import { type LogConfig, LogLevel, type LogOptions } from './config';
-import { type LogContext, type LogProcessor } from './context';
+import { type LogContext, LogEntry, type LogProcessor } from './context';
 import { createFunctionLogDecorator, createMethodLogDecorator } from './decorators';
 import { type CallMetadata } from './meta';
-import { getConfig, DEFAULT_PROCESSORS } from './options';
+import { createConfig } from './options';
+
+/**
+ * Accessible from browser console.
+ * Example: `DX_LOG.config({ filter: 'ERROR' })`
+ * NOTE: File level filtering isn't supported in storybooks.
+ */
+declare global {
+  const DX_LOG: Log;
+}
 
 /**
  * Logging function.
@@ -17,99 +26,185 @@ type LogFunction = (message: string, context?: LogContext, meta?: CallMetadata)
  * Logging methods.
  */
 export interface LogMethods {
+  config: (options?: LogOptions) => Log;
+  addProcessor: (processor: LogProcessor, addDefault?: boolean) => () => void;
+
+  /**
+   * Log at `trace` level.
+   *
+   * Generally not surfaced to the developer and not captured in a log file.
+   */
   trace: LogFunction;
+
+  /**
+   * Log at `debug` level.
+   * Generally not surfaced to the developer and captured in a log file.
+   */
   debug: LogFunction;
+
+  /**
+   * Log at `verbose` level.
+   * Generally not surfaced to the developer and not captured in a log file.
+   */
   verbose: LogFunction;
+
+  /**
+   * Log at `info` level.
+   * Generally surfaced to the developer and captured in a log file.
+   */
   info: LogFunction;
+
+  /**
+   * Log at `warn` level.
+   * Generally surfaced to the developer and captured in a log file.
+   */
   warn: LogFunction;
+
+  /**
+   * Log at `error` level.
+   * Generally surfaced to the developer and captured in a log file.
+   */
   error: LogFunction;
+
+  /**
+   * Log an error and its stack trace at an `error` level.
+   * Generally surfaced to the developer and captured in a log file.
+   */
   catch: (error: Error | any, context?: LogContext, meta?: CallMetadata) => void;
-  break: () => void;
-  stack: (message?: string, context?: never, meta?: CallMetadata) => void;
+
+  /**
+   * Decorator to log method parameters and return value at the `info` level.
+   */
   method: (arg0?: never, arg1?: never, meta?: CallMetadata) => MethodDecorator;
-  func: <F extends (...args: any[]) => any>(
+
+  /**
+   * Wrapper to log function parameters and return value at the `info` level.
+   */
+  function: <F extends (...args: any[]) => any>(
     name: string,
     fn: F,
-    opts?: { transformOutput?: (result: ReturnType<F>) => Promise<any> | any },
+    opts?: {
+      transformOutput?: (result: ReturnType<F>) => Promise<any> | any;
+    },
   ) => F;
+
+  /**
+   * Log a horizontal rule at the `info` level.
+   */
+  break: () => void;
+
+  /**
+   * Log a stack trace at the `info` level.
+   */
+  stack: (message?: string, context?: never, meta?: CallMetadata) => void;
 }
 
 /**
  * Properties accessible on the logging function.
+ * @internal
  */
-interface Log extends LogMethods, LogFunction {
-  config: (options: LogOptions) => void;
-  addProcessor: (processor: LogProcessor) => void;
-  runtimeConfig: LogConfig;
+export interface Log extends LogFunction, LogMethods {
+  readonly runtimeConfig: LogConfig;
 }
 
+/**
+ * @internal
+ */
 interface LogImp extends Log {
+  _id: string;
   _config: LogConfig;
 }
 
-const createLog = (): LogImp => {
-  const log: LogImp = ((...params) => processLog(LogLevel.DEBUG, ...params)) as LogImp;
-
-  log._config = getConfig();
-  Object.defineProperty(log, 'runtimeConfig', { get: () => log._config });
-
-  log.addProcessor = (processor: LogProcessor) => {
-    if (DEFAULT_PROCESSORS.filter((p) => p === processor).length === 0) {
-      DEFAULT_PROCESSORS.push(processor);
-    }
-    if (log._config.processors.filter((p) => p === processor).length === 0) {
-      log._config.processors.push(processor);
-    }
-  };
+let logCount = 0;
 
-  // Set config.
-  log.config = (options: LogOptions) => {
-    log._config = getConfig(options);
-  };
-
-  // TODO(burdon): API to set context and separate error object.
-  //  E.g., log.warn('failed', { key: 123 }, err);
-
-  log.trace = (...params) => processLog(LogLevel.TRACE, ...params);
-  log.debug = (...params) => processLog(LogLevel.DEBUG, ...params);
-  log.verbose = (...params) => processLog(LogLevel.VERBOSE, ...params);
-  log.info = (...params) => processLog(LogLevel.INFO, ...params);
-  log.warn = (...params) => processLog(LogLevel.WARN, ...params);
-  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?.message ?? String(error), context, meta, error);
-
-  // Show break.
-  log.break = () => log.info('——————————————————————————————————————————————————');
+/**
+ * Create a logging function with properties.
+ * @internal
+ */
+export const createLog = (): LogImp => {
+  // Default function.
+  const log: LogImp = ((...params) => processLog(LogLevel.DEBUG, ...params)) as LogImp;
 
-  log.stack = (message, context, meta) =>
-    processLog(LogLevel.INFO, `${message ?? 'Stack Dump'}\n${getFormattedStackTrace()}`, context, meta);
+  // Add private properties.
+  Object.assign<LogImp, Partial<LogImp>>(log, {
+    _id: `log-${++logCount}`,
+    _config: createConfig(),
+  });
 
-  log.method = createMethodLogDecorator(log);
-  log.func = createFunctionLogDecorator(log);
+  // TODO(burdon): Document.
+  Object.defineProperty(log, 'runtimeConfig', {
+    get: () => log._config,
+  });
 
   /**
    * Process the current log call.
    */
   const processLog = (
     level: LogLevel,
-    message: string,
+    message: string | undefined,
     context: LogContext = {},
     meta?: CallMetadata,
     error?: Error,
   ) => {
-    log._config.processors.forEach((processor) => processor(log._config, { level, message, context, meta, error }));
+    // TODO(burdon): Do the filter matching upstream (here) rather than in each processor?
+    const entry = new LogEntry({ level, message, context, meta, error });
+    log._config.processors.forEach((processor) => processor(log._config, entry));
   };
 
+  /**
+   * API.
+   */
+  Object.assign<Log, LogMethods>(log, {
+    /**
+     * Update config.
+     * NOTE: Preserves any processors that were already added to this logger instance
+     * unless an explicit processor option is provided.
+     */
+    config: ({ processor, ...options } = {}) => {
+      const config = createConfig(options);
+      // TODO(burdon): This could be buggy since the behavior is not reentrant.
+      const processors = processor ? config.processors : log._config.processors;
+      log._config = { ...config, processors };
+      return log;
+    },
+
+    /**
+     * Adds a processor to the logger.
+     */
+    addProcessor: (processor) => {
+      if (log._config.processors.filter((p) => p === processor).length === 0) {
+        log._config.processors.push(processor);
+      }
+
+      return () => {
+        log._config.processors = log._config.processors.filter((p) => p !== processor);
+      };
+    },
+
+    trace: (...params) => processLog(LogLevel.TRACE, ...params),
+    debug: (...params) => processLog(LogLevel.DEBUG, ...params),
+    verbose: (...params) => processLog(LogLevel.VERBOSE, ...params),
+    info: (...params) => processLog(LogLevel.INFO, ...params),
+    warn: (...params) => processLog(LogLevel.WARN, ...params),
+    error: (...params) => processLog(LogLevel.ERROR, ...params),
+    catch: (error, context, meta) => processLog(LogLevel.ERROR, undefined, context, meta, error),
+
+    method: createMethodLogDecorator(log),
+    function: createFunctionLogDecorator(log),
+
+    break: () => log.info('-'.repeat(80)),
+    stack: (message, context, meta) => {
+      return processLog(LogLevel.INFO, `${message ?? 'Stack Dump'}\n${getFormattedStackTrace()}`, context, meta);
+    },
+  });
+
   return log;
 };
 
 /**
  * Global logging function.
  */
-export const log: Log = ((globalThis as any).dx_log ??= createLog());
+export const log: Log = ((globalThis as any).DX_LOG ??= createLog());
 
 const start = Date.now();
 let last = start;
@@ -129,12 +224,4 @@ export const debug = (label?: any, args?: any) => {
   last = Date.now();
 };
 
-/**
- * Accessible from browser console.
- */
-declare global {
-  // eslint-disable-next-line camelcase
-  const dx_log: Log;
-}
-
 const getFormattedStackTrace = () => new Error().stack!.split('\n').slice(3).join('\n');

package/src/meta.ts

@@ -3,11 +3,27 @@
 //
 
 /**
- * Metadata injected b y the log transform plugin.
+ * Marker key + value injected on every {@link CallMetadata} object by the log transform plugin.
+ * Used by {@link isLogMeta} to detect a log-meta argument at runtime (e.g. for variadic
+ * `param_index: 'last'` callees that don't have a fixed meta slot).
+ */
+export const LOG_META_MARKER = '~LogMeta';
+
+/**
+ * Metadata injected by the log transform plugin.
  *
  * Field names are intentionally short to reduce the size of the generated code.
  */
 export interface CallMetadata {
+  /**
+   * Marker tag — when present, equal to {@link LOG_META_MARKER} ({@link `'~LogMeta'`}).
+   * Injected by the log transform plugin on every emitted meta object so that {@link isLogMeta}
+   * can distinguish a meta argument from a regular user-supplied value at runtime.
+   * Optional because hand-written `CallMetadata` literals (decorators, RPC mappers, tests)
+   * don't need the marker — they are recognized by position in the call signature.
+   */
+  '~LogMeta'?: typeof LOG_META_MARKER;
+
   /**
    * File name.
    */
@@ -35,3 +51,15 @@ export interface CallMetadata {
    */
   A?: string[];
 }
+
+/**
+ * Type guard: `true` when `value` is a {@link CallMetadata} object emitted by the log transform plugin.
+ * Detection is based on the presence of the {@link LOG_META_MARKER} marker key/value.
+ */
+export const isLogMeta = (value: unknown): value is CallMetadata => {
+  return (
+    value != null &&
+    typeof value === 'object' &&
+    (value as Record<string, unknown>)[LOG_META_MARKER] === LOG_META_MARKER
+  );
+};

package/src/options.ts

@@ -7,37 +7,53 @@ import defaultsDeep from 'lodash.defaultsdeep';
 import { type LogConfig, type LogFilter, LogLevel, type LogOptions, LogProcessorType, levels } from './config';
 import { type LogProcessor } from './context';
 import { loadOptions } from './platform';
-import { CONSOLE_PROCESSOR, DEBUG_PROCESSOR, BROWSER_PROCESSOR } from './processors';
+import { BROWSER_PROCESSOR, CONSOLE_PROCESSOR, DEBUG_PROCESSOR } from './processors';
 
 /**
  * Processor variants.
  */
-export const processors: { [index: string]: LogProcessor } = {
+export const processors: Record<string, LogProcessor> = {
   [LogProcessorType.CONSOLE]: CONSOLE_PROCESSOR,
   [LogProcessorType.BROWSER]: BROWSER_PROCESSOR,
   [LogProcessorType.DEBUG]: DEBUG_PROCESSOR,
 };
 
-const IS_BROWSER = typeof window !== 'undefined' || typeof navigator !== 'undefined';
+const browser =
+  (typeof window !== 'undefined' || typeof navigator !== 'undefined') &&
+  !(typeof process !== 'undefined' && process?.env?.VITEST);
 
-export const DEFAULT_PROCESSORS = [IS_BROWSER ? BROWSER_PROCESSOR : CONSOLE_PROCESSOR];
+export const DEFAULT_PROCESSORS = [browser ? BROWSER_PROCESSOR : CONSOLE_PROCESSOR];
 
+const parseLogLevel = (level: string, defValue = LogLevel.WARN) => levels[level.toLowerCase()] ?? defValue;
+
+/**
+ * @internal
+ */
 export const parseFilter = (filter: string | string[] | LogLevel): LogFilter[] => {
   if (typeof filter === 'number') {
     return [{ level: filter }];
   }
 
-  const parseLogLevel = (level: string, defValue = LogLevel.WARN) => levels[level.toLowerCase()] ?? defValue;
-
   const lines = typeof filter === 'string' ? filter.split(/,\s*/) : filter;
   return lines.map((filter) => {
     const [pattern, level] = filter.split(':');
-    return level ? { level: parseLogLevel(level), pattern } : { level: parseLogLevel(pattern) };
+    return level
+      ? {
+          level: parseLogLevel(level),
+          pattern,
+        }
+      : {
+          level: parseLogLevel(pattern),
+        };
   });
 };
 
-export const getConfig = (options?: LogOptions): LogConfig => {
-  const nodeOptions: LogOptions | undefined =
+/**
+ * @internal
+ */
+export const createConfig = (options?: LogOptions): LogConfig => {
+  // Node only.
+  const envOptions: LogOptions | undefined =
     'process' in globalThis
       ? {
           file: process!.env.LOG_CONFIG,
@@ -46,12 +62,12 @@ export const getConfig = (options?: LogOptions): LogConfig => {
         }
       : undefined;
 
-  const mergedOptions: LogOptions = defaultsDeep({}, loadOptions(nodeOptions?.file), nodeOptions, options);
+  const mergedOptions: LogOptions = defaultsDeep({}, loadOptions(envOptions?.file), envOptions, options);
   return {
     options: mergedOptions,
     filters: parseFilter(mergedOptions.filter ?? LogLevel.INFO),
     captureFilters: parseFilter(mergedOptions.captureFilter ?? LogLevel.WARN),
-    processors: mergedOptions.processor ? [processors[mergedOptions.processor]] : DEFAULT_PROCESSORS,
+    processors: mergedOptions.processor ? [processors[mergedOptions.processor]] : [...DEFAULT_PROCESSORS],
     prefix: mergedOptions.prefix,
   };
 };

package/src/platform/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2022 DXOS.org
 //
 
-export * from './node';
+export * from '#platform';

package/src/processors/browser-processor.ts

@@ -2,22 +2,10 @@
 // Copyright 2022 DXOS.org
 //
 
-import { getDebugName, safariCheck } from '@dxos/util';
+import { safariCheck } from '@dxos/util';
 
 import { LogLevel } from '../config';
-import { getContextFromEntry, type LogProcessor, shouldLog } from '../context';
-
-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;
-};
+import { type LogProcessor, getContextFromEntry, shouldLog } from '../context';
 
 type Config = {
   useTestProcessor: boolean;
@@ -47,31 +35,38 @@ const APP_BROWSER_PROCESSOR: LogProcessor = (config, entry) => {
   // const LOG_BROWSER_CSS = ['color:gray; font-size:10px; padding-bottom: 4px', 'color:#B97852; font-size:14px;'];
   const LOG_BROWSER_CSS: string[] = [];
 
+  const { filename, line: lineNumber, context: scopeDebugName } = entry.computedMeta;
+
   let link = '';
-  if (entry.meta) {
-    const filename = getRelativeFilename(entry.meta.F);
+  if (filename !== undefined && lineNumber !== undefined) {
     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
-    link = `${filepath}#L${entry.meta.L}`;
+    link = `${filepath}#L${lineNumber}`;
   }
 
   let args = [];
 
-  if (entry.meta?.S) {
-    const scope = entry.meta?.S;
-    const scopeName = scope.name || getDebugName(scope);
-    const processPrefix = entry.meta.S?.hostSessionId ? '[worker] ' : '';
-    // TODO(dmaretskyi): Those can be made clickable with a custom formatter.
-    args.push(`%c${processPrefix}${scopeName}`, 'color:#C026D3;font-weight:bold');
+  const scope = entry.meta?.S;
+  if (scope) {
+    const scopeName = scope.name || scopeDebugName;
+    if (scopeName) {
+      const processPrefix = scope.hostSessionId ? '[worker] ' : '';
+      // TODO(dmaretskyi): Those can be made clickable with a custom formatter.
+      args.push(`%c${processPrefix}${scopeName}`, 'color:#C026D3;font-weight:bold');
+    }
   }
 
-  args.push(entry.message);
+  if (entry.message) {
+    args.push(entry.message);
+  }
 
   const context = getContextFromEntry(entry);
   if (context) {
     if (Object.keys(context).length === 1 && 'error' in context) {
-      args.push(context.error);
+      args.push(unwrapEffectError(context.error));
+    } else if (Object.keys(context).length === 1 && 'err' in context) {
+      args.push(unwrapEffectError(context.err));
     } else {
       args.push(context);
     }
@@ -110,10 +105,8 @@ const TEST_BROWSER_PROCESSOR: LogProcessor = (config, entry) => {
     return;
   }
 
-  let path = '';
-  if (entry.meta) {
-    path = `${getRelativeFilename(entry.meta.F)}:${entry.meta.L}`;
-  }
+  const { filename, line: lineNumber } = entry.computedMeta;
+  const path = filename !== undefined && lineNumber !== undefined ? `${filename}:${lineNumber}` : '';
 
   let args = [];
 
@@ -144,3 +137,13 @@ const TEST_BROWSER_PROCESSOR: LogProcessor = (config, entry) => {
 };
 
 export const BROWSER_PROCESSOR: LogProcessor = CONFIG.useTestProcessor ? TEST_BROWSER_PROCESSOR : APP_BROWSER_PROCESSOR;
+
+// effect-specific
+const originalSymbol = Symbol.for('effect/OriginalAnnotation');
+
+const unwrapEffectError = (error: any) => {
+  if (typeof error === 'object' && error !== null && originalSymbol in error) {
+    return error[originalSymbol];
+  }
+  return error;
+};