feat: add logger class util in @metamask/snap-networks-utils

packages/snap-networks-utils/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- **BREAKING** Replace the logger utilities with a configurable `Logger` class that requires a log level and supports level filtering, per-instance prefixes, and method decorators.
+
 ## [1.0.0]
 
 ### Added

packages/snap-networks-utils/README.md

@@ -18,16 +18,6 @@ yarn workspace @metamask/tron-wallet-snap add @metamask/snap-networks-utils@work
 
 ## Usage
 
-### Logger
-
-```typescript
-import { logger, createPrefixedLogger } from '@metamask/snap-networks-utils';
-// or: import { logger } from '@metamask/snap-networks-utils/logger';
-
-const snapLogger = createPrefixedLogger(logger, '[tron-wallet-snap]');
-snapLogger.info('account synced');
-```
-
 ### Core AssetsController reads
 
 Wire the Snap messenger endowment, then pass it to `AssetsProvider`:

packages/snap-networks-utils/package.json

@@ -34,12 +34,12 @@
     },
     "./logger": {
       "import": {
-        "types": "./dist/logger.d.mts",
-        "default": "./dist/logger.mjs"
+        "types": "./dist/logger/index.d.mts",
+        "default": "./dist/logger/index.mjs"
       },
       "require": {
-        "types": "./dist/logger.d.cts",
-        "default": "./dist/logger.cjs"
+        "types": "./dist/logger/index.d.cts",
+        "default": "./dist/logger/index.cjs"
       }
     },
     "./package.json": "./package.json"
@@ -64,6 +64,7 @@
     "@metamask/assets-controller": "^13.0.0",
     "@metamask/remote-feature-flag-controller": "^5.0.0",
     "@metamask/snaps-sdk": "^11.2.0",
