Added @trace decorator

Author: rpanic

packages/api/src/metrics/OpenTelemetryServer.ts

@@ -24,7 +24,7 @@ export type OpenTelemetryServerConfig = {
     prometheus?: ConstructorParameters<typeof PrometheusExporter>[0];
     nodeScrapeInterval?: number;
   };
-  tracing: {
+  tracing?: {
     enabled?: boolean;
     otlp?: ConstructorParameters<typeof OTLPTraceExporter>[0];
   };

packages/sequencer/src/logging/trace.ts

@@ -0,0 +1,33 @@
+import snakeCase from "lodash/snakeCase";
+
+import { Tracer } from "./Tracer";
+
+type Attributes = Record<string, string | number | boolean>;
+
+export function trace<P extends any[], R>(
+  name?: string,
+  metadata?: ((p: P /*, r: R*/) => Attributes) | Attributes
+) {
+  return (
+    target: { tracer: Tracer },
+    methodName: string,
+    descriptor: TypedPropertyDescriptor<(...args: P) => Promise<R>>
+  ) => {
+    const originalMethod = descriptor.value!;
+
+    descriptor.value = async function replaced(
+      this: { tracer: Tracer },
+      ...args: P
+    ) {
+      const metadataRecord =
+        typeof metadata === "function" ? metadata(args) : metadata;
+      return await this.tracer.trace(
+        name ?? snakeCase(methodName),
+        async () => {
+          return await originalMethod.bind(this)(...args);
+        },
+        metadataRecord ?? {}
+      );
+    };
+  };
+}

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

@@ -30,11 +30,13 @@ import { CachedStateService } from "../../state/state/CachedStateService";
 import { AsyncStateService } from "../../state/async/AsyncStateService";
 import { distinctByPredicate } from "../../helpers/utils";
 import { Tracer } from "../../logging/Tracer";
+import { trace } from "../../logging/trace";
 
 type MempoolTransactionPaths = {
   transaction: PendingTransaction;
   paths: Field[];
 };
+
 @sequencerModule()
 export class PrivateMempool extends SequencerModule implements Mempool {
   public readonly events = new EventEmitter<MempoolEvents>();
@@ -51,7 +53,7 @@ export class PrivateMempool extends SequencerModule implements Mempool {
     private readonly sequencer: Sequencer<SequencerModulesRecord>,
     @inject("UnprovenStateService")
     private readonly stateService: AsyncStateService,
-    @inject("Tracer") private readonly tracer: Tracer
+    @inject("Tracer") public readonly tracer: Tracer
   ) {
     super();
     this.accountStateHook =
@@ -102,30 +104,25 @@ export class PrivateMempool extends SequencerModule implements Mempool {
     return result?.result.afterNetworkState;
   }
 
+  @trace("mempool.get_txs")
   public async getTxs(limit?: number): Promise<PendingTransaction[]> {
-    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;
-    });
+    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;
   }
 
   // We iterate through the transactions. For each tx we run the account state hook.
@@ -135,6 +132,7 @@ export class PrivateMempool extends SequencerModule implements Mempool {
   // because a failed tx may succeed now if the failure was to do with a nonce issue, say.
   // TODO Refactor
   // eslint-disable-next-line sonarjs/cognitive-complexity
+  @trace("mempool.validate_txs")
   private async checkTxValid(
     transactions: PendingTransaction[],
     baseService: CachedStateService,

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

@@ -22,6 +22,7 @@ import { Tracer } from "../../logging/Tracer";
 import { BlockProofSerializer } from "./tasks/serializers/BlockProofSerializer";
 import { BatchTracingService } from "./tracing/BatchTracingService";
 import { BatchFlow } from "./flow/BatchFlow";
+import { trace } from "../../logging/trace";
 
 export type StateRecord = Record<string, Field[] | undefined>;
 
@@ -54,7 +55,7 @@ export class BatchProducerModule extends SequencerModule {
     @inject("Database")
     private readonly database: Database,
     @inject("Tracer")
-    private readonly tracer: Tracer,
+    public readonly tracer: Tracer,
     private readonly batchFlow: BatchFlow,
     private readonly blockProofSerializer: BlockProofSerializer,
     private readonly batchTraceService: BatchTracingService
@@ -138,6 +139,7 @@ export class BatchProducerModule extends SequencerModule {
     noop();
   }
 
+  @trace("batch")
   private async produceBatch(
     blocks: BlockWithResult[],
     height: number

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

@@ -29,6 +29,7 @@ import { Tracer } from "../../../logging/Tracer";
 
 import { BlockProductionService } from "./BlockProductionService";
 import { BlockResultService } from "./BlockResultService";
+import { trace } from "../../../logging/trace";
 
 export interface BlockConfig {
   allowEmptyBlock?: boolean;
@@ -108,6 +109,7 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
     }
   }
 
+  @trace("block.metadata", ([block]) => ({ height: block.height.toString() }))
   public async generateMetadata(block: Block): Promise<BlockResult> {
     const traceMetadata = {
       height: block.height.toString(),
@@ -135,10 +137,7 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
   public async tryProduceBlock(): Promise<Block | undefined> {
     if (!this.productionInProgress) {
       try {
-        const block = await this.tracer.trace(
-          "block",
-          async () => await this.produceBlock()
-        );
+        const block = await this.produceBlock();
 
         if (block === undefined) {
           if (!this.allowEmptyBlock()) {
@@ -168,6 +167,7 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
     return undefined;
   }
 
+  @trace("block.collect_inputs")
   private async collectProductionData(): Promise<{
     txs: PendingTransaction[];
     metadata: BlockWithResult;
@@ -210,13 +210,11 @@ export class BlockProducerModule extends SequencerModule<BlockConfig> {
     };
   }
 
+  @trace("block")
   private async produceBlock(): Promise<Block | undefined> {
     this.productionInProgress = true;
 
-    const { txs, metadata } = await this.tracer.trace(
-      "block.collect_inputs",
-      async () => await this.collectProductionData()
-    );
+    const { txs, metadata } = await this.collectProductionData();
 
     // Skip production if no transactions are available for now
     if (txs.length === 0 && !this.allowEmptyBlock()) {

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

@@ -42,6 +42,8 @@ import {
   TransactionExecutionResult,
 } from "../../../storage/model/Block";
 import { UntypedStateTransition } from "../helpers/UntypedStateTransition";
+import { trace } from "../../../logging/trace";
+import { Tracer } from "../../../logging/Tracer";
 
 const errors = {
   methodIdNotFound: (methodId: string) =>
@@ -185,7 +187,9 @@ export class TransactionExecutionService {
     protocol: Protocol<MandatoryProtocolModulesRecord & ProtocolModulesRecord>,
     // Coming in from the appchain scope (accessible by protocol & runtime)
     @inject("StateServiceProvider")
-    private readonly stateServiceProvider: StateServiceProvider
+    private readonly stateServiceProvider: StateServiceProvider,
+    @inject("Tracer")
+    public readonly tracer: Tracer
   ) {
     this.transactionHooks = protocol.dependencyContainer.resolveAll(
       "ProvableTransactionHook"
@@ -277,6 +281,11 @@ export class TransactionExecutionService {
     );
   }
 
+  @trace("block.transaction", ([, tx, networkState]) => ({
+    height: networkState.block.height.toString(),
+    methodId: tx.methodId.toString(),
+    isMessage: tx.isMessage,
+  }))
   public async createExecutionTrace(
     asyncStateService: CachedStateService,
     tx: PendingTransaction,

packages/stack/src/scripts/graphql/server.ts

@@ -195,7 +195,14 @@ export async function startServer() {
         MerkleWitnessResolver: {},
       },
 
-      OpenTelemetryServer: {},
+      OpenTelemetryServer: {
+        tracing: {
+          enabled: true,
+          otlp: {
+            url: "http://localhost:4318",
+          },
+        },
+      },
 
       Database: {
         // redis: {