@aztec/p2p 0.87.6 → 0.87.8

package/src/mem_pools/tx_pool/aztec_kv_tx_pool.ts

@@ -15,7 +15,7 @@ import assert from 'assert';
 
 import { ArchiveCache } from '../../msg_validators/tx_validator/archive_cache.js';
 import { GasTxValidator } from '../../msg_validators/tx_validator/gas_validator.js';
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import { getPendingTxPriority } from './priority.js';
 import type { TxPool, TxPoolOptions } from './tx_pool.js';
 
@@ -49,9 +49,6 @@ export class AztecKVTxPool implements TxPool {
   /** The cumulative tx size in bytes that the pending txs in the pool take up. */
   #pendingTxSize: AztecAsyncSingleton<number>;
 
-  /** Count of total pending txs. */
-  #pendingTxCount: AztecAsyncSingleton<number>;
-
   /** In-memory mapping of pending tx hashes to the hydrated pending tx in the pool. */
   #pendingTxs: Map<string, Tx>;
 
@@ -102,7 +99,6 @@ export class AztecKVTxPool implements TxPool {
     this.#pendingTxHashToSize = store.openMap('pendingTxHashToSize');
     this.#pendingTxHashToHeaderHash = store.openMap('pendingTxHashToHeaderHash');
     this.#pendingTxSize = store.openSingleton('pendingTxSize');
-    this.#pendingTxCount = store.openSingleton('pendingTxCount');
 
     this.#pendingTxs = new Map<string, Tx>();
     this.#nonEvictableTxs = new Set<string>();
@@ -113,9 +109,20 @@ export class AztecKVTxPool implements TxPool {
     this.#store = store;
     this.#archive = archive;
     this.#worldStateSynchronizer = worldStateSynchronizer;
-    this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, () => store.estimateSize());
+    this.#metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, this.countTxs, () => store.estimateSize());
   }
 
+  private countTxs: PoolStatsCallback = async () => {
+    const [pending = 0, mined = 0] = await Promise.all([this.getPendingTxCount(), this.getMinedTxCount()]);
+
+    return Promise.resolve({
+      itemCount: {
+        pending,
+        mined,
+      },
+    });
+  };
+
   public async isEmpty(): Promise<boolean> {
     for await (const _ of this.#txs.entriesAsync()) {
       return false;
@@ -128,7 +135,6 @@ export class AztecKVTxPool implements TxPool {
       return Promise.resolve();
     }
 
-    let deletedPending = 0;
     const minedNullifiers = new Set<string>();
     const minedFeePayers = new Set<string>();
 
@@ -143,23 +149,13 @@ export class AztecKVTxPool implements TxPool {
           const nullifiers = tx.data.getNonEmptyNullifiers();
           nullifiers.forEach(nullifier => minedNullifiers.add(nullifier.toString()));
           minedFeePayers.add(tx.data.feePayer.toString());
-
-          deletedPending++;
           pendingTxSize -= tx.getSize();
           await this.removePendingTxIndices(tx, key);
         }
       }
-      this.#metrics.recordAddedObjects(txHashes.length, 'mined');
       await this.#pendingTxSize.set(pendingTxSize);
-      await this.increasePendingTxCount(-deletedPending);
 
-      const numTxsEvicted = await this.evictInvalidTxsAfterMining(
-        txHashes,
-        blockNumber,
-        minedNullifiers,
-        minedFeePayers,
-      );
-      this.#metrics.recordRemovedObjects(deletedPending + numTxsEvicted, 'pending');
+      await this.evictInvalidTxsAfterMining(txHashes, blockNumber, minedNullifiers, minedFeePayers);
     });
     // We update this after the transaction above. This ensures that the non-evictable transactions are not evicted
     // until any that have been mined are marked as such.
@@ -171,8 +167,6 @@ export class AztecKVTxPool implements TxPool {
     if (txHashes.length === 0) {
       return Promise.resolve();
     }
-
-    let markedAsPending = 0;
     await this.#store.transactionAsync(async () => {
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       for (const hash of txHashes) {
@@ -184,21 +178,14 @@ export class AztecKVTxPool implements TxPool {
         if (tx) {
           await this.addPendingTxIndices(tx, key);
           pendingTxSize += tx.getSize();
-          markedAsPending++;
         }
       }
 
       await this.#pendingTxSize.set(pendingTxSize);
     });
 
