fix(logger): pass loggerOverride string as log level to chunk logger

When users passed a string level like "error" via loggerOverride in
generatePlatformLogger, it was not being passed through to the chunk
logger. This caused all logs to be forwarded to console regardless of
the configured level.

The fix ensures that when loggerOverride is a string, it's used as the
log level in the opts passed to generateClientLogger/generateServerLogger.

Additionally, fixed generateServerLogger to use browser.write in addition
to the destination stream. The bundled pino-browser ignores the destination
argument, so browser.write is needed for the bundled version while the
destination stream is needed for Node.js tests.

- All logs are still captured in memory (pino level remains "trace")
- Only logs at configured level or higher are forwarded to console
- Added tests to verify loggerOverride string is respected

Bump version to 3.0.2

Author: ganchoradkov

misc/logger/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@walletconnect/logger",
   "description": "Logger Utils",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "author": "WalletConnect, Inc. <walletconnect.com>",
   "license": "MIT",
   "homepage": "https://github.com/WalletConnect/walletconnect-utils/",
@@ -64,4 +64,4 @@
     "@walletconnect/safe-json": "^1.0.2",
     "pino": "10.0.0"
   }
-}
+}

misc/logger/src/utils.ts

@@ -76,10 +76,15 @@ export function generateServerLogger(params: { maxSizeInBytes?: number; opts?: L
   chunkLoggerController: ServerChunkLogger;
 } {
   const serverLogger = new ServerChunkLogger(params.opts?.level, params.maxSizeInBytes);
+  // Use both destination stream (for Node.js pino) and browser.write (for bundled pino-browser)
   const logger = pino(
     {
       ...params.opts,
       level: "trace",
+      browser: {
+        ...params.opts?.browser,
+        write: (obj) => serverLogger.write(obj),
+      },
     },
     serverLogger,
   );
@@ -102,9 +107,15 @@ export function generatePlatformLogger(params: {
     };
   }
 
+  // When loggerOverride is a string, use it as the log level
+  const opts: LoggerOptions = {
+    ...params.opts,
+    level: typeof params.loggerOverride === "string" ? params.loggerOverride : params.opts?.level,
+  };
+
   if (typeof window !== "undefined") {
-    return generateClientLogger(params);
+    return generateClientLogger({ ...params, opts });
   } else {
-    return generateServerLogger(params);
+    return generateServerLogger({ ...params, opts });
   }
 }

misc/logger/test/index.test.ts

@@ -9,6 +9,7 @@ import {
   getDefaultLoggerOptions,
   generateChildLogger,
   generateServerLogger,
+  generatePlatformLogger,
 } from "../src";
 
 describe("Logger", () => {
@@ -252,5 +253,77 @@ describe("Logger", () => {
         chai.expect(logArray.filter((log) => log.includes(pString)).length).eq(1);
       });
     });
+
+    describe("Platform Logger", () => {
+      let consoleTrace: sinon.SinonStub;
+      let consoleDebug: sinon.SinonStub;
+      let consoleLog: sinon.SinonStub;
+      let consoleWarn: sinon.SinonStub;
+      let consoleError: sinon.SinonStub;
+
+      beforeEach(() => {
+        consoleTrace = sinon.stub(console, "trace");
+        consoleDebug = sinon.stub(console, "debug");
+        consoleLog = sinon.stub(console, "log");
+        consoleWarn = sinon.stub(console, "warn");
+        consoleError = sinon.stub(console, "error");
+      });
+
+      afterEach(() => {
+        consoleTrace.restore();
+        consoleDebug.restore();
+        consoleLog.restore();
+        consoleWarn.restore();
+        consoleError.restore();
+      });
+
+      it("Respects loggerOverride string as log level for console output", () => {
+        // Use "warn" level (NOT "error") to avoid coincidentally matching the default
+        // The default level in BaseChunkLogger is "error", so using "error" here
+        // would pass even if loggerOverride is not properly passed through
+        const { logger, chunkLoggerController } = generatePlatformLogger({
+          loggerOverride: "warn",
+        });
+
+        logger.trace("trace message");
+        logger.debug("debug message");
+        logger.info("info message");
+        logger.warn("warn message");
+        logger.error("error message");
+
+        const logArray = chunkLoggerController!.getLogArray();
+
+        // All logs should be stored in memory
+        chai.expect(logArray.length).eq(5);
+
+        // Only warn and error should be forwarded to console
+        chai.expect(consoleTrace.called).eq(false);
+        chai.expect(consoleDebug.called).eq(false);
+        chai.expect(consoleLog.called).eq(false);
+        chai.expect(consoleWarn.called).eq(true);
+        chai.expect(consoleError.called).eq(true);
+      });
+
+      it("Stores all logs in memory regardless of level", () => {
+        const { logger, chunkLoggerController } = generatePlatformLogger({
+          loggerOverride: "warn",
+        });
+
+        logger.trace("trace");
+        logger.debug("debug");
+        logger.info("info");
+        logger.warn("warn");
+        logger.error("error");
+
+        const logArray = chunkLoggerController!.getLogArray();
+
+        // All 5 logs should be stored
+        chai.expect(logArray.filter((log) => log.includes("trace")).length).eq(1);
+        chai.expect(logArray.filter((log) => log.includes("debug")).length).eq(1);
+        chai.expect(logArray.filter((log) => log.includes("info")).length).eq(1);
+        chai.expect(logArray.filter((log) => log.includes("warn")).length).eq(1);
+        chai.expect(logArray.filter((log) => log.includes("error")).length).eq(1);
+      });
+    });
   });
 });