Integrated tracing points into block prod pipeline

Author: rpanic

packages/sequencer/src/mempool/private/PrivateMempool.ts

@@ -29,6 +29,7 @@ import {
 import { CachedStateService } from "../../state/state/CachedStateService";
 import { AsyncStateService } from "../../state/async/AsyncStateService";
 import { distinctByPredicate } from "../../helpers/utils";
+import { Tracer } from "../../logging/Tracer";
 
 type MempoolTransactionPaths = {
   transaction: PendingTransaction;
@@ -49,13 +50,19 @@ export class PrivateMempool extends SequencerModule implements Mempool {
     @inject("Sequencer")
     private readonly sequencer: Sequencer<SequencerModulesRecord>,
     @inject("UnprovenStateService")
-    private readonly stateService: AsyncStateService
+    private readonly stateService: AsyncStateService,
+    @inject("Tracer") private readonly tracer: Tracer
   ) {
     super();
     this.accountStateHook =
       this.protocol.dependencyContainer.resolve("AccountState");
   }
 
+  public async length(): Promise<number> {
+    const txs = await this.transactionStorage.getPendingUserTransactions();
+    return txs.length;
+  }
+
   public async add(tx: PendingTransaction): Promise<boolean> {
     const [txValid, error] = this.transactionValidator.validateTx(tx);
     if (txValid) {
@@ -96,22 +103,29 @@ export class PrivateMempool extends SequencerModule implements Mempool {
   }
 
   public async getTxs(limit?: number): Promise<PendingTransaction[]> {
-    const txs = await this.transactionStorage.getPendingUserTransactions();
-
-    const baseCachedStateService = new CachedStateService(this.stateService);
-
-    const networkState =
-      (await this.getStagedNetworkState()) ?? NetworkState.empty();
-
-    const sortedTxs = await this.checkTxValid(
-      txs,
-      baseCachedStateService,
-      this.protocol.stateServiceProvider,
-      networkState,
-      limit
-    );
-    this.protocol.stateServiceProvider.popCurrentStateService();
-    return sortedTxs;
+    return await this.tracer.trace("mempool.get_txs", async () => {
+      const txs = await this.transactionStorage.getPendingUserTransactions();
+
+      const baseCachedStateService = new CachedStateService(this.stateService);
+
+      const networkState =
+        (await this.getStagedNetworkState()) ?? NetworkState.empty();
+
+      const sortedTxs = await this.tracer.trace(
+        "mempool.validate_txs",
+        async () =>
+          await this.checkTxValid(
+            txs,
+            baseCachedStateService,
+            this.protocol.stateServiceProvider,
+            networkState,
+            limit
+          )
+      );
+
+      this.protocol.stateServiceProvider.popCurrentStateService();
+      return sortedTxs;
+    });
   }
 
   // We iterate through the transactions. For each tx we run the account state hook.

packages/sequencer/src/protocol/production/BatchProducerModule.ts

@@ -17,6 +17,7 @@ import { CachedMerkleTreeStore } from "../../state/merkle/CachedMerkleTreeStore"
 import { AsyncMerkleTreeStore } from "../../state/async/AsyncMerkleTreeStore";
 import { BlockWithResult } from "../../storage/model/Block";
 import type { Database } from "../../storage/Database";
+import { Tracer } from "../../logging/Tracer";
 
 import { BlockProofSerializer } from "./tasks/serializers/BlockProofSerializer";
 import { BatchTracingService } from "./tracing/BatchTracingService";
@@ -52,6 +53,8 @@ export class BatchProducerModule extends SequencerModule {
     @inject("BatchStorage") private readonly batchStorage: BatchStorage,
     @inject("Database")
     private readonly database: Database,
+    @inject("Tracer")
+    private readonly tracer: Tracer,
     private readonly batchFlow: BatchFlow,
     private readonly blockProofSerializer: BlockProofSerializer,
     private readonly batchTraceService: BatchTracingService

packages/sequencer/src/protocol/production/sequencing/BlockProducerModule.ts

@@ -25,6 +25,7 @@ import {
 } from "../../../storage/model/Block";
 import { MessageStorage } from "../../../storage/repositories/MessageStorage";
 import { Database } from "../../../storage/Database";
+import { Tracer } from "../../../logging/Tracer";
 
 import { BlockProductionService } from "./BlockProductionService";
 import { BlockResultService } from "./BlockResultService";
@@ -54,7 +55,8 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
     @inject("MethodIdResolver")
     private readonly methodIdResolver: MethodIdResolver,
     @inject("Runtime") private readonly runtime: Runtime<RuntimeModulesRecord>,
-    @inject("Database") private readonly database: Database
+    @inject("Database") private readonly database: Database,
+    @inject("Tracer") public readonly tracer: Tracer
   ) {
     super();
   }
@@ -107,6 +109,10 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
   }
 
   public async generateMetadata(block: Block): Promise<BlockResult> {
+    const traceMetadata = {
+      height: block.height.toString(),
+    };
+
     const { result, blockHashTreeStore, treeStore, stateService } =
       await this.resultService.generateMetadataForNextBlock(
         block,
@@ -129,7 +135,10 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
   public async tryProduceBlock(): Promise<Block | undefined> {
     if (!this.productionInProgress) {
       try {
-        const block = await this.produceBlock();
+        const block = await this.tracer.trace(
+          "block",
+          async () => await this.produceBlock()
+        );
 
         if (block === undefined) {
           if (!this.allowEmptyBlock()) {
@@ -204,7 +213,10 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
   private async produceBlock(): Promise<Block | undefined> {
     this.productionInProgress = true;
 
-    const { txs, metadata } = await this.collectProductionData();
+    const { txs, metadata } = await this.tracer.trace(
+      "block.collect_inputs",
+      async () => await this.collectProductionData()
+    );
 
     // Skip production if no transactions are available for now
     if (txs.length === 0 && !this.allowEmptyBlock()) {
@@ -221,10 +233,18 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
     if (blockResult !== undefined) {
       const { block, stateChanges } = blockResult;
 
-      await this.database.executeInTransaction(async () => {
-        await stateChanges.mergeIntoParent();
-        await this.blockQueue.pushBlock(block);
-      });
+      await this.tracer.trace(
+        "block.commit",
+        async () =>
+          // Push changes to the database atomically
+          await this.database.executeInTransaction(async () => {
+            await stateChanges.mergeIntoParent();
+            await this.blockQueue.pushBlock(block);
+          }),
+        {
+          height: block.height.toString(),
+        }
+      );
     }
 
     this.productionInProgress = false;

packages/sequencer/src/protocol/production/sequencing/BlockProductionService.ts

@@ -31,6 +31,7 @@ import {
   executeWithExecutionContext,
   TransactionExecutionService,
 } from "./TransactionExecutionService";
+import { Tracer } from "../../../logging/Tracer";
 
 @injectable()
 @scoped(Lifecycle.ContainerScoped)
@@ -40,6 +41,8 @@ export class BlockProductionService {
   public constructor(
     @inject("Protocol")
     protocol: Protocol<MandatoryProtocolModulesRecord & ProtocolModulesRecord>,
+    @inject("Tracer")
+    private readonly tracer: Tracer,
     private readonly transactionExecutionService: TransactionExecutionService,
     @inject("StateServiceProvider")
     private readonly stateServiceProvider: StateServiceProvider

packages/sequencer/src/protocol/production/trigger/TimedBlockTrigger.ts

@@ -34,7 +34,7 @@ export interface TimedBlockTriggerEvent extends BlockEvents {
 @closeable()
 export class TimedBlockTrigger
   extends BlockTriggerBase<TimedBlockTriggerConfig, TimedBlockTriggerEvent>
-  implements BlockTrigger, Closeable
+  implements Closeable
 {
   // There is no real type for interval ids somehow, so any it is
 
@@ -122,6 +122,7 @@ export class TimedBlockTrigger
   }
 
   private async produceUnprovenBlock() {
+    // TODO Optimize towards mempool.length()
     const mempoolTxs = await this.mempool.getTxs();
     // Produce a block if either produceEmptyBlocks is true or we have more
     // than 1 tx in mempool