-    const numInvalidTxsEvicted = await this.evictInvalidTxsAfterReorg(txHashes);
-    const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(txHashes);
-
-    await this.increasePendingTxCount(markedAsPending);
-
-    this.#metrics.recordAddedObjects(markedAsPending - numNewTxsEvicted, 'pending');
-    this.#metrics.recordRemovedObjects(numInvalidTxsEvicted + numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
-    this.#metrics.recordRemovedObjects(markedAsPending, 'mined');
+    await this.evictInvalidTxsAfterReorg(txHashes);
+    await this.evictLowPriorityTxs(txHashes);
   }
 
   public async getPendingTxHashes(): Promise<TxHash[]> {
@@ -212,7 +199,11 @@ export class AztecKVTxPool implements TxPool {
   }
 
   public async getPendingTxCount(): Promise<number> {
-    return (await this.#pendingTxCount.getAsync()) ?? 0;
+    return (await this.#pendingTxHashToHeaderHash.sizeAsync()) ?? 0;
+  }
+
+  public async getMinedTxCount(): Promise<number> {
+    return (await this.#minedTxHashToBlock.sizeAsync()) ?? 0;
   }
 
   public async getTxStatus(txHash: TxHash): Promise<'pending' | 'mined' | undefined> {
@@ -284,7 +275,6 @@ export class AztecKVTxPool implements TxPool {
       txs.map(async tx => ({ txHash: await tx.getTxHash(), txStats: await tx.getStats() })),
     );
     await this.#store.transactionAsync(async () => {
-      let addedCount = 0;
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
       await Promise.all(
         txs.map(async (tx, i) => {
@@ -303,7 +293,6 @@ export class AztecKVTxPool implements TxPool {
           await this.#txs.set(key, tx.toBuffer());
 
           if (!(await this.#minedTxHashToBlock.hasAsync(key))) {
-            addedCount++;
             pendingTxSize += tx.getSize();
             await this.addPendingTxIndices(tx, key);
             this.#metrics.recordSize(tx);
@@ -311,14 +300,8 @@ export class AztecKVTxPool implements TxPool {
         }),
       );
 
-      await this.increasePendingTxCount(addedCount);
       await this.#pendingTxSize.set(pendingTxSize);
-      const { numLowPriorityTxsEvicted, numNewTxsEvicted } = await this.evictLowPriorityTxs(
-        hashesAndStats.map(({ txHash }) => txHash),
-      );
-
-      this.#metrics.recordAddedObjects(addedCount - numNewTxsEvicted, 'pending');
-      this.#metrics.recordRemovedObjects(numLowPriorityTxsEvicted - numNewTxsEvicted, 'pending');
+      await this.evictLowPriorityTxs(hashesAndStats.map(({ txHash }) => txHash));
     });
   }
 
@@ -328,9 +311,6 @@ export class AztecKVTxPool implements TxPool {
    * @returns Empty promise.
    */
   public deleteTxs(txHashes: TxHash[], eviction = false): Promise<void> {
-    let pendingDeleted = 0;
-    let minedDeleted = 0;
-
     const deletedTxs: Tx[] = [];
     const poolDbTx = this.#store.transactionAsync(async () => {
       let pendingTxSize = (await this.#pendingTxSize.getAsync()) ?? 0;
@@ -340,10 +320,7 @@ export class AztecKVTxPool implements TxPool {
 
         if (tx) {
           const isMined = await this.#minedTxHashToBlock.hasAsync(key);
-          if (isMined) {
-            minedDeleted++;
-          } else {
-            pendingDeleted++;
+          if (!isMined) {
             pendingTxSize -= tx.getSize();
             await this.removePendingTxIndices(tx, key);
           }
@@ -358,10 +335,6 @@ export class AztecKVTxPool implements TxPool {
       }
 
       await this.#pendingTxSize.set(pendingTxSize);
-      await this.increasePendingTxCount(-pendingDeleted);
-
-      this.#metrics.recordRemovedObjects(pendingDeleted, 'pending');
-      this.#metrics.recordRemovedObjects(minedDeleted, 'mined');
     });
 
     return this.#archivedTxLimit ? poolDbTx.then(() => this.archiveTxs(deletedTxs)) : poolDbTx;
@@ -670,12 +643,4 @@ export class AztecKVTxPool implements TxPool {
     await this.#pendingTxHashToHeaderHash.delete(txHash);
     this.#pendingTxs.delete(txHash);
   }
-
-  private async increasePendingTxCount(count: number): Promise<void> {
-    const pendingTxCount = (await this.#pendingTxCount.getAsync()) ?? 0;
-    this.#log.debug(
-      `Increasing pending tx count: current ${pendingTxCount} + count ${count} = ${pendingTxCount + count}`,
-    );
-    await this.#pendingTxCount.set(pendingTxCount + count);
-  }
 }

package/src/mem_pools/tx_pool/memory_tx_pool.ts

@@ -3,7 +3,7 @@ import type { TxAddedToPoolStats } from '@aztec/stdlib/stats';
 import { Tx, TxHash } from '@aztec/stdlib/tx';
 import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client';
 
-import { PoolInstrumentation, PoolName } from '../instrumentation.js';
+import { PoolInstrumentation, PoolName, type PoolStatsCallback } from '../instrumentation.js';
 import { getPendingTxPriority } from './priority.js';
 import type { TxPool, TxPoolOptions } from './tx_pool.js';
 
@@ -31,9 +31,18 @@ export class InMemoryTxPool implements TxPool {
     this.txs = new Map<bigint, Tx>();
     this.minedTxs = new Map();
     this.pendingTxs = new Set();
-    this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL);
+    this.metrics = new PoolInstrumentation(telemetry, PoolName.TX_POOL, this.countTx);
   }
 
+  private countTx: PoolStatsCallback = () => {
+    return Promise.resolve({
+      itemCount: {
+        mined: this.minedTxs.size,
+        pending: this.pendingTxs.size,
+      },
+    });
+  };
+
   public isEmpty(): Promise<boolean> {
     return Promise.resolve(this.txs.size === 0);
   }
@@ -44,8 +53,6 @@ export class InMemoryTxPool implements TxPool {
       this.minedTxs.set(key, blockNumber);
       this.pendingTxs.delete(key);
     }
-    this.metrics.recordRemovedObjects(txHashes.length, 'pending');
-    this.metrics.recordAddedObjects(txHashes.length, 'mined');
     return Promise.resolve();
   }
 
@@ -55,23 +62,15 @@ export class InMemoryTxPool implements TxPool {
     }
 
     const keys = txHashes.map(x => x.toBigInt());
-    let deleted = 0;
-    let added = 0;
     for (const key of keys) {
-      if (this.minedTxs.delete(key)) {
-        deleted++;
-      }
+      this.minedTxs.delete(key);
 
       // only add back to the pending set if we have the tx object
       if (this.txs.has(key)) {
-        added++;
         this.pendingTxs.add(key);
       }
     }
 
-    this.metrics.recordRemovedObjects(deleted, 'mined');
-    this.metrics.recordAddedObjects(added, 'pending');
-
     return Promise.resolve();
   }
 
@@ -131,7 +130,6 @@ export class InMemoryTxPool implements TxPool {
    * @returns Empty promise.
    */
   public async addTxs(txs: Tx[]): Promise<void> {
-    let pending = 0;
     for (const tx of txs) {
       const txHash = await tx.getTxHash();
       this.log.verbose(`Adding tx ${txHash.toString()} to pool`, {
@@ -142,14 +140,10 @@ export class InMemoryTxPool implements TxPool {
       const key = txHash.toBigInt();
       this.txs.set(key, tx);
       if (!this.minedTxs.has(key)) {
-        pending++;
         this.metrics.recordSize(tx);
         this.pendingTxs.add(key);
       }
     }
-
-    this.metrics.recordAddedObjects(pending, 'pending');
-    return;
   }
 
   /**
@@ -158,19 +152,13 @@ export class InMemoryTxPool implements TxPool {
    * @returns The number of transactions that was deleted from the pool.
    */
   public deleteTxs(txHashes: TxHash[]): Promise<void> {
-    let deletedMined = 0;
-    let deletedPending = 0;
-
     for (const txHash of txHashes) {
       const key = txHash.toBigInt();
       this.txs.delete(key);
-      deletedPending += this.pendingTxs.delete(key) ? 1 : 0;
-      deletedMined += this.minedTxs.delete(key) ? 1 : 0;
+      this.pendingTxs.delete(key);
+      this.minedTxs.delete(key);
     }
 
-    this.metrics.recordRemovedObjects(deletedPending, 'pending');
-    this.metrics.recordRemovedObjects(deletedMined, 'mined');
-
     return Promise.resolve();
   }
 

package/src/services/encoding.ts

@@ -4,7 +4,7 @@ import { sha256 } from '@aztec/foundation/crypto';
 import type { RPC } from '@chainsafe/libp2p-gossipsub/message';
 import type { DataTransform } from '@chainsafe/libp2p-gossipsub/types';
 import type { Message } from '@libp2p/interface';
-import { compressSync, uncompressSync } from 'snappy';
+import { compress, compressSync, uncompress, uncompressSync } from 'snappy';
 import xxhashFactory from 'xxhash-wasm';
 
 // Load WASM
@@ -76,4 +76,12 @@ export class SnappyTransform implements DataTransform {
     }
     return Buffer.from(compressSync(data));
   }
+
+  public outboundTransformAsync(data: Buffer): Promise<Buffer> {
+    return compress(data);
+  }
+
+  public inboundTransformAsync(data: Buffer): Promise<Buffer> {
+    return uncompress(data, { asBuffer: true }) as Promise<Buffer>;
+  }
 }

package/src/services/libp2p/instrumentation.ts

@@ -0,0 +1,39 @@
+import type { Timer } from '@aztec/foundation/timer';
+import type { TopicType } from '@aztec/stdlib/p2p';
+import {
+  Attributes,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type UpDownCounter,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+export class P2PInstrumentation {
+  private messageValidationDuration: Histogram;
+  private messagePrevalidationCount: UpDownCounter;
+
+  constructor(client: TelemetryClient, name: string) {
+    const meter = client.getMeter(name);
+
+    this.messageValidationDuration = meter.createHistogram(Metrics.P2P_GOSSIP_MESSAGE_VALIDATION_DURATION, {
+      unit: 'ms',
+      description: 'How long validating a gossiped message takes',
+      valueType: ValueType.INT,
+    });
+
+    this.messagePrevalidationCount = meter.createUpDownCounter(Metrics.P2P_GOSSIP_MESSAGE_PREVALIDATION_COUNT, {
+      description: 'How many message pass/fail prevalidation',
+      valueType: ValueType.INT,
+    });
+  }
+
+  public recordMessageValidation(topicName: TopicType, timerOrMs: Timer | number) {
+    const ms = typeof timerOrMs === 'number' ? timerOrMs : timerOrMs.ms();
+    this.messageValidationDuration.record(Math.ceil(ms), { [Attributes.TOPIC_NAME]: topicName });
+  }
+
+  public incMessagePrevalidationStatus(passed: boolean, topicName: TopicType | undefined) {
+    this.messagePrevalidationCount.add(1, { [Attributes.TOPIC_NAME]: topicName, [Attributes.OK]: passed });
+  }
+}

package/src/services/libp2p/libp2p_service.ts

@@ -2,6 +2,7 @@ import type { EpochCacheInterface } from '@aztec/epoch-cache';
 import { createLibp2pComponentLogger, createLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import { Timer } from '@aztec/foundation/timer';
 import type { AztecAsyncKVStore } from '@aztec/kv-store';
 import { protocolContractTreeRoot } from '@aztec/protocol-contracts';
 import type { L2BlockSource } from '@aztec/stdlib/block';
@@ -65,6 +66,7 @@ import { reqGoodbyeHandler } from '../reqresp/protocols/goodbye.js';
 import { pingHandler, reqRespBlockHandler, reqRespTxHandler, statusHandler } from '../reqresp/protocols/index.js';
 import { ReqResp } from '../reqresp/reqresp.js';
 import type { P2PBlockReceivedCallback, P2PService, PeerDiscoveryService } from '../service.js';
+import { P2PInstrumentation } from './instrumentation.js';
 
 interface ValidationResult {
   name: string;
@@ -107,6 +109,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
 
   private gossipSubEventHandler: (e: CustomEvent<GossipsubMessage>) => void;
 
+  private instrumentation: P2PInstrumentation;
+
   constructor(
     private clientType: T,
     private config: P2PConfig,
@@ -122,6 +126,8 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   ) {
     super(telemetry, 'LibP2PService');
 
+    this.instrumentation = new P2PInstrumentation(telemetry, 'LibP2PService');
+
     this.msgIdSeenValidators[TopicType.tx] = new MessageSeenValidator(config.seenMessageCacheSize);
     this.msgIdSeenValidators[TopicType.block_proposal] = new MessageSeenValidator(config.seenMessageCacheSize);
     this.msgIdSeenValidators[TopicType.block_attestation] = new MessageSeenValidator(config.seenMessageCacheSize);
@@ -501,25 +507,33 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
   }
 
   protected preValidateReceivedMessage(msg: Message, msgId: string, source: PeerId) {
-    const getValidator = () => {
-      if (msg.topic === this.topicStrings[TopicType.tx]) {
-        return this.msgIdSeenValidators[TopicType.tx];
-      }
-      if (msg.topic === this.topicStrings[TopicType.block_attestation]) {
-        return this.msgIdSeenValidators[TopicType.block_attestation];
-      }
-      if (msg.topic === this.topicStrings[TopicType.block_proposal]) {
-        return this.msgIdSeenValidators[TopicType.block_proposal];
-      }
-      this.logger.error(`Received message on unknown topic: ${msg.topic}`);
-    };
+    let topicType: TopicType | undefined;
+
+    switch (msg.topic) {
+      case this.topicStrings[TopicType.tx]:
+        topicType = TopicType.tx;
+        break;
+      case this.topicStrings[TopicType.block_attestation]:
+        topicType = TopicType.block_attestation;
+        break;
+      case this.topicStrings[TopicType.block_proposal]:
+        topicType = TopicType.block_proposal;
+        break;
+      default:
+        this.logger.error(`Received message on unknown topic: ${msg.topic}`);
+        break;
+    }
 
-    const validator = getValidator();
+    const validator = topicType ? this.msgIdSeenValidators[topicType] : undefined;
 
     if (!validator || !validator.addMessage(msgId)) {
+      this.instrumentation.incMessagePrevalidationStatus(false, topicType);
       this.node.services.pubsub.reportMessageValidationResult(msgId, source.toString(), TopicValidatorResult.Ignore);
       return false;
     }
+
+    this.instrumentation.incMessagePrevalidationStatus(true, topicType);
+
     return true;
   }
 
@@ -559,14 +573,20 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
     validationFunc: () => Promise<{ result: boolean; obj: T }>,
     msgId: string,
     source: PeerId,
+    topicType: TopicType,
   ): Promise<{ result: boolean; obj: T | undefined }> {
     let resultAndObj: { result: boolean; obj: T | undefined } = { result: false, obj: undefined };
+    const timer = new Timer();
     try {
       resultAndObj = await validationFunc();
     } catch (err) {
       this.logger.error(`Error deserialising and validating message `, err);
     }
 
+    if (resultAndObj.result) {
+      this.instrumentation.recordMessageValidation(topicType, timer);
+    }
+
     this.node.services.pubsub.reportMessageValidationResult(
       msgId,
       source.toString(),
@@ -582,7 +602,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       return { result, obj: tx };
     };
 
-    const { result, obj: tx } = await this.validateReceivedMessage<Tx>(validationFunc, msgId, source);
+    const { result, obj: tx } = await this.validateReceivedMessage<Tx>(validationFunc, msgId, source, TopicType.tx);
     if (!result || !tx) {
       return;
     }
@@ -613,6 +633,7 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       validationFunc,
       msgId,
       source,
+      TopicType.block_attestation,
     );
     if (!result || !attestation) {
       return;
@@ -640,7 +661,12 @@ export class LibP2PService<T extends P2PClientType = P2PClientType.Full> extends
       return { result, obj: block };
     };
 
-    const { result, obj: block } = await this.validateReceivedMessage<BlockProposal>(validationFunc, msgId, source);
+    const { result, obj: block } = await this.validateReceivedMessage<BlockProposal>(
+      validationFunc,
+      msgId,
+      source,
+      TopicType.block_proposal,
+    );
     if (!result || !block) {
       return;
     }

package/src/services/reqresp/reqresp.ts

@@ -5,7 +5,7 @@ import { executeTimeout } from '@aztec/foundation/timer';
 import { PeerErrorSeverity } from '@aztec/stdlib/p2p';
 import { Attributes, type TelemetryClient, getTelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
-import type { IncomingStreamData, PeerId, Stream } from '@libp2p/interface';
+import { CodeError, type IncomingStreamData, type PeerId, type Stream } from '@libp2p/interface';
 import { pipe } from 'it-pipe';
 import type { Libp2p } from 'libp2p';
 import type { Uint8ArrayList } from 'uint8arraylist';
@@ -538,7 +538,7 @@ export class ReqResp {
 
     // Timeout errors are punished with high tolerance, they can be due to a geogrpahically far away peer or an
     // overloaded peer
-    if (e instanceof IndividualReqRespTimeoutError) {
+    if (e instanceof IndividualReqRespTimeoutError || (e instanceof CodeError && e.code === 'ERR_TIMEOUT')) {
       this.logger.debug(
         `Timeout error: ${e.message} | peerId: ${peerId.toString()} | subProtocol: ${subProtocol}`,
         logTags,
@@ -573,7 +573,7 @@ export class ReqResp {
       }
 
       const messageData = Buffer.concat(chunks);
-      const message: Buffer = this.snappyTransform.inboundTransformNoTopic(messageData);
+      const message = await this.snappyTransform.inboundTransformAsync(messageData);
 
       return {
         status: statusBuffer ?? ReqRespStatus.UNKNOWN,
@@ -651,13 +651,13 @@ export class ReqResp {
             const successChunk = Buffer.from([ReqRespStatus.SUCCESS]);
             yield new Uint8Array(successChunk);
 
-            yield new Uint8Array(transform.outboundTransformNoTopic(response));
+            yield new Uint8Array(await transform.outboundTransformAsync(response));
           }
         },
         stream,
       );
     } catch (e: any) {
-      this.logger.warn('Reqresp Response error: ', e);
+      this.logger.warn(`Reqresp Response error: ${e?.name} ${e?.code} ${e?.message}`, { err: e, protocol });
       this.metrics.recordResponseError(protocol);
 
       // If we receive a known error, we use the error status in the response chunk, otherwise we categorize as unknown
@@ -677,7 +677,7 @@ export class ReqResp {
           stream,
         );
       } else {
-        this.logger.debug('Stream already closed, not sending error response', { protocol, err: e, errorStatus });
+        this.logger.trace('Stream already closed, not sending error response', { protocol, err: e, errorStatus });
       }
     } finally {
       //NOTE: All other status codes indicate closed stream.

package/src/services/tx_collect_instrumentation.ts

@@ -0,0 +1,44 @@
+import { Metrics, type TelemetryClient, type UpDownCounter } from '@aztec/telemetry-client';
+
+export class TxCollectorInstrumentation {
+  private txFromProposalCount: UpDownCounter;
+  private txFromMempoolCount: UpDownCounter;
+  private txFromP2PCount: UpDownCounter;
+  private missingTxsCount: UpDownCounter;
+
+  constructor(client: TelemetryClient, name: string) {
+    const meter = client.getMeter(name);
+
+    this.txFromProposalCount = meter.createUpDownCounter(Metrics.TX_COLLECTOR_TXS_FROM_PROPOSALS_COUNT, {
+      description: 'The number of txs taken from block proposals',
+    });
+
+    this.txFromMempoolCount = meter.createUpDownCounter(Metrics.TX_COLLECTOR_TXS_FROM_MEMPOOL_COUNT, {
+      description: 'The number of txs taken from the local mempool',
+    });
+
+    this.txFromP2PCount = meter.createUpDownCounter(Metrics.TX_COLLECTOR_TXS_FROM_P2P_COUNT, {
+      description: 'The number of txs taken from the p2p network',
+    });
+
+    this.missingTxsCount = meter.createUpDownCounter(Metrics.TX_COLLECTOR_MISSING_TXS_COUNT, {
+      description: 'The number of txs not found anywhere',
+    });
+  }
+
+  incTxsFromProposals(count: number) {
+    this.txFromProposalCount.add(count);
+  }
+
+  incTxsFromMempool(count: number) {
+    this.txFromMempoolCount.add(count);
+  }
+
+  incTxsFromP2P(count: number) {
+    this.txFromP2PCount.add(count);
+  }
+
+  incMissingTxs(count: number) {
+    this.missingTxsCount.add(count);
+  }
+}