feat(extension): use @ocap/utils logger

Author: grypez

packages/extension/src/background.ts

@@ -2,11 +2,13 @@ import type { Json } from '@metamask/utils';
 import { KernelCommandMethod, isKernelCommandReply } from '@ocap/kernel';
 import type { KernelCommand } from '@ocap/kernel';
 import { ChromeRuntimeDuplexStream } from '@ocap/streams/browser';
-import { delay } from '@ocap/utils';
+import { delay, Logger } from '@ocap/utils';
 
 const OFFSCREEN_DOCUMENT_PATH = '/offscreen.html';
 
-main().catch(console.error);
+const logger = new Logger('background');
+
+main().catch(logger.error);
 
 /**
  * The main function for the background script.
@@ -56,22 +58,22 @@ async function main(): Promise<void> {
     sendClusterCommand({
       method: KernelCommandMethod.ping,
       params: [],
-    }).catch(console.error);
+    }).catch(logger.error);
   });
 
   // Handle replies from the offscreen document
   for await (const message of offscreenStream) {
     if (!isKernelCommandReply(message)) {
-      console.error('Background received unexpected message', message);
+      logger.error('Background received unexpected message', message);
       continue;
     }
 
     switch (message.method) {
       case KernelCommandMethod.ping:
-        console.log(message.params);
+        logger.info('Background received ping reply', message.params);
         break;
       default:
-        console.error(
+        logger.error(
           // @ts-expect-error Compile-time exhaustiveness check
           `Background received unexpected command method: "${message.method.valueOf()}"`,
         );

packages/extension/src/iframe.ts

@@ -4,8 +4,11 @@ import {
   MessagePortDuplexStream,
   receiveMessagePort,
 } from '@ocap/streams/browser';
+import { Logger } from '@ocap/utils';
 
-main().catch(console.error);
+const logger = new Logger('iframe');
+
+main().catch(logger.error);
 
 /**
  * The main function for the iframe.
@@ -30,5 +33,5 @@ async function main(): Promise<void> {
     commandStream,
   });
 
-  console.log('VatSupervisor initialized with vatId:', vatId);
+  logger.info('VatSupervisor initialized with vatId:', vatId);
 }

packages/extension/src/kernel-integration/iframe-vat-worker.ts

@@ -1,6 +1,7 @@
 import { createWindow } from '@metamask/snaps-utils';
 import type { VatId, VatConfig } from '@ocap/kernel';
 import type { initializeMessageChannel } from '@ocap/streams/browser';
+import { Logger } from '@ocap/utils';
 
 import type { VatWorker } from './VatWorkerServer.ts';
 
@@ -9,6 +10,7 @@ const IFRAME_URI = 'iframe.html';
 export const makeIframeVatWorker = (
   id: VatId,
   getPort: typeof initializeMessageChannel,
+  logger: Logger,
 ): VatWorker => {
   const vatHtmlId = `ocap-iframe-${id}`;
   return {
@@ -27,7 +29,7 @@ export const makeIframeVatWorker = (
     terminate: async (): Promise<void> => {
       const iframe = document.getElementById(vatHtmlId);
       if (iframe === null) {
-        console.error(
+        logger.error(
           `iframe of vat with id "${id}" already removed from DOM (#${vatHtmlId})`,
         );
         return undefined;

packages/extension/src/kernel-integration/kernel-worker.ts

@@ -11,14 +11,14 @@ import {
   MessagePortDuplexStream,
   receiveMessagePort,
 } from '@ocap/streams/browser';
-import { fetchValidatedJson, makeLogger } from '@ocap/utils';
+import { fetchValidatedJson, Logger } from '@ocap/utils';
 
-import { loggingMiddleware } from './middleware/logging.ts';
+import { makeLoggingMiddleware } from './middleware/logging.ts';
 import { createPanelMessageMiddleware } from './middleware/panel-message.ts';
 import { receiveUiConnections } from './ui-connections.ts';
 import { ExtensionVatWorkerClient } from './VatWorkerClient.ts';
 
-const logger = makeLogger('[kernel worker]');
+const logger = new Logger('kernel-worker');
 const DB_FILENAME = 'store.db';
 
 // XXX Warning: Setting this flag to true causes persistent storage to be
@@ -63,7 +63,7 @@ async function main(): Promise<void> {
     },
   );
   const kernelEngine = new JsonRpcEngine();
-  kernelEngine.push(loggingMiddleware);
+  kernelEngine.push(makeLoggingMiddleware(logger.subLogger('kernel-command')));
   kernelEngine.push(createPanelMessageMiddleware(kernel, kernelDatabase));
   receiveUiConnections(async (request) => kernelEngine.handle(request), logger);
   const launchDefaultSubcluster = firstTime || ALWAYS_RESET_STORAGE;
@@ -88,9 +88,9 @@ async function main(): Promise<void> {
     (async () => {
       if (launchDefaultSubcluster) {
         const result = await kernel.launchSubcluster(defaultSubcluster);
-        console.log(`Subcluster launched: ${JSON.stringify(result)}`);
+        logger.info(`Subcluster launched: ${JSON.stringify(result)}`);
       } else {
-        console.log(`Resuming kernel execution`);
+        logger.info(`Resuming kernel execution`);
       }
     })(),
   ]);

packages/extension/src/kernel-integration/middleware/logging.test.ts

@@ -3,17 +3,20 @@ import {
   JsonRpcEngine,
 } from '@metamask/json-rpc-engine';
 import type { JsonRpcRequest, JsonRpcSuccess } from '@metamask/utils';
+import { Logger } from '@ocap/utils';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-import { loggingMiddleware, logger } from './logging.ts';
+import { makeLoggingMiddleware } from './logging.ts';
 
 describe('loggingMiddleware', () => {
   let engine: JsonRpcEngine;
+  let logger: Logger;
 
   beforeEach(() => {
     vi.clearAllMocks();
     engine = new JsonRpcEngine();
-    engine.push(loggingMiddleware);
+    logger = new Logger('test');
+    engine.push(makeLoggingMiddleware(logger));
   });
 
   it('should pass the request to the next middleware', async () => {

packages/extension/src/kernel-integration/middleware/logging.ts

@@ -1,11 +1,11 @@
 import { createAsyncMiddleware } from '@metamask/json-rpc-engine';
 import type { JsonRpcMiddleware } from '@metamask/json-rpc-engine';
 import type { Json, JsonRpcParams } from '@metamask/utils';
-import { makeLogger } from '@ocap/utils';
+import { Logger } from '@ocap/utils';
 
-export const logger = makeLogger('[kernel-commands]');
-
-export const loggingMiddleware: JsonRpcMiddleware<JsonRpcParams, Json> =
+export const makeLoggingMiddleware = (
+  logger: Logger,
+): JsonRpcMiddleware<JsonRpcParams, Json> =>
   createAsyncMiddleware(async (_req, _res, next) => {
     const start = performance.now();
     // eslint-disable-next-line n/callback-return

packages/extension/src/kernel-integration/middleware/panel-message.test.ts

@@ -56,17 +56,16 @@ describe('createPanelMessageMiddleware', () => {
 
     // Process the request
     const response = await engine.handle(request);
-    console.log('response', response);
-
-    // Verify the middleware called execute with the right parameters
-    expect(mockExecute).toHaveBeenCalledWith('testMethod1', { foo: 'bar' });
 
     // Verify the response contains the expected result
     expect(response).toStrictEqual({
       id: 1,
       jsonrpc: '2.0',
       result: expectedResult,
     });
+
+    // Verify the middleware called execute with the right parameters
+    expect(mockExecute).toHaveBeenCalledWith('testMethod1', { foo: 'bar' });
   });
 
   it('should handle command execution with empty params', async () => {

packages/extension/src/kernel-integration/ui-connections.test.ts

@@ -2,6 +2,7 @@ import type { JsonRpcRequest, JsonRpcResponse } from '@metamask/utils';
 import type { PostMessageTarget } from '@ocap/streams/browser';
 import { delay } from '@ocap/test-utils';
 import { TestDuplexStream } from '@ocap/test-utils/streams';
+import type { Logger } from '@ocap/utils';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 import {
@@ -86,11 +87,10 @@ vi.stubGlobal('BroadcastChannel', MockBroadcastChannel);
 
 const makeMockLogger = () =>
   ({
-    ...console,
-    label: 'test-logger',
     debug: vi.fn(),
     error: vi.fn(),
-  }) as Console & { label: string };
+    info: vi.fn(),
+  }) as unknown as Logger;
 
 describe('ui-connections', () => {
   beforeEach(() => {

packages/extension/src/offscreen.ts

@@ -7,12 +7,12 @@ import {
   MessagePortDuplexStream,
 } from '@ocap/streams/browser';
 import type { PostMessageTarget } from '@ocap/streams/browser';
-import { delay, makeLogger } from '@ocap/utils';
+import { delay, Logger } from '@ocap/utils';
 
 import { makeIframeVatWorker } from './kernel-integration/iframe-vat-worker.ts';
 import { ExtensionVatWorkerService } from './kernel-integration/VatWorkerServer.ts';
 
-const logger = makeLogger('[offscreen]');
+const logger = new Logger('offscreen');
 
 main().catch(logger.error);
 
@@ -61,7 +61,14 @@ async function makeKernelWorker(): Promise<{
 
   const vatWorkerService = ExtensionVatWorkerService.make(
     worker as PostMessageTarget,
-    (vatId) => makeIframeVatWorker(vatId, initializeMessageChannel),
+    (vatId) =>
+      makeIframeVatWorker(
+        vatId,
+        initializeMessageChannel,
+        logger.subLogger({
+          tags: ['iframe-vat-worker', vatId],
+        }),
+      ),
   );
 
   return {