Make logger usage optional

packages/client/bin/cli.ts

@@ -28,7 +28,7 @@
 import type { ClientOpts } from '../src/types.ts'
 import type { RPCArgs } from './startRPC.ts'
 
-let logger: Logger
+let logger: Logger | undefined
 
 const args: ClientOpts = getArgs()
 
@@ -118,7 +118,7 @@
   }
   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 +150,7 @@
       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 +162,7 @@
       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 +186,7 @@
   config: Config,
   genesisMeta: { genesisState?: GenesisState; genesisStateRoot?: Uint8Array } = {},
 ) {
-  config.logger.info(`Data directory: ${config.datadir}`)
+  config.logger?.info(`Data directory: ${config.datadir}`)
 
   const dbs = initDBs(config)
 
@@ -243,13 +243,13 @@
           })
           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 +310,28 @@
     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()
@@ -366,14 +366,14 @@
         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 +388,8 @@
   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)
 
     void stopClient(config, clientStartPromise)
   })

packages/client/bin/repl.ts

@@ -83,7 +83,12 @@
     action(params) {
       const level = params
       if (['debug', 'info', 'warn', 'error'].includes(level)) {
-        for (const transport of (replServer.context.client as EthereumClient).config.logger
+        const logger = (replServer.context.client as EthereumClient).config.logger
+        if (logger === undefined) {
+          this.displayPrompt()
+          return
+        }
+        for (const transport of (replServer.context.client as EthereumClient).config.logger!
           .transports) {
           transport.level = level
         }

packages/client/bin/startRPC.ts

@@ -68,9 +68,9 @@
 
     jwtSecret = randomBytes(32)
     writeFileSync(defaultJwtPath, bytesToUnprefixedHex(jwtSecret), {})
-    config.logger.info(`New Engine API JWT token created path=${defaultJwtPath}`)
+    config.logger?.info(`New Engine API JWT token created path=${defaultJwtPath}`)
   }
-  config.logger.info(`Using Engine API with JWT token authentication path=${usedJwtPath}`)
+  config.logger?.info(`Using Engine API with JWT token authentication path=${usedJwtPath}`)
   return jwtSecret
 }
 
@@ -138,12 +138,12 @@
             : undefined,
       })
       rpcHttpServer.listen(rpcPort, rpcAddr)
-      logger.info(
+      logger?.info(
         `Started JSON RPC Server address=http://${rpcAddr}:${rpcPort} namespaces=${namespaces}${
           withEngineMethods ? ' rpcEngineAuth=' + rpcEngineAuth.toString() : ''
         }`,
       )
-      logger.debug(
+      logger?.debug(
         `Methods available at address=http://${rpcAddr}:${rpcPort} namespaces=${namespaces} methods=${Object.keys(
           methods,
         ).join(',')}`,
@@ -162,12 +162,12 @@
 
       const rpcWsServer = createWsRPCServerListener(opts)
       if (rpcWsServer) rpcWsServer.listen(wsPort)
-      logger.info(
+      logger?.info(
         `Started JSON RPC Server address=ws://${wsAddr}:${wsPort} namespaces=${namespaces}${
           withEngineMethods ? ` rpcEngineAuth=${rpcEngineAuth}` : ''
         }`,
       )
-      logger.debug(
+      logger?.debug(
         `Methods available at address=ws://${wsAddr}:${wsPort} namespaces=${namespaces} methods=${Object.keys(
           methods,
         ).join(',')}`,
@@ -193,10 +193,10 @@
         : undefined,
     })
     rpcHttpServer.listen(rpcEnginePort, rpcEngineAddr)
-    logger.info(
+    logger?.info(
       `Started JSON RPC server address=http://${rpcEngineAddr}:${rpcEnginePort} namespaces=${namespaces} rpcEngineAuth=${rpcEngineAuth}`,
     )
-    logger.debug(
+    logger?.debug(
       `Methods available at address=http://${rpcEngineAddr}:${rpcEnginePort} namespaces=${namespaces} methods=${Object.keys(
         methods,
       ).join(',')}`,
@@ -216,10 +216,10 @@
 
       const rpcWsServer = createWsRPCServerListener(opts)
       if (rpcWsServer) rpcWsServer.listen(wsEnginePort, wsEngineAddr)
-      logger.info(
+      logger?.info(
         `Started JSON RPC Server address=ws://${wsEngineAddr}:${wsEnginePort} namespaces=${namespaces} rpcEngineAuth=${rpcEngineAuth}`,
       )
-      logger.debug(
+      logger?.debug(
         `Methods available at address=ws://${wsEngineAddr}:${wsEnginePort} namespaces=${namespaces} methods=${Object.keys(
           methods,
         ).join(',')}`,

packages/client/bin/utils.ts

@@ -206,7 +206,7 @@
       })
       .option('logLevel', {
         describe: 'Logging verbosity',
-        choices: ['error', 'warn', 'info', 'debug'],
+        choices: ['error', 'warn', 'info', 'debug', 'off'],
         default: 'info',
       })
       .option('logFile', {
@@ -757,7 +757,7 @@
     args.logFile = args.logFile ? `${networkDir}/ethereumjs.log` : undefined
   }
 
-  const logger: Logger = getLogger(args)
+  const logger: Logger | undefined = getLogger(args)
   let bootnodes
   if (args.bootnodes !== undefined) {
     // File path passed, read bootnodes from disk
@@ -777,7 +777,7 @@
         }
       })
       bootnodes = parseMultiaddrs(nodeURLs)
-      logger.info(`Reading bootnodes file=${args.bootnodes[0]} num=${nodeURLs.length}`)
+      logger?.info(`Reading bootnodes file=${args.bootnodes[0]} num=${nodeURLs.length}`)
     } else {
       bootnodes = parseMultiaddrs(args.bootnodes)
     }
@@ -824,7 +824,7 @@
       }
     })
     // Start the HTTP server which exposes the metrics on http://localhost:${args.prometheusPort}/metrics
-    logger.info(`Starting Metrics Server on port ${args.prometheusPort}`)
+    logger?.info(`Starting Metrics Server on port ${args.prometheusPort}`)
     metricsServer.listen(args.prometheusPort)
   }
 
@@ -884,12 +884,12 @@
       writeFileSync(`${networkDir}/${details.transport}`, details.url)
     } catch (e) {
       // In case dir is not really setup, mostly to take care of mockserver in test
-      config.logger.error(`Error writing listener details to disk: ${(e as Error).message}`)
+      config.logger?.error(`Error writing listener details to disk: ${(e as Error).message}`)
     }
   })
   if (customGenesisState !== undefined) {
     const numAccounts = Object.keys(customGenesisState).length
-    config.logger.info(`Reading custom genesis state accounts=${numAccounts}`)
+    config.logger?.info(`Reading custom genesis state accounts=${numAccounts}`)
   }
   const customGenesisStateRoot = args.verkleGenesisStateRoot
 

