chore: use %e token anywhere we are logging errors with @libp2p/logger

package.json

@@ -46,5 +46,8 @@
     "doc",
     "interop",
     "packages/*"
-  ]
+  ],
+  "dependencies": {
+    "@libp2p/interface": "^2.10.3"
+  }
 }

packages/integration-tests/test/interop.ts

@@ -1,32 +1,35 @@
-import fs from 'fs'
-import { gossipsub } from '@chainsafe/libp2p-gossipsub'
-import { noise } from '@chainsafe/libp2p-noise'
-import { yamux } from '@chainsafe/libp2p-yamux'
-import { circuitRelayServer, circuitRelayTransport } from '@libp2p/circuit-relay-v2'
-import { privateKeyFromProtobuf } from '@libp2p/crypto/keys'
-import { createClient } from '@libp2p/daemon-client'
-import { createServer } from '@libp2p/daemon-server'
-import { floodsub } from '@libp2p/floodsub'
-import { identify } from '@libp2p/identify'
-import { UnsupportedError, interopTests } from '@libp2p/interop'
-import { kadDHT, passthroughMapper } from '@libp2p/kad-dht'
-import { logger } from '@libp2p/logger'
-import { mplex } from '@libp2p/mplex'
-import { ping } from '@libp2p/ping'
-import { plaintext } from '@libp2p/plaintext'
-import { tcp } from '@libp2p/tcp'
-import { tls } from '@libp2p/tls'
-import { webRTCDirect } from '@libp2p/webrtc'
-import { multiaddr } from '@multiformats/multiaddr'
-import { execa } from 'execa'
-import { path as p2pd } from 'go-libp2p'
-import { createLibp2p } from 'libp2p'
-import pDefer from 'p-defer'
-import type { Identify } from '@libp2p/identify'
-import type { ServiceMap, PrivateKey } from '@libp2p/interface'
-import type { SpawnOptions, Daemon, DaemonFactory } from '@libp2p/interop'
-import type { PingService } from '@libp2p/ping'
-import type { Libp2pOptions, ServiceFactoryMap } from 'libp2p'
+import fs from "fs";
+import { gossipsub } from "@chainsafe/libp2p-gossipsub";
+import { noise } from "@chainsafe/libp2p-noise";
+import { yamux } from "@chainsafe/libp2p-yamux";
+import {
+  circuitRelayServer,
+  circuitRelayTransport,
+} from "@libp2p/circuit-relay-v2";
+import { privateKeyFromProtobuf } from "@libp2p/crypto/keys";
+import { createClient } from "@libp2p/daemon-client";
+import { createServer } from "@libp2p/daemon-server";
+import { floodsub } from "@libp2p/floodsub";
+import { identify } from "@libp2p/identify";
+import { UnsupportedError, interopTests } from "@libp2p/interop";
+import { kadDHT, passthroughMapper } from "@libp2p/kad-dht";
+import { logger } from "@libp2p/logger";
+import { mplex } from "@libp2p/mplex";
+import { ping } from "@libp2p/ping";
+import { plaintext } from "@libp2p/plaintext";
+import { tcp } from "@libp2p/tcp";
+import { tls } from "@libp2p/tls";
+import { webRTCDirect } from "@libp2p/webrtc";
+import { multiaddr } from "@multiformats/multiaddr";
+import { execa } from "execa";
+import { path as p2pd } from "go-libp2p";
+import { createLibp2p } from "libp2p";
+import pDefer from "p-defer";
+import type { Identify } from "@libp2p/identify";
+import type { ServiceMap, PrivateKey } from "@libp2p/interface";
+import type { SpawnOptions, Daemon, DaemonFactory } from "@libp2p/interop";
+import type { PingService } from "@libp2p/ping";
+import type { Libp2pOptions, ServiceFactoryMap } from "libp2p";
 
 /**
  * @packageDocumentation
@@ -38,198 +41,194 @@ import type { Libp2pOptions, ServiceFactoryMap } from 'libp2p'
  * ```
  */
 
