@waku/core 0.0.23 → 0.0.25-a42b7be.0

package/src/lib/connection_manager.ts

@@ -1,7 +1,9 @@
 import type { PeerId } from "@libp2p/interface/peer-id";
 import type { PeerInfo } from "@libp2p/interface/peer-info";
 import type { Peer } from "@libp2p/interface/peer-store";
+import type { PeerStore } from "@libp2p/interface/peer-store";
 import { CustomEvent, EventEmitter } from "@libp2p/interfaces/events";
+import { decodeRelayShard } from "@waku/enr";
 import {
   ConnectionManagerOptions,
   EPeersByDiscoveryEvents,
@@ -9,14 +11,17 @@ import {
   IPeersByDiscoveryEvents,
   IRelay,
   KeepAliveOptions,
-  PeersByDiscoveryResult
+  PeersByDiscoveryResult,
+  PubSubTopic,
+  ShardInfo
 } from "@waku/interfaces";
 import { Libp2p, Tags } from "@waku/interfaces";
-import debug from "debug";
+import { shardInfoToPubSubTopics } from "@waku/utils";
+import { Logger } from "@waku/utils";
 
 import { KeepAliveManager } from "./keep_alive_manager.js";
 
-const log = debug("waku:connection-manager");
+const log = new Logger("connection-manager");
 
 export const DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED = 1;
 export const DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER = 3;
@@ -33,13 +38,14 @@ export class ConnectionManager
   private dialAttemptsForPeer: Map<string, number> = new Map();
   private dialErrorsForPeer: Map<string, any> = new Map();
 
-  private currentActiveDialCount = 0;
+  private currentActiveParallelDialCount = 0;
   private pendingPeerDialQueue: Array<PeerId> = [];
 
   public static create(
     peerId: string,
     libp2p: Libp2p,
     keepAliveOptions: KeepAliveOptions,
+    pubsubTopics: PubSubTopic[],
     relay?: IRelay,
     options?: ConnectionManagerOptions
   ): ConnectionManager {
@@ -48,6 +54,7 @@ export class ConnectionManager
       instance = new ConnectionManager(
         libp2p,
         keepAliveOptions,
+        pubsubTopics,
         relay,
         options
       );
@@ -104,11 +111,13 @@ export class ConnectionManager
   private constructor(
     libp2p: Libp2p,
     keepAliveOptions: KeepAliveOptions,
+    private configuredPubSubTopics: PubSubTopic[],
     relay?: IRelay,
     options?: Partial<ConnectionManagerOptions>
   ) {
     super();
     this.libp2p = libp2p;
+    this.configuredPubSubTopics = configuredPubSubTopics;
     this.options = {
       maxDialAttemptsForPeer: DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER,
       maxBootstrapPeersAllowed: DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED,
@@ -119,14 +128,16 @@ export class ConnectionManager
     this.keepAliveManager = new KeepAliveManager(keepAliveOptions, relay);
 
     this.run()
-      .then(() => log(`Connection Manager is now running`))
-      .catch((error) => log(`Unexpected error while running service`, error));
+      .then(() => log.info(`Connection Manager is now running`))
+      .catch((error) =>
+        log.error(`Unexpected error while running service`, error)
+      );
 
     // libp2p emits `peer:discovery` events during its initialization
     // which means that before the ConnectionManager is initialized, some peers may have been discovered
     // we will dial the peers in peerStore ONCE before we start to listen to the `peer:discovery` events within the ConnectionManager
     this.dialPeerStorePeers().catch((error) =>
-      log(`Unexpected error while dialing peer store peers`, error)
+      log.error(`Unexpected error while dialing peer store peers`, error)
     );
   }
 
@@ -144,7 +155,7 @@ export class ConnectionManager
     try {
       await Promise.all(dialPromises);
     } catch (error) {
-      log(`Unexpected error while dialing peer store peers`, error);
+      log.error(`Unexpected error while dialing peer store peers`, error);
     }
   }
 
@@ -172,11 +183,13 @@ export class ConnectionManager
   }
 
   private async dialPeer(peerId: PeerId): Promise<void> {
-    this.currentActiveDialCount += 1;
+    this.currentActiveParallelDialCount += 1;
     let dialAttempt = 0;
     while (dialAttempt < this.options.maxDialAttemptsForPeer) {
       try {
-        log(`Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`);
+        log.info(
+          `Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`
+        );
         await this.libp2p.dial(peerId);
 
         const tags = await this.getTagNamesForPeer(peerId);
@@ -186,16 +199,21 @@ export class ConnectionManager
           conn.tags = Array.from(new Set([...conn.tags, ...tags]));
         });
 
-        this.dialAttemptsForPeer.delete(peerId.toString());
+        // instead of deleting the peer from the peer store, we set the dial attempt to -1
+        // this helps us keep track of peers that have been dialed before
+        this.dialAttemptsForPeer.set(peerId.toString(), -1);
+
         // Dialing succeeded, break the loop
         break;
       } catch (error) {
         if (error instanceof AggregateError) {
           // Handle AggregateError
-          log(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
+          log.error(
+            `Error dialing peer ${peerId.toString()} - ${error.errors}`
+          );
         } else {
           // Handle generic error
-          log(
+          log.error(
             `Error dialing peer ${peerId.toString()} - ${
               (error as any).message
             }`
@@ -209,7 +227,7 @@ export class ConnectionManager
     }
 
     // Always decrease the active dial count and process the dial queue
-    this.currentActiveDialCount--;
+    this.currentActiveParallelDialCount--;
     this.processDialQueue();
 
     // If max dial attempts reached and dialing failed, delete the peer
@@ -217,16 +235,24 @@ export class ConnectionManager
       try {
         const error = this.dialErrorsForPeer.get(peerId.toString());
 
-        let errorMessage;
-        if (error instanceof AggregateError) {
-          errorMessage = JSON.stringify(error.errors[0]);
-        } else {
-          errorMessage = error.message;
-        }
+        if (error) {
+          let errorMessage;
+          if (error instanceof AggregateError) {
+            if (!error.errors) {
+              log.warn(`No errors array found for AggregateError`);
+            } else if (error.errors.length === 0) {
+              log.warn(`Errors array is empty for AggregateError`);
+            } else {
+              errorMessage = JSON.stringify(error.errors[0]);
+            }
+          } else {
+            errorMessage = error.message;
+          }
 
-        log(
-          `Deleting undialable peer ${peerId.toString()} from peer store. Error: ${errorMessage}`
-        );
+          log.info(
+            `Deleting undialable peer ${peerId.toString()} from peer store. Reason: ${errorMessage}`
+          );
+        }
 
         this.dialErrorsForPeer.delete(peerId.toString());
         await this.libp2p.peerStore.delete(peerId);
@@ -242,9 +268,9 @@ export class ConnectionManager
     try {
       this.keepAliveManager.stop(peerId);
       await this.libp2p.hangUp(peerId);
-      log(`Dropped connection with peer ${peerId.toString()}`);
+      log.info(`Dropped connection with peer ${peerId.toString()}`);
     } catch (error) {
-      log(
+      log.error(
         `Error dropping connection with peer ${peerId.toString()} - ${error}`
       );
     }
@@ -253,12 +279,12 @@ export class ConnectionManager
   private processDialQueue(): void {
     if (
       this.pendingPeerDialQueue.length > 0 &&
-      this.currentActiveDialCount < this.options.maxParallelDials
+      this.currentActiveParallelDialCount < this.options.maxParallelDials
     ) {
       const peerId = this.pendingPeerDialQueue.shift();
       if (!peerId) return;
       this.attemptDial(peerId).catch((error) => {
-        log(error);
+        log.error(error);
       });
     }
   }
@@ -297,15 +323,15 @@ export class ConnectionManager
   }
 
   private async attemptDial(peerId: PeerId): Promise<void> {
-    if (this.currentActiveDialCount >= this.options.maxParallelDials) {
+    if (!(await this.shouldDialPeer(peerId))) return;
+
+    if (this.currentActiveParallelDialCount >= this.options.maxParallelDials) {
       this.pendingPeerDialQueue.push(peerId);
       return;
     }
 
-    if (!(await this.shouldDialPeer(peerId))) return;
-
     this.dialPeer(peerId).catch((err) => {
-      throw `Error dialing peer ${peerId.toString()} : ${err}`;
+      log.error(`Error dialing peer ${peerId.toString()} : ${err}`);
     });
   }
 
@@ -314,25 +340,12 @@ export class ConnectionManager
       void (async () => {
         const { id: peerId } = evt.detail;
 
-        const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(
-          Tags.BOOTSTRAP
-        );
-
-        this.dispatchEvent(
-          new CustomEvent<PeerId>(
-            isBootstrap
-              ? EPeersByDiscoveryEvents.PEER_DISCOVERY_BOOTSTRAP
-              : EPeersByDiscoveryEvents.PEER_DISCOVERY_PEER_EXCHANGE,
-            {
-              detail: peerId
-            }
-          )
-        );
+        await this.dispatchDiscoveryEvent(peerId);
 
         try {
           await this.attemptDial(peerId);
         } catch (error) {
-          log(`Error dialing peer ${peerId.toString()} : ${error}`);
+          log.error(`Error dialing peer ${peerId.toString()} : ${error}`);
         }
       })();
     },
@@ -390,15 +403,63 @@ export class ConnectionManager
   };
 
   /**
-   * Checks if the peer is dialable based on the following conditions:
-   * 1. If the peer is a bootstrap peer, it is only dialable if the number of current bootstrap connections is less than the max allowed.
-   * 2. If the peer is not a bootstrap peer
+   * Checks if the peer should be dialed based on the following conditions:
+   * 1. If the peer is already connected, don't dial
+   * 2. If the peer is not part of any of the configured pubsub topics, don't dial
+   * 3. If the peer is not dialable based on bootstrap status, don't dial
+   * 4. If the peer is already has an active dial attempt, or has been dialed before, don't dial it
+   * @returns true if the peer should be dialed, false otherwise
    */
   private async shouldDialPeer(peerId: PeerId): Promise<boolean> {
+    // if we're already connected to the peer, don't dial
     const isConnected = this.libp2p.getConnections(peerId).length > 0;
+    if (isConnected) {
+      log.warn(`Already connected to peer ${peerId.toString()}. Not dialing.`);
+      return false;
+    }
 
-    if (isConnected) return false;
+    // if the peer is not part of any of the configured pubsub topics, don't dial
+    if (!(await this.isPeerTopicConfigured(peerId))) {
+      const shardInfo = await this.getPeerShardInfo(
+        peerId,
+        this.libp2p.peerStore
+      );
+      log.warn(
+        `Discovered peer ${peerId.toString()} with ShardInfo ${shardInfo} is not part of any of the configured pubsub topics (${
+          this.configuredPubSubTopics
+        }). 
+            Not dialing.`
+      );
+      return false;
+    }
 
+    // if the peer is not dialable based on bootstrap status, don't dial
+    if (!(await this.isPeerDialableBasedOnBootstrapStatus(peerId))) {
+      log.warn(
+        `Peer ${peerId.toString()} is not dialable based on bootstrap status. Not dialing.`
+      );
+      return false;
+    }
+
+    // If the peer is already already has an active dial attempt, or has been dialed before, don't dial it
+    if (this.dialAttemptsForPeer.has(peerId.toString())) {
+      log.warn(
+        `Peer ${peerId.toString()} has already been attempted dial before, or already has a dial attempt in progress, skipping dial`
+      );
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Checks if the peer is dialable based on the following conditions:
+   * 1. If the peer is a bootstrap peer, it is only dialable if the number of current bootstrap connections is less than the max allowed.
+   * 2. If the peer is not a bootstrap peer
+   */
+  private async isPeerDialableBasedOnBootstrapStatus(
+    peerId: PeerId
+  ): Promise<boolean> {
     const tagNames = await this.getTagNamesForPeer(peerId);
 
     const isBootstrap = tagNames.some((tagName) => tagName === Tags.BOOTSTRAP);
@@ -418,6 +479,23 @@ export class ConnectionManager
     return false;
   }
 
+  private async dispatchDiscoveryEvent(peerId: PeerId): Promise<void> {
+    const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(
+      Tags.BOOTSTRAP
+    );
+
+    this.dispatchEvent(
+      new CustomEvent<PeerId>(
+        isBootstrap
+          ? EPeersByDiscoveryEvents.PEER_DISCOVERY_BOOTSTRAP
+          : EPeersByDiscoveryEvents.PEER_DISCOVERY_PEER_EXCHANGE,
+        {
+          detail: peerId
+        }
+      )
+    );
+  }
+
   /**
    * Fetches the tag names for a given peer
    */
@@ -426,8 +504,35 @@ export class ConnectionManager
       const peer = await this.libp2p.peerStore.get(peerId);
       return Array.from(peer.tags.keys());
     } catch (error) {
-      log(`Failed to get peer ${peerId}, error: ${error}`);
+      log.error(`Failed to get peer ${peerId}, error: ${error}`);
       return [];
     }
   }
+
+  private async isPeerTopicConfigured(peerId: PeerId): Promise<boolean> {
+    const shardInfo = await this.getPeerShardInfo(
+      peerId,
+      this.libp2p.peerStore
+    );
+
+    // If there's no shard information, simply return true
+    if (!shardInfo) return true;
+
+    const pubsubTopics = shardInfoToPubSubTopics(shardInfo);
+
+    const isTopicConfigured = pubsubTopics.some((topic) =>
+      this.configuredPubSubTopics.includes(topic)
+    );
+    return isTopicConfigured;
+  }
+
+  private async getPeerShardInfo(
+    peerId: PeerId,
+    peerStore: PeerStore
+  ): Promise<ShardInfo | undefined> {
+    const peer = await peerStore.get(peerId);
+    const shardInfoBytes = peer.metadata.get("shardInfo");
+    if (!shardInfoBytes) return undefined;
+    return decodeRelayShard(shardInfoBytes);
+  }
 }

package/src/lib/filter/index.ts

@@ -17,8 +17,12 @@ import type {
   Unsubscribe
 } from "@waku/interfaces";
 import { WakuMessage } from "@waku/proto";
-import { groupByContentTopic, toAsyncIterator } from "@waku/utils";
-import debug from "debug";
+import {
+  ensurePubsubTopicIsConfigured,
+  groupByContentTopic,
+  toAsyncIterator
+} from "@waku/utils";
+import { Logger } from "@waku/utils";
 import all from "it-all";
 import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
@@ -32,7 +36,7 @@ import {
   FilterSubscribeRpc
 } from "./filter_rpc.js";
 
-const log = debug("waku:filter:v2");
+const log = new Logger("filter:v2");
 
 type SubscriptionCallback<T extends IDecodedMessage> = {
   decoders: IDecoder<T>[];
@@ -46,7 +50,7 @@ export const FilterCodecs = {
 
 class Subscription {
   private readonly peer: Peer;
-  private readonly pubSubTopic: PubSubTopic;
+  private readonly pubsubTopic: PubSubTopic;
   private newStream: (peer: Peer) => Promise<Stream>;
 
   private subscriptionCallbacks: Map<
@@ -55,12 +59,12 @@ class Subscription {
   >;
 
   constructor(
-    pubSubTopic: PubSubTopic,
+    pubsubTopic: PubSubTopic,
     remotePeer: Peer,
     newStream: (peer: Peer) => Promise<Stream>
   ) {
     this.peer = remotePeer;
-    this.pubSubTopic = pubSubTopic;
+    this.pubsubTopic = pubsubTopic;
     this.newStream = newStream;
     this.subscriptionCallbacks = new Map();
   }
@@ -70,13 +74,23 @@ class Subscription {
     callback: Callback<T>
   ): Promise<void> {
     const decodersArray = Array.isArray(decoders) ? decoders : [decoders];
+
+    // check that all decoders are configured for the same pubsub topic as this subscription
+    decodersArray.forEach((decoder) => {
+      if (decoder.pubsubTopic !== this.pubsubTopic) {
+        throw new Error(
+          `Pubsub topic not configured: decoder is configured for pubsub topic ${decoder.pubsubTopic} but this subscription is for pubsub topic ${this.pubsubTopic}. Please create a new Subscription for the different pubsub topic.`
+        );
+      }
+    });
+
     const decodersGroupedByCT = groupByContentTopic(decodersArray);
     const contentTopics = Array.from(decodersGroupedByCT.keys());
 
     const stream = await this.newStream(this.peer);
 
     const request = FilterSubscribeRpc.createSubscribeRequest(
-      this.pubSubTopic,
+      this.pubsubTopic,
       contentTopics
     );
 
@@ -89,6 +103,12 @@ class Subscription {
         async (source) => await all(source)
       );
 
+      if (!res || !res.length) {
+        throw Error(
+          `No response received for request ${request.requestId}: ${res}`
+        );
+      }
+
       const { statusCode, requestId, statusDesc } =
         FilterSubscribeResponse.decode(res[0].slice());
 
@@ -98,7 +118,7 @@ class Subscription {
         );
       }
 
-      log(
+      log.info(
         "Subscribed to peer ",
         this.peer.id.toString(),
         "for content topics",
@@ -135,7 +155,7 @@ class Subscription {
   async unsubscribe(contentTopics: ContentTopic[]): Promise<void> {
     const stream = await this.newStream(this.peer);
     const unsubscribeRequest = FilterSubscribeRpc.createUnsubscribeRequest(
-      this.pubSubTopic,
+      this.pubsubTopic,
       contentTopics
     );
 
@@ -164,6 +184,12 @@ class Subscription {
         async (source) => await all(source)
       );
 
+      if (!res || !res.length) {
+        throw Error(
+          `No response received for request ${request.requestId}: ${res}`
+        );
+      }
+
       const { statusCode, requestId, statusDesc } =
         FilterSubscribeResponse.decode(res[0].slice());
 
@@ -173,9 +199,9 @@ class Subscription {
         );
       }
 
-      log("Ping successful");
+      log.info("Ping successful");
     } catch (error) {
-      log("Error pinging: ", error);
+      log.error("Error pinging: ", error);
       throw new Error("Error pinging: " + error);
     }
   }
@@ -184,7 +210,7 @@ class Subscription {
     const stream = await this.newStream(this.peer);
 
     const request = FilterSubscribeRpc.createUnsubscribeAllRequest(
-      this.pubSubTopic
+      this.pubsubTopic
     );
 
     try {
@@ -196,6 +222,12 @@ class Subscription {
         async (source) => await all(source)
       );
 
+      if (!res || !res.length) {
+        throw Error(
+          `No response received for request ${request.requestId}: ${res}`
+        );
+      }
+
       const { statusCode, requestId, statusDesc } =
         FilterSubscribeResponse.decode(res[0].slice());
 
@@ -206,7 +238,7 @@ class Subscription {
       }
 
       this.subscriptionCallbacks.clear();
-      log("Unsubscribed from all content topics");
+      log.info("Unsubscribed from all content topics");
     } catch (error) {
       throw new Error("Error unsubscribing from all content topics: " + error);
     }
@@ -216,50 +248,53 @@ class Subscription {
     const contentTopic = message.contentTopic;
     const subscriptionCallback = this.subscriptionCallbacks.get(contentTopic);
     if (!subscriptionCallback) {
-      log("No subscription callback available for ", contentTopic);
+      log.error("No subscription callback available for ", contentTopic);
       return;
     }
-    await pushMessage(subscriptionCallback, this.pubSubTopic, message);
+    await pushMessage(subscriptionCallback, this.pubsubTopic, message);
   }
 }
 
 class Filter extends BaseProtocol implements IReceiver {
-  private readonly options: ProtocolCreateOptions;
+  private readonly pubsubTopics: PubSubTopic[] = [];
   private activeSubscriptions = new Map<string, Subscription>();
   private readonly NUM_PEERS_PROTOCOL = 1;
 
   private getActiveSubscription(
-    pubSubTopic: PubSubTopic,
+    pubsubTopic: PubSubTopic,
     peerIdStr: PeerIdStr
   ): Subscription | undefined {
-    return this.activeSubscriptions.get(`${pubSubTopic}_${peerIdStr}`);
+    return this.activeSubscriptions.get(`${pubsubTopic}_${peerIdStr}`);
   }
 
   private setActiveSubscription(
-    pubSubTopic: PubSubTopic,
+    pubsubTopic: PubSubTopic,
     peerIdStr: PeerIdStr,
     subscription: Subscription
   ): Subscription {
-    this.activeSubscriptions.set(`${pubSubTopic}_${peerIdStr}`, subscription);
+    this.activeSubscriptions.set(`${pubsubTopic}_${peerIdStr}`, subscription);
     return subscription;
   }
 
   constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
     super(FilterCodecs.SUBSCRIBE, libp2p.components);
 
+    this.pubsubTopics = options?.pubsubTopics || [DefaultPubSubTopic];
+
     libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
-      log("Failed to register ", FilterCodecs.PUSH, e);
+      log.error("Failed to register ", FilterCodecs.PUSH, e);
     });
 
     this.activeSubscriptions = new Map();
-
-    this.options = options ?? {};
   }
 
-  async createSubscription(pubSubTopic?: string): Promise<Subscription> {
-    const _pubSubTopic =
-      pubSubTopic ?? this.options.pubSubTopic ?? DefaultPubSubTopic;
+  async createSubscription(
+    pubsubTopic: string = DefaultPubSubTopic
+  ): Promise<Subscription> {
+    ensurePubsubTopicIsConfigured(pubsubTopic, this.pubsubTopics);
 
+    //TODO: get a relevant peer for the topic/shard
+    // https://github.com/waku-org/js-waku/pull/1586#discussion_r1336428230
     const peer = (
       await this.getPeers({
         maxBootstrapPeers: 1,
@@ -268,11 +303,11 @@ class Filter extends BaseProtocol implements IReceiver {
     )[0];
 
     const subscription =
-      this.getActiveSubscription(_pubSubTopic, peer.id.toString()) ??
+      this.getActiveSubscription(pubsubTopic, peer.id.toString()) ??
       this.setActiveSubscription(
-        _pubSubTopic,
+        pubsubTopic,
         peer.id.toString(),
-        new Subscription(_pubSubTopic, peer, this.getStream.bind(this, peer))
+        new Subscription(pubsubTopic, peer, this.getStream.bind(this, peer))
       );
 
     return subscription;
@@ -319,7 +354,6 @@ class Filter extends BaseProtocol implements IReceiver {
   }
 
   private onRequest(streamData: IncomingStreamData): void {
-    log("Receiving message push");
     try {
       pipe(streamData.stream, lp.decode, async (source) => {
         for await (const bytes of source) {
@@ -328,12 +362,12 @@ class Filter extends BaseProtocol implements IReceiver {
           const { pubsubTopic, wakuMessage } = response;
 
           if (!wakuMessage) {
-            log("Received empty message");
+            log.error("Received empty message");
             return;
           }
 
           if (!pubsubTopic) {
-            log("PubSub topic missing from push message");
+            log.error("PubSub topic missing from push message");
             return;
           }
 
@@ -344,7 +378,9 @@ class Filter extends BaseProtocol implements IReceiver {
           );
 
           if (!subscription) {
-            log(`No subscription locally registered for topic ${pubsubTopic}`);
+            log.error(
+              `No subscription locally registered for topic ${pubsubTopic}`
+            );
             return;
           }
 
@@ -352,14 +388,14 @@ class Filter extends BaseProtocol implements IReceiver {
         }
       }).then(
         () => {
-          log("Receiving pipe closed.");
+          log.info("Receiving pipe closed.");
         },
         (e) => {
-          log("Error with receiving pipe", e);
+          log.error("Error with receiving pipe", e);
         }
       );
     } catch (e) {
-      log("Error decoding message", e);
+      log.error("Error decoding message", e);
     }
   }
 }
@@ -372,21 +408,21 @@ export function wakuFilter(
 
 async function pushMessage<T extends IDecodedMessage>(
   subscriptionCallback: SubscriptionCallback<T>,
-  pubSubTopic: PubSubTopic,
+  pubsubTopic: PubSubTopic,
   message: WakuMessage
 ): Promise<void> {
   const { decoders, callback } = subscriptionCallback;
 
   const { contentTopic } = message;
   if (!contentTopic) {
-    log("Message has no content topic, skipping");
+    log.warn("Message has no content topic, skipping");
     return;
   }
 
   try {
     const decodePromises = decoders.map((dec) =>
       dec
-        .fromProtoObj(pubSubTopic, message as IProtoMessage)
+        .fromProtoObj(pubsubTopic, message as IProtoMessage)
         .then((decoded) => decoded || Promise.reject("Decoding failed"))
     );
 
@@ -394,6 +430,6 @@ async function pushMessage<T extends IDecodedMessage>(
 
     await callback(decodedMessage);
   } catch (e) {
-    log("Error decoding message", e);
+    log.error("Error decoding message", e);
   }
 }