packages/client/src/client.ts

@@ -110,15 +110,15 @@
     const name = this.config.chainCommon.chainName()
     const chainId = this.config.chainCommon.chainId()
     const packageJSON = getPackageJSON()
-    this.config.logger.info(
+    this.config.logger?.info(
       `Initializing Ethereumjs client version=v${packageJSON.version} network=${name} chainId=${chainId}`,
     )
 
     this.config.events.on(Event.SERVER_ERROR, (error) => {
-      this.config.logger.warn(`Server error: ${error.name} - ${error.message}`)
+      this.config.logger?.warn(`Server error: ${error.name} - ${error.message}`)
     })
     this.config.events.on(Event.SERVER_LISTENING, (details) => {
-      this.config.logger.info(
+      this.config.logger?.info(
         `Server listener up transport=${details.transport} url=${details.url}`,
       )
     })
@@ -135,7 +135,7 @@
     if (this.started) {
       return false
     }
-    this.config.logger.info('Setup networking and services.')
+    this.config.logger?.info('Setup networking and services.')
 
     await this.service.start()
     this.config.server && (await this.config.server.start())

packages/client/src/config.ts

@@ -4,7 +4,6 @@ import { type Address, BIGINT_0, BIGINT_1, BIGINT_2, BIGINT_256 } from '@ethereu
 import { EventEmitter } from 'eventemitter3'
 import { Level } from 'level'
 
-import { getLogger } from './logging.ts'
 import { RlpxServer } from './net/server/index.ts'
 import { Event } from './types.ts'
 import { isBrowser, short } from './util/index.ts'
@@ -398,7 +397,7 @@ export class Config {
   // support blobs and proofs cache for CL getBlobs for upto 1 epoch of data
   public static readonly BLOBS_AND_PROOFS_CACHE_BLOCKS = 32
 
-  public readonly logger: Logger
+  public readonly logger: Logger | undefined
   public readonly syncmode: SyncMode
   public readonly vm?: VM
   public readonly datadir: string
@@ -566,9 +565,9 @@ export class Config {
     this.discDns = this.getDnsDiscovery(options.discDns)
     this.discV4 = options.discV4 ?? true
 
-    this.logger = options.logger ?? getLogger({ logLevel: 'error' })
+    this.logger = options.logger
 
-    this.logger.info(`Sync Mode ${this.syncmode}`)
+    this.logger?.info(`Sync Mode ${this.syncmode}`)
     if (this.syncmode !== SyncMode.None) {
       if (options.server !== undefined) {
         this.server = options.server
@@ -628,15 +627,15 @@ export class Config {
         const diff = Date.now() - this.lastSyncDate
         if (diff >= this.syncedStateRemovalPeriod) {
           this.synchronized = false
-          this.logger.info(
+          this.logger?.info(
             `Sync status reset (no chain updates for ${Math.round(diff / 1000)} seconds).`,
           )
         }
       }
     }
 
     if (this.synchronized !== this.lastSynchronized) {
-      this.logger.debug(
+      this.logger?.debug(
         `Client synchronized=${this.synchronized}${
           latest !== null && latest !== undefined ? ' height=' + latest.number : ''
         } syncTargetHeight=${this.syncTargetHeight} lastSyncDate=${
@@ -712,11 +711,11 @@ export class Config {
     for (const msg of msgs) {
       len = msg.length > len ? msg.length : len
     }
-    this.logger.info('-'.repeat(len), meta)
+    this.logger?.info('-'.repeat(len), meta)
     for (const msg of msgs) {
-      this.logger.info(msg, meta)
+      this.logger?.info(msg, meta)
     }
-    this.logger.info('-'.repeat(len), meta)
+    this.logger?.info('-'.repeat(len), meta)
   }
 
   /**

packages/client/src/execution/execution.ts

@@ -49,15 +49,15 @@ export abstract class Execution {
    */
   async open(): Promise<void> {
     this.started = true
-    this.config.logger.info('Setup EVM execution.')
+    this.config.logger?.info('Setup EVM execution.')
   }
 
   /**
    * Stop execution. Returns a promise that resolves once stopped.
    */
   async stop(): Promise<boolean> {
     this.started = false
-    this.config.logger.info('Stopped execution.')
+    this.config.logger?.info('Stopped execution.')
     return true
   }
 }