-async function createGoPeer (options: SpawnOptions): Promise<Daemon> {
-  const controlPort = Math.floor(Math.random() * (50000 - 10000 + 1)) + 10000
-  const apiAddr = multiaddr(`/ip4/127.0.0.1/tcp/${controlPort}`)
+async function createGoPeer(options: SpawnOptions): Promise<Daemon> {
+  const controlPort = Math.floor(Math.random() * (50000 - 10000 + 1)) + 10000;
+  const apiAddr = multiaddr(`/ip4/127.0.0.1/tcp/${controlPort}`);
 
-  const log = logger(`go-libp2p:${controlPort}`)
+  const log = logger(`go-libp2p:${controlPort}`);
 
-  const opts = [
-    `-listen=${apiAddr.toString()}`
-  ]
+  const opts = [`-listen=${apiAddr.toString()}`];
 
   if (options.noListen === true) {
-    opts.push('-noListenAddrs')
+    opts.push("-noListenAddrs");
   } else {
-    if (options.transport == null || options.transport === 'tcp') {
-      opts.push('-hostAddrs=/ip4/127.0.0.1/tcp/0')
-    } else if (options.transport === 'webtransport') {
-      opts.push('-hostAddrs=/ip4/127.0.0.1/udp/0/quic-v1/webtransport')
-    } else if (options.transport === 'webrtc-direct') {
-      opts.push('-hostAddrs=/ip4/127.0.0.1/udp/0/webrtc-direct')
+    if (options.transport == null || options.transport === "tcp") {
+      opts.push("-hostAddrs=/ip4/127.0.0.1/tcp/0");
+    } else if (options.transport === "webtransport") {
+      opts.push("-hostAddrs=/ip4/127.0.0.1/udp/0/quic-v1/webtransport");
+    } else if (options.transport === "webrtc-direct") {
+      opts.push("-hostAddrs=/ip4/127.0.0.1/udp/0/webrtc-direct");
     } else {
-      throw new UnsupportedError()
+      throw new UnsupportedError();
     }
   }
 
   if (options.encryption != null) {
-    opts.push(`-${options.encryption}=true`)
+    opts.push(`-${options.encryption}=true`);
   }
 
   if (options.dht === true) {
-    opts.push('-dhtServer')
+    opts.push("-dhtServer");
   }
 
   if (options.relay === true) {
-    opts.push('-relay')
+    opts.push("-relay");
   }
 
   if (options.pubsub === true) {
-    opts.push('-pubsub')
+    opts.push("-pubsub");
   }
 
   if (options.pubsubRouter != null) {
-    opts.push(`-pubsubRouter=${options.pubsubRouter}`)
+    opts.push(`-pubsubRouter=${options.pubsubRouter}`);
   }
 
   if (options.key != null) {
-    opts.push(`-id=${options.key}`)
+    opts.push(`-id=${options.key}`);
   }
 
-  if (options.muxer === 'mplex') {
-    opts.push('-muxer=mplex')
+  if (options.muxer === "mplex") {
+    opts.push("-muxer=mplex");
   } else {
-    opts.push('-muxer=yamux')
+    opts.push("-muxer=yamux");
   }
 
-  const deferred = pDefer()
+  const deferred = pDefer();
   const proc = execa(p2pd(), opts, {
     env: {
-      GOLOG_LOG_LEVEL: 'debug'
-    }
-  })
+      GOLOG_LOG_LEVEL: "debug",
+    },
+  });
 
-  proc.stdout?.on('data', (buf: Buffer) => {
-    const str = buf.toString()
-    log(str)
+  proc.stdout?.on("data", (buf: Buffer) => {
+    const str = buf.toString();
+    log(str);
 
     // daemon has started
-    if (str.includes('Control socket:')) {
-      deferred.resolve()
+    if (str.includes("Control socket:")) {
+      deferred.resolve();
     }
-  })
+  });
 
-  proc.stderr?.on('data', (buf) => {
-    log.error(buf.toString())
-  })
+  proc.stderr?.on("data", (buf) => {
+    log.error("interop main error - %e", buf.toString());
+  });
 
-  await deferred.promise
+  await deferred.promise;
 
   return {
     client: createClient(apiAddr),
     stop: async () => {
-      proc.kill()
-    }
-  }
+      proc.kill();
+    },
+  };
 }
 