+    "@metamask/superstruct": "^3.4.1",
     "@metamask/utils": "^11.9.0"
   },
   "devDependencies": {

packages/snap-networks-utils/src/index.ts

@@ -1,5 +1,3 @@
-export type { Logger } from './logger';
-export { createPrefixedLogger, logger, noOpLogger } from './logger';
 export {
   ASSETS_PROVIDER_NAME,
   AssetsProvider,

packages/snap-networks-utils/src/logger/Logger.test.ts

@@ -0,0 +1,178 @@
+import { Logger, LogLevel } from './Logger';
+
+const loggerMethodConfigurations = [
+  { method: 'log', consoleMethod: 'info', filteredAt: LogLevel.WARN },
+  { method: 'info', consoleMethod: 'info', filteredAt: LogLevel.WARN },
+  { method: 'warn', consoleMethod: 'warn', filteredAt: LogLevel.ERROR },
+  { method: 'error', consoleMethod: 'error', filteredAt: LogLevel.SILENT },
+  { method: 'debug', consoleMethod: 'debug', filteredAt: LogLevel.INFO },
+  { method: 'trace', consoleMethod: 'trace', filteredAt: LogLevel.DEBUG },
+] as const;
+
+type MockConsole = Record<
+  (typeof loggerMethodConfigurations)[number]['consoleMethod'],
+  jest.SpyInstance
+>;
+
+type SetupTestResult = {
+  loggerMethods: typeof loggerMethodConfigurations;
+  mockConsole: MockConsole;
+};
+
+const setupTest = (): SetupTestResult => {
+  jest.restoreAllMocks();
+
+  return {
+    loggerMethods: loggerMethodConfigurations,
+    mockConsole: {
+      debug: jest.spyOn(console, 'debug').mockImplementation(),
+      error: jest.spyOn(console, 'error').mockImplementation(),
+      info: jest.spyOn(console, 'info').mockImplementation(),
+      trace: jest.spyOn(console, 'trace').mockImplementation(),
+      warn: jest.spyOn(console, 'warn').mockImplementation(),
+    },
+  };
+};
+
+describe('Logger', () => {
+  it('forwards calls to the matching console method', () => {
+    const { loggerMethods, mockConsole } = setupTest();
+
+    const logger = new Logger({ level: LogLevel.TRACE });
+
+    for (const { method, consoleMethod } of loggerMethods) {
+      logger[method]('hello', 42);
+
+      expect(mockConsole[consoleMethod]).toHaveBeenCalledWith('hello', 42);
+    }
+  });
+
+  it('prefixes messages with a derived logger', () => {
+    const { mockConsole } = setupTest();
+
+    const logger = new Logger({ level: LogLevel.TRACE });
+
+    const prefixed = logger.withPrefix('[snap-networks-utils]');
+
+    prefixed.info('a');
+    prefixed.warn('b');
+    prefixed.error('c');
+    prefixed.debug('d');
+    prefixed.trace('e');
+
+    expect(mockConsole.info).toHaveBeenCalledWith('[snap-networks-utils]', 'a');
+    expect(mockConsole.warn).toHaveBeenCalledWith('[snap-networks-utils]', 'b');
+    expect(mockConsole.error).toHaveBeenCalledWith(
+      '[snap-networks-utils]',
+      'c',
+    );
+    expect(mockConsole.debug).toHaveBeenCalledWith(
+      '[snap-networks-utils]',
+      'd',
+    );
+    expect(mockConsole.trace).toHaveBeenCalledWith(
+      '[snap-networks-utils]',
+      'e',
+    );
+  });
+
+  it('combines prefixes from derived loggers', () => {
+    const { mockConsole } = setupTest();
+
+    const logger = new Logger({ level: LogLevel.TRACE });
+
+    const parentLogger = logger.withPrefix('[parent]');
+    const childLogger = parentLogger.withPrefix('[child]');
+
+    childLogger.info('message');
+
+    expect(mockConsole.info).toHaveBeenCalledWith(
+      '[parent] [child]',
+      'message',
+    );
+  });
+
+  it('logs trace messages at the trace level', () => {
+    const { mockConsole } = setupTest();
+
+    const logger = new Logger({ level: LogLevel.TRACE });
+
+    logger.trace('trace');
+
+    expect(mockConsole.trace).toHaveBeenCalledWith('trace');
+  });
+
+  it('throws when given an invalid log level', () => {
+    expect(() => new Logger({ level: '' as LogLevel })).toThrow(
+      'Expected one of `"silent","error","warn","info","debug","trace"`, but received: ""',
+    );
+    expect(() => new Logger({ level: 'verbose' as LogLevel })).toThrow(
+      'Expected one of `"silent","error","warn","info","debug","trace"`, but received: "verbose"',
+    );
+  });
+
+  it('runs decorators through the configured output', () => {
+    const decorator = jest.fn((next: (...args: unknown[]) => void) => {
+      next('decoded error');
+    });
+    const { mockConsole } = setupTest();
+
+    const baseLogger = new Logger({
+      level: LogLevel.TRACE,
+      decorators: { error: decorator },
+    });
+
+    const logger = baseLogger.withPrefix('[Solana]');
+
+    logger.error('original error');
+
+    expect(decorator).toHaveBeenCalledWith(
+      expect.any(Function),
+      'original error',
+    );
+    expect(mockConsole.error).toHaveBeenCalledWith('[Solana]', 'decoded error');
+  });
+
+  it('does not run decorators at the silent level', () => {
+    const decorator = jest.fn();
+    const { mockConsole } = setupTest();
+
+    const logger = new Logger({
+      level: LogLevel.SILENT,
+      decorators: { error: decorator },
+    });
+
+    logger.error('silent');
+
+    expect(decorator).not.toHaveBeenCalled();
+    expect(mockConsole.error).not.toHaveBeenCalled();
+  });
+
+  it('does not log calls at the silent level', () => {
+    const { loggerMethods, mockConsole } = setupTest();
+
+    const logger = new Logger({
+      level: LogLevel.SILENT,
+    });
+
+    for (const { method, consoleMethod } of loggerMethods) {
+      logger[method]('silent');
+
+      expect(mockConsole[consoleMethod]).not.toHaveBeenCalled();
+    }
+  });
+
+  it('filters messages above the configured level', () => {
+    const { loggerMethods, mockConsole } = setupTest();
+
+    for (const { method, consoleMethod, filteredAt } of loggerMethods) {
+      const logger = new Logger({
+        level: filteredAt,
+      });
+
+      logger[method]('filtered');
+
+      expect(mockConsole[consoleMethod]).not.toHaveBeenCalled();
+    }
+  });
+});