Improve logger

blockchain-watcher/src/domain/actions/evm/HandleEvmLogs.ts

@@ -9,13 +9,13 @@ import { ethers } from "ethers";
 export class HandleEvmLogs<T> {
   cfg: HandleEvmConfig;
   mapper: (log: EvmLog, parsedArgs: ReadonlyArray<any>) => T;
-  target: (parsed: T[]) => Promise<void>;
+  target: (parsed: T[], chain: string) => Promise<void>;
   statsRepo: StatRepository;
 
   constructor(
     cfg: HandleEvmConfig,
     mapper: (log: EvmLog, args: ReadonlyArray<any>) => T,
-    target: (parsed: T[]) => Promise<void>,
+    target: (parsed: T[], chain: string) => Promise<void>,
     statsRepo: StatRepository
   ) {
     this.cfg = this.normalizeCfg(cfg);
@@ -39,7 +39,7 @@ export class HandleEvmLogs<T> {
         return logMap;
       });
 
-    await this.target(mappedItems);
+    await this.target(mappedItems, this.cfg.chain);
     // TODO: return a result specifying failures if any
     return mappedItems;
   }

blockchain-watcher/src/domain/actions/evm/HandleEvmTransactions.ts

@@ -9,13 +9,13 @@ import { StatRepository } from "../../repositories";
 export class HandleEvmTransactions<T> {
   cfg: HandleEvmConfig;
   mapper: (log: EvmTransaction) => T;
-  target: (parsed: T[]) => Promise<void>;
+  target: (parsed: T[], chain: string) => Promise<void>;
   statsRepo: StatRepository;
 
   constructor(
     cfg: HandleEvmConfig,
     mapper: (log: EvmTransaction) => T,
-    target: (parsed: T[]) => Promise<void>,
+    target: (parsed: T[], chain: string) => Promise<void>,
     statsRepo: StatRepository
   ) {
     this.cfg = this.normalizeCfg(cfg);
@@ -36,7 +36,7 @@ export class HandleEvmTransactions<T> {
       }
     }) as T[];
 
-    await this.target(filterItems);
+    await this.target(filterItems, this.cfg.chain);
     return filterItems;
   }
 

blockchain-watcher/src/domain/actions/solana/HandleSolanaTransactions.ts