-async function createJsPeer (options: SpawnOptions): Promise<Daemon> {
-  let privateKey: PrivateKey | undefined
+async function createJsPeer(options: SpawnOptions): Promise<Daemon> {
+  let privateKey: PrivateKey | undefined;
 
   if (options.key != null) {
-    const keyFile = fs.readFileSync(options.key)
-    privateKey = privateKeyFromProtobuf(keyFile)
+    const keyFile = fs.readFileSync(options.key);
+    privateKey = privateKeyFromProtobuf(keyFile);
   }
 
   const opts: Libp2pOptions<ServiceMap> = {
     privateKey,
     addresses: {
-      listen: []
+      listen: [],
     },
-    transports: [
-      tcp(),
-      circuitRelayTransport(),
-      webRTCDirect()
-    ],
+    transports: [tcp(), circuitRelayTransport(), webRTCDirect()],
     streamMuxers: [],
-    connectionEncrypters: []
-  }
+    connectionEncrypters: [],
+  };
 
   if (options.noListen !== true) {
-    if (options.transport == null || options.transport === 'tcp') {
-      opts.addresses?.listen?.push('/ip4/127.0.0.1/tcp/0')
-    } else if (options.transport === 'webrtc-direct') {
-      opts.addresses?.listen?.push('/ip4/127.0.0.1/udp/0/webrtc-direct')
+    if (options.transport == null || options.transport === "tcp") {
+      opts.addresses?.listen?.push("/ip4/127.0.0.1/tcp/0");
+    } else if (options.transport === "webrtc-direct") {
+      opts.addresses?.listen?.push("/ip4/127.0.0.1/udp/0/webrtc-direct");
     } else {
-      throw new UnsupportedError()
+      throw new UnsupportedError();
     }
   }
 
-  if (options.transport === 'webtransport') {
-    throw new UnsupportedError()
+  if (options.transport === "webtransport") {
+    throw new UnsupportedError();
   }
 
-  const services: ServiceFactoryMap<{ identify: Identify, ping: PingService } & Record<string, any>> = {
+  const services: ServiceFactoryMap<
+    { identify: Identify; ping: PingService } & Record<string, any>
+  > = {
     identify: identify(),
-    ping: ping()
-  }
+    ping: ping(),
+  };
 
-  if (options.encryption === 'tls') {
-    opts.connectionEncrypters?.push(tls())
-  } else if (options.encryption === 'plaintext') {
-    opts.connectionEncrypters?.push(plaintext())
+  if (options.encryption === "tls") {
+    opts.connectionEncrypters?.push(tls());
+  } else if (options.encryption === "plaintext") {
+    opts.connectionEncrypters?.push(plaintext());
   } else {
-    opts.connectionEncrypters?.push(noise())
+    opts.connectionEncrypters?.push(noise());
   }
 
-  if (options.muxer === 'mplex') {
-    opts.streamMuxers?.push(mplex())
+  if (options.muxer === "mplex") {
+    opts.streamMuxers?.push(mplex());
   } else {
-    opts.streamMuxers?.push(yamux())
+    opts.streamMuxers?.push(yamux());
   }
 
   if (options.pubsub === true) {
-    if (options.pubsubRouter === 'floodsub') {
-      services.pubsub = floodsub()
+    if (options.pubsubRouter === "floodsub") {
+      services.pubsub = floodsub();
     } else {
-      services.pubsub = gossipsub()
+      services.pubsub = gossipsub();
     }
   }
 
   if (options.relay === true) {
-    services.relay = circuitRelayServer()
+    services.relay = circuitRelayServer();
   }
 
   if (options.dht === true) {
     services.dht = kadDHT({
-      protocol: '/ipfs/kad/1.0.0',
+      protocol: "/ipfs/kad/1.0.0",
       peerInfoMapper: passthroughMapper,
-      clientMode: false
-    })
+      clientMode: false,
+    });
   }
 
   const node: any = await createLibp2p({
     ...opts,
-    services
-  })
+    services,
+  });
 
-  const server = createServer(multiaddr('/ip4/127.0.0.1/tcp/0'), node)
-  await server.start()
+  const server = createServer(multiaddr("/ip4/127.0.0.1/tcp/0"), node);
+  await server.start();
 
   return {
     client: createClient(server.getMultiaddr()),
     stop: async () => {
-      await server.stop()
-      await node.stop()
-    }
-  }
+      await server.stop();
+      await node.stop();
+    },
+  };
 }
 
-async function main (): Promise<void> {
+async function main(): Promise<void> {
   const factory: DaemonFactory = {
-    async spawn (options: SpawnOptions) {
-      if (options.type === 'go') {
-        return createGoPeer(options)
+    async spawn(options: SpawnOptions) {
+      if (options.type === "go") {
+        return createGoPeer(options);
       }
 
-      return createJsPeer(options)
-    }
-  }
+      return createJsPeer(options);
+    },
+  };
 
-  await interopTests(factory)
+  await interopTests(factory);
 }
 
-main().catch(err => {
-  console.error(err) // eslint-disable-line no-console
-  process.exit(1)
-})
+main().catch((err) => {
+  console.error(err); // eslint-disable-line no-console
+  process.exit(1);
+});