feat: log every rpc call across all the viem clients used

packages/automated-dispute/src/providers/protocolProvider.ts

@@ -1,5 +1,5 @@
 import { BlockNumberService, UnsupportedChain } from "@ebo-agent/blocknumber";
-import { Caip2ChainId, HexUtils, UnixTimestamp } from "@ebo-agent/shared";
+import { Caip2ChainId, HexUtils, ILogger, UnixTimestamp } from "@ebo-agent/shared";
 import {
     Account,
     Address,
@@ -115,12 +115,14 @@ export class ProtocolProvider implements IProtocolProvider {
      * @param contracts The addresses of the protocol contracts that will be instantiated
      * @param privateKey The private key of the account that will be used to interact with the contracts
      * @param blockNumberService The service that will be used to fetch block numbers
+     * @param logger The logger instance
      */
     constructor(
         private readonly rpcConfig: ProtocolRpcConfig,
         contracts: ProtocolContractsAddresses,
         privateKey: Hex,
         blockNumberService?: BlockNumberService,
+        private readonly logger?: ILogger,
     ) {
         const l1Chain = this.getViemChain(rpcConfig.l1.chainId);
         const l2Chain = this.getViemChain(rpcConfig.l2.chainId);
@@ -206,12 +208,7 @@ export class ProtocolProvider implements IProtocolProvider {
         return createPublicClient({
             chain: chain,
             transport: fallback(
-                urls.map((url) =>
-                    http(url, {
-                        timeout: timeout,
-                        retryDelay: retryInterval,
-                    }),
-                ),
+                urls.map((url) => this.createHttpTransportWithLogging(url, timeout, retryInterval)),
             ),
         });
     }
@@ -227,17 +224,57 @@ export class ProtocolProvider implements IProtocolProvider {
         return createWalletClient({
             chain: chain,
             transport: fallback(
-                urls.map((url) =>
-                    http(url, {
-                        timeout: timeout,
-                        retryDelay: retryInterval,
-                    }),
-                ),
+                urls.map((url) => this.createHttpTransportWithLogging(url, timeout, retryInterval)),
             ),
             account: account,
         });
     }
 
+    /**
+     * Creates an HTTP transport with logging capabilities for requests and responses.
+     *
+     * This function sets up a custom HTTP transport that logs the details of each
+     * HTTP request and response, including the URL, method, headers, and body.
+     * The logging captures and logs the cloned `Request` and `Response` objects,
+     * ensuring the original objects remain unaltered.
+     *
+     * @param {string} url - The base URL for the HTTP transport.
+     * @param {number} timeout - The timeout duration in milliseconds for each HTTP request.
+     * @param {number} retryInterval - The delay in milliseconds before retrying a failed request.
+     * @returns {HttpTransport} The configured HTTP transport with logging enabled.
+     *
+     */
+    private createHttpTransportWithLogging(
+        url: string,
+        timeout: number,
+        retryInterval: number,
+    ): HttpTransport {
+        return http(url, {
+            timeout: timeout,
+            retryDelay: retryInterval,
+            onFetchRequest: async (request) => {
+                const clonedRequest = {
+                    url: request.url,
+                    method: request.method,
+                    headers: Array.from(request.headers.entries()),
+                    body: await request.clone().text(),
+                };
+
+                this.logger?.debug(`Fetch Request`, clonedRequest);
+            },
+            onFetchResponse: async (response) => {
+                const clonedResponse = {
+                    url: response.url,
+                    status: response.status,
+                    headers: Array.from(response.headers.entries()),
+                    body: await response.clone().text(),
+                };
+
+                this.logger?.debug(`Fetch Response`, clonedResponse);
+            },
+        });
+    }
+
     private getViemChain(chainId: Caip2ChainId): Chain {
         switch (chainId) {
             case "eip155:1":

packages/shared/package.json

@@ -23,7 +23,8 @@
     "keywords": [],
     "author": "",
     "dependencies": {
-        "winston": "3.13.1"
+        "winston": "3.13.1",
+        "winston-transport": "^4.8.0"
     },
     "devDependencies": {
         "viem": "2.21.25"

packages/shared/src/services/logger.ts

@@ -1,4 +1,6 @@
+import { stringify } from "viem";
 import { createLogger, format, transports, Logger as WinstonLogger } from "winston";
+import Transport from "winston-transport";
 
 import { ILogger } from "../index.js";
 
@@ -10,50 +12,53 @@ export class Logger implements ILogger {
     private logger: WinstonLogger;
     private static instance: Logger | null;
     private level: LogLevel;
-    private constructor() {
+    private constructor(transportsArray?: Transport[]) {
         this.level = this.isValidLogLevel(process.env.LOG_LEVEL) ? process.env.LOG_LEVEL : "info";
         this.logger = createLogger({
             level: this.level,
             format: format.combine(
                 format.colorize(),
                 format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
                 format.errors({ stack: true }),
-                format.printf(({ level, message, timestamp, stack }) => {
-                    return `${timestamp} ${level}: ${stack ?? message ?? ""}`;
+                format.printf((info) => {
+                    const { level, message, timestamp, stack, ...meta } = info;
+                    const metaString = Object.keys(meta).length ? ` ${stringify(meta)}` : "";
+                    return `${timestamp} ${level}: ${stack ?? message ?? ""}${metaString}`;
                 }),
             ),
-            transports: [new transports.Console()],
+            transports: transportsArray || [new transports.Console()],
         });
     }
     /**
      * Returns the instance of the Logger class.
-     * @param level The log level to be used by the logger.
+     * @param transportsArray - An array of transports to use with the logger.
      * @returns The instance of the Logger class.
      */
-    public static getInstance(): Logger {
+    public static getInstance(transportsArray?: Transport[]): Logger {
         if (!Logger.instance) {
-            Logger.instance = new Logger();
+            Logger.instance = new Logger(transportsArray);
         }
         return Logger.instance;
     }
     isValidLogLevel(level: any): level is LogLevel {
         return validLogLevels.includes(level);
     }
 
-    info(message: string) {
-        this.logger.info(message);
+    info(message: string, meta?: unknown) {
+        this.logger.info(message, meta);
     }
-    error(error: Error | string): void {
+    error(error: Error | string, meta?: unknown): void {
+        const metaData = meta ? (meta as object) : {};
         if (error instanceof Error) {
-            this.logger.error(error);
+            this.logger.error(error.message, { stack: error.stack, ...metaData });
         } else {
-            this.logger.error(new Error(error));
+            this.logger.error(error, metaData);
         }
     }
-    warn(message: string) {
-        this.logger.warn(message);
+    warn(message: string, meta?: unknown) {
+        this.logger.warn(message, meta);
     }
-    debug(message: string) {
-        this.logger.debug(message);
+    debug(message: string, meta?: unknown) {
+        this.logger.debug(message, meta);
     }
 }

packages/shared/src/types/logger.ts

@@ -2,8 +2,8 @@
  * Generic logger interface.
  */
 export interface ILogger {
-    error: (error: Error | string) => void;
-    info: (message: string) => void;
-    warn: (message: string) => void;
-    debug: (message: string) => void;
+    error: (error: Error | string, meta?: unknown) => void;
+    info: (message: string, meta?: unknown) => void;
+    warn: (message: string, meta?: unknown) => void;
+    debug: (message: string, meta?: unknown) => void;
 }

packages/shared/tests/services/logger.spec.ts

@@ -1,7 +1,56 @@
-import { describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
 import { Logger } from "../../src/services/index.js";
 
+describe("Logger Methods", () => {
+    beforeEach(() => {
+        Logger["instance"] = null;
+        delete process.env.LOG_LEVEL;
+    });
+
+    it("includes metadata in log output", () => {
+        const logger = Logger.getInstance();
+        const mockInfo = vi.spyOn(logger["logger"], "info");
+
+        const message = "Test message";
+        const meta = { key: "value" };
+
+        logger.info(message, meta);
+
+        expect(mockInfo).toHaveBeenCalledWith(message, meta);
+        mockInfo.mockRestore();
+    });
+
+    it("handles errors with metadata", () => {
+        const logger = Logger.getInstance();
+        const mockError = vi.spyOn(logger["logger"], "error");
+
+        const error = new Error("An error occurred");
+        const meta = { key: "value" };
+
+        logger.error(error, meta);
+
+        expect(mockError).toHaveBeenCalledWith(
+            error.message,
+            expect.objectContaining({ stack: error.stack, ...meta }),
+        );
+        mockError.mockRestore();
+    });
+
+    it("includes metadata in debug log output", () => {
+        const logger = Logger.getInstance();
+        const mockDebug = vi.spyOn(logger["logger"], "debug");
+
+        const message = "Debug message";
+        const meta = { debugKey: "debugValue" };
+
+        logger.debug(message, meta);
+
+        expect(mockDebug).toHaveBeenCalledWith(message, meta);
+        mockDebug.mockRestore();
+    });
+});
+
 describe("Logger Singleton", () => {
     it("creates a logger instance with the given log level", () => {
         const logger = Logger.getInstance();
@@ -16,7 +65,7 @@ describe("Logger Singleton", () => {
     });
     it("sets level correctly based on LOG_LEVEL env var", () => {
         let logger1 = Logger.getInstance();
-        expect(logger1["level"]).toEqual("info");
+        expect(logger1["level"]).toContain("info");
 
         Logger["instance"] = null;
         process.env.LOG_LEVEL = "debug";