@@ -8,14 +8,14 @@ import winston from "winston";
 export class HandleSolanaTransactions<T> {
   cfg: HandleSolanaTxConfig;
   mapper: (txs: solana.Transaction, args: { programId: string }) => Promise<T[]>;
-  target?: (parsed: T[]) => Promise<void>;
+  target?: (parsed: T[], chain: string) => Promise<void>;
   logger: winston.Logger = winston.child({ module: "HandleSolanaTransaction" });
   statsRepo?: StatRepository;
 
   constructor(
     cfg: HandleSolanaTxConfig,
     mapper: (tx: solana.Transaction) => Promise<T[]>,
-    target?: (parsed: T[]) => Promise<void>,
+    target?: (parsed: T[], chain: string) => Promise<void>,
     statsRepo?: StatRepository
   ) {
     this.cfg = cfg;
@@ -46,7 +46,7 @@ export class HandleSolanaTransactions<T> {
     }
 
     if (this.target) {
-      await this.target(mappedItems);
+      await this.target(mappedItems, this.cfg.chain);
     } else {
       this.logger.warn(`No target for ${this.cfg.programId} txs`);
     }

blockchain-watcher/src/domain/actions/sui/HandleSuiTransactions.ts

@@ -2,11 +2,14 @@ import { TransactionFoundEvent } from "../../entities";
 import { SuiTransactionBlockReceipt } from "../../entities/sui";
 import { StatRepository } from "../../repositories";
 
+const COMMITMENT = "immediate";
+const SUI_CHAIN = "sui";
+
 export class HandleSuiTransactions {
   constructor(
     private readonly cfg: HandleSuiTransactionsOptions,
     private readonly mapper: (tx: SuiTransactionBlockReceipt) => TransactionFoundEvent,
-    private readonly target: (parsed: TransactionFoundEvent[]) => Promise<void>,
+    private readonly target: (parsed: TransactionFoundEvent[], chain: string) => Promise<void>,
     private readonly statsRepo: StatRepository
   ) {}
 
@@ -21,7 +24,7 @@ export class HandleSuiTransactions {
       }
     }
 
-    await this.target(items);
+    await this.target(items, SUI_CHAIN);
 
     return items;
   }
@@ -37,8 +40,8 @@ export class HandleSuiTransactions {
 
     const labels = {
       job: this.cfg.id,
-      chain: "sui",
+      chain: SUI_CHAIN,
-      commitment: "immediate",
+      commitment: COMMITMENT,
     };
     this.statsRepo.count(this.cfg.metricName, labels);
   }

blockchain-watcher/src/infrastructure/repositories/SnsEventRepository.ts

@@ -22,9 +22,9 @@ export class SnsEventRepository {
     this.logger.info(`Created for topic ${cfg.topicArn}`);
   }
 
-  async publish(events: LogFoundEvent<any>[]): Promise<SnsPublishResult> {
+  async publish(events: LogFoundEvent<any>[], chain: string): Promise<SnsPublishResult> {
     if (!events.length) {
-      this.logger.debug("[publish] No events to publish, continuing...");
+      this.logger.debug(`[publish][${chain}] No events to publish, continuing...`);
       return {
         status: "success",
       };
@@ -63,7 +63,7 @@ export class SnsEventRepository {
 
       for (const result of results) {
         if (result.status !== "fulfilled") {
-          this.logger.error(`[publish] ${result.reason}`);
+          this.logger.error(`[publish][${chain}] ${result.reason}`);
           errors.push(result.reason);
         }
       }
@@ -82,18 +82,18 @@ export class SnsEventRepository {
       };
     }
 
-    this.logger.info(`[publish] Published ${events.length} events to SNS`);
+    this.logger.info(`[publish][${chain}] Published ${events.length} events to SNS`);
     return {
       status: "success",
     };
   }
 
-  async asTarget(): Promise<(events: LogFoundEvent<any>[]) => Promise<void>> {
+  async asTarget(): Promise<(events: LogFoundEvent<any>[], chain: string) => Promise<void>> {
-    return async (events: LogFoundEvent<any>[]) => {
+    return async (events: LogFoundEvent<any>[], chain: string) => {
-      const result = await this.publish(events);
+      const result = await this.publish(events, chain);
       if (result.status === "error") {
         this.logger.error(
-          `[asTarget] Error publishing events to SNS: ${result.reason ?? result.reasons}`
+          `[asTarget][${chain}] Error publishing events to SNS: ${result.reason ?? result.reasons}`
         );
         throw new Error(`Error publishing events to SNS: ${result.reason}`);
       }

blockchain-watcher/src/infrastructure/repositories/StaticJobRepository.ts

@@ -41,7 +41,8 @@ export class StaticJobRepository implements JobRepository {
   private handlers: Map<string, (cfg: any, target: string, mapper: any) => Promise<Handler>> =
     new Map();
   private mappers: Map<string, any> = new Map();
-  private targets: Map<string, () => Promise<(items: any[]) => Promise<void>>> = new Map();
+  private targets: Map<string, () => Promise<(items: any[], chain: string) => Promise<void>>> =
+    new Map();
   private blockRepoProvider: (chain: string) => EvmBlockRepository;
   private metadataRepo: MetadataRepository<any>;
   private statsRepo: StatRepository;
@@ -209,7 +210,7 @@ export class StaticJobRepository implements JobRepository {
     this.handlers.set("HandleSuiTransactions", handleSuiTx);
   }
 
-  private async getTarget(target: string): Promise<(items: any[]) => Promise<void>> {
+  private async getTarget(target: string): Promise<(items: any[], chain: string) => Promise<void>> {
     const maybeTarget = this.targets.get(this.dryRun ? "dummy" : target);
     if (!maybeTarget) {
       throw new Error(`Target ${target} not found`);

blockchain-watcher/test/infrastructure/repositories/SnsEventRepository.test.ts

@@ -10,7 +10,7 @@ describe("SnsEventRepository", () => {
   it("should not call sns client when no events given", async () => {
     givenSnsEventRepository();
 
-    const result = await snsEventRepository.publish([]);
+    const result = await snsEventRepository.publish([], "sui");
 
     expect(result).toEqual({ status: "success" });
     expect(snsClient.send).not.toHaveBeenCalled();
@@ -19,17 +19,20 @@ describe("SnsEventRepository", () => {
   it("should publish", async () => {
     givenSnsEventRepository();
 
-    const result = await snsEventRepository.publish([
+    const result = await snsEventRepository.publish(
-      {
+      [
-        chainId: 1,
+        {
-        address: "0x123456",
+          chainId: 1,
-        txHash: "0x123",
+          address: "0x123456",
-        blockHeight: 123n,
+          txHash: "0x123",
-        blockTime: 0,
+          blockHeight: 123n,
-        name: "LogMessagePublished",
+          blockTime: 0,
-        attributes: {},
+          name: "LogMessagePublished",
-      },
+          attributes: {},
-    ]);
+        },
+      ],
+      "sui"
+    );
 
     expect(result).toEqual({ status: "success" });
     expect(snsClient.send).toHaveBeenCalledTimes(1);