Generalize logger usage between src and binary folders

config/cspell-ts.json

@@ -24,6 +24,8 @@
     }
   ],
   "words": [
+    "logtape",
+    "logtapelogger",
     "bytelist",
     "bytestring",
     "binarytree",

packages/client/bin/cli.ts

@@ -20,14 +20,66 @@ import type * as http from 'http'
 import type { Block, BlockBytes } from '@ethereumjs/block'
 import type { ConsensusDict } from '@ethereumjs/blockchain'
 import type { GenesisState } from '@ethereumjs/util'
+import { getFileSink } from '@logtape/file'
+import {
+  ansiColorFormatter,
+  configure,
+  getConsoleSink,
+  getLogger as getLogtapeLogger,
+} from '@logtape/logtape'
+import type { Logger as LogtapeLoggerType } from '@logtape/logtape'
 import type { AbstractLevel } from 'abstract-level'
 import type { Server as RPCServer } from 'jayson/promise/index.js'
 import type { Config } from '../src/config.ts'
-import type { Logger } from '../src/logging.ts'
 import type { FullEthereumService } from '../src/service/index.ts'
-import type { ClientOpts } from '../src/types.ts'
+import type { ClientOpts, Logger } from '../src/types.ts'
 import type { RPCArgs } from './startRPC.ts'
 
+export class LogtapeLogger implements Logger {
+  public logger: LogtapeLoggerType
+
+  constructor(logger: LogtapeLoggerType) {
+    this.logger = logger
+
+    // Bind methods for logger instance
+    this.info = this.info.bind(this)
+    this.warn = this.warn.bind(this)
+    this.error = this.error.bind(this)
+    this.debug = this.debug.bind(this)
+  }
+
+  info(message: string, ...meta: any[]) {
+    this.logger?.info(`${message}`, ...meta)
+  }
+
+  warn(message: string, ...meta: any[]) {
+    this.logger?.warn(`${message}`, ...meta)
+  }
+
+  error(message: string, ...meta: any[]) {
+    this.logger?.error(`${message}`, ...meta)
+  }
+
+  debug(message: string, ...meta: any[]) {
+    this.logger?.debug(`${message}`, ...meta)
+  }
+
+  isInfoEnabled() {
+    const level = (this.logger as any).lowestLevel
+    return level === 'info' || level === 'debug'
+  }
+
+  configure(_: { [key: string]: any }) {
+    console.warn(
+      'Dynamic configuration is not supported in Logtapelogger. Please configure globally.',
+    )
+  }
+
+  getLevel() {
+    return (this.logger as any).lowestLevel
+  }
+}
+
 let logger: Logger
 
 const args: ClientOpts = getArgs()
@@ -118,7 +170,7 @@ async function startBlock(client: EthereumClient) {
   }
   try {
     await client.chain.resetCanonicalHead(startBlock)
-    client.config.logger.info(`Chain height reset to ${client.chain.headers.height}`)
+    client.config.logger?.info(`Chain height reset to ${client.chain.headers.height}`)
   } catch (err: any) {
     throw EthereumJSErrorWithoutCode(`Error setting back chain in startBlock: ${err}`)
   }
@@ -150,7 +202,7 @@ async function startExecutionFrom(client: EthereumClient) {
       try {
         await client.chain.blockchain.setIteratorHead('vm', startExecutionParent.hash())
         await client.chain.update(false)
-        client.config.logger.info(
+        client.config.logger?.info(
           `vmHead set to ${client.chain.headers.height} for starting stateless execution at hardfork=${startExecutionHardfork}`,
         )
       } catch (err: any) {
@@ -162,7 +214,7 @@ async function startExecutionFrom(client: EthereumClient) {
       try {
         await client.chain.blockchain.setIteratorHead('vm', startExecutionParent.hash())
         await client.chain.update(false)
-        client.config.logger.info(
+        client.config.logger?.info(
           `vmHead set to ${client.chain.headers.height} for starting stateful execution at hardfork=${startExecutionHardfork}`,
         )
       } catch (err: any) {
@@ -186,7 +238,8 @@ async function startClient(
   config: Config,
   genesisMeta: { genesisState?: GenesisState; genesisStateRoot?: Uint8Array } = {},
 ) {
-  config.logger.info(`Data directory: ${config.datadir}`)
+  // TODO make sure all logger usage is preservable through newly created logger interface
+  config.logger?.info(`Data directory: ${config.datadir}`)
 
   const dbs = initDBs(config)
 
@@ -243,13 +296,13 @@ async function startClient(
           })
           blocks.push(block)
           buf = RLP.decode(buf.remainder, true)
-          config.logger.info(
+          config.logger?.info(
             `Preloading block hash=${short(bytesToHex(block.header.hash()))} number=${
               block.header.number
             }`,
           )
         } catch (err: any) {
-          config.logger.info(
+          config.logger?.info(
             `Encountered error while while preloading chain data  error=${err.message}`,
           )
           break
@@ -310,28 +363,28 @@ const stopClient = async (
     servers: (RPCServer | http.Server)[]
   } | null>,
 ) => {
-  config.logger.info('Caught interrupt signal. Obtaining client handle for clean shutdown...')
-  config.logger.info('(This might take a little longer if client not yet fully started)')
+  config.logger?.info('Caught interrupt signal. Obtaining client handle for clean shutdown...')
+  config.logger?.info('(This might take a little longer if client not yet fully started)')
   let timeoutHandle
   if (clientStartPromise?.toString().includes('Promise') === true)
     // Client hasn't finished starting up so setting timeout to terminate process if not already shutdown gracefully
     timeoutHandle = setTimeout(() => {
-      config.logger.warn('Client has become unresponsive while starting up.')
-      config.logger.warn('Check logging output for potential errors.  Exiting...')
+      config.logger?.warn('Client has become unresponsive while starting up.')
+      config.logger?.warn('Check logging output for potential errors.  Exiting...')
       process.exit(1)
     }, 30000)
   const clientHandle = await clientStartPromise
   if (clientHandle !== null) {
-    config.logger.info('Shutting down the client and the servers...')
+    config.logger?.info('Shutting down the client and the servers...')
     const { client, servers } = clientHandle
     for (const s of servers) {
       //@ts-expect-error jayson.Server type doesn't play well with ESM for some reason
       s['http'] !== undefined ? (s as RPCServer).http().close() : (s as http.Server).close()
     }
     await client.stop()
-    config.logger.info('Exiting.')
+    config.logger?.info('Exiting.')
   } else {
-    config.logger.info('Client did not start properly, exiting ...')
+    config.logger?.info('Client did not start properly, exiting ...')
   }
   clearTimeout(timeoutHandle)
   process.exit()
@@ -346,10 +399,27 @@ async function run() {
     return helpRPC()
   }
 
+  // use Logtape logger with cli
+  const sinks: { [key: string]: any } = {
+    console: getConsoleSink({ formatter: ansiColorFormatter }),
+  }
+  if (typeof args.logFile === 'string') {
+    sinks.file = getFileSink(args.logFile)
+  }
+  await configure({
+    sinks,
+    loggers: [
+      {
+        category: 'ethjs',
+        lowestLevel: args.logLevel as any,
+        // Use all configured sink names.
+        sinks: Object.keys(sinks),
+      },
+    ],
+  })
+  logger = new LogtapeLogger(getLogtapeLogger(['ethjs', 'client']))
   const { config, customGenesisState, customGenesisStateRoot, metricsServer } =
-    await generateClientConfig(args)
-
-  logger = config.logger
+    await generateClientConfig({ ...args, logger })
 
   // Do not wait for client to be fully started so that we can hookup SIGINT handling
   // else a SIGINT before may kill the process in unclean manner
@@ -366,14 +436,14 @@ async function run() {
         client.config.chainCommon.gteHardfork(Hardfork.Paris) &&
         (args.rpcEngine === false || args.rpcEngine === undefined)
       ) {
-        config.logger.warn(`Engine RPC endpoint not activated on a post-Merge HF setup.`)
+        config.logger?.warn(`Engine RPC endpoint not activated on a post-Merge HF setup.`)
       }
       if (metricsServer !== undefined) servers.push(metricsServer)
       config.superMsg('Client started successfully')
       return { client, servers }
     })
     .catch((e) => {
-      config.logger.error('Error starting client', e)
+      config.logger?.error('Error starting client', e)
       return null
     })
 
@@ -388,8 +458,8 @@ async function run() {
   process.on('uncaughtException', (err) => {
     // Handles uncaught exceptions that are thrown in async events/functions and aren't caught in
     // main client process
-    config.logger.error(`Uncaught error: ${err.message}`)
-    config.logger.error(err)
+    config.logger?.error(`Uncaught error: ${err.message}`)
+    config.logger?.error(err.stack ?? err.message)
 
     void stopClient(config, clientStartPromise)
   })