@aztec/bb-prover 0.42.0 → 0.44.0

package/src/instrumentation.ts

@@ -0,0 +1,149 @@
+import { type CircuitName } from '@aztec/circuit-types/stats';
+import { type Timer } from '@aztec/foundation/timer';
+import {
+  Attributes,
+  type Gauge,
+  type Histogram,
+  Metrics,
+  type TelemetryClient,
+  type Tracer,
+  ValueType,
+} from '@aztec/telemetry-client';
+
+/**
+ * Instrumentation class for Prover implementations.
+ */
+export class ProverInstrumentation {
+  private simulationDuration: Histogram;
+  private witGenDuration: Gauge;
+  private provingDuration: Gauge;
+
+  private witGenInputSize: Gauge;
+  private witGenOutputSize: Gauge;
+
+  private proofSize: Gauge;
+  private circuitSize: Gauge;
+  private circuitPublicInputCount: Gauge;
+
+  public readonly tracer: Tracer;
+
+  constructor(telemetry: TelemetryClient, name: string) {
+    this.tracer = telemetry.getTracer(name);
+    const meter = telemetry.getMeter(name);
+
+    this.simulationDuration = meter.createHistogram(Metrics.CIRCUIT_SIMULATION_DURATION, {
+      description: 'Records how long it takes to simulate a circuit',
+      unit: 's',
+      valueType: ValueType.DOUBLE,
+      advice: {
+        explicitBucketBoundaries: [0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30, 60],
+      },
+    });
+
+    this.witGenDuration = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_DURATION, {
+      description: 'Records how long it takes to generate the partial witness for a circuit',
+      unit: 's',
+      valueType: ValueType.DOUBLE,
+    });
+
+    // ideally this would be a histogram, but proving takes a long time on the server
+    // and they don't happen that often so Prometheus & Grafana have a hard time handling it
+    this.provingDuration = meter.createGauge(Metrics.CIRCUIT_PROVING_DURATION, {
+      unit: 's',
+      description: 'Records how long it takes to prove a circuit',
+      valueType: ValueType.DOUBLE,
+    });
+
+    this.witGenInputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_INPUT_SIZE, {
+      unit: 'By',
+      description: 'Records the size of the input to the witness generation',
+      valueType: ValueType.INT,
+    });
+
+    this.witGenOutputSize = meter.createGauge(Metrics.CIRCUIT_WITNESS_GEN_OUTPUT_SIZE, {
+      unit: 'By',
+      description: 'Records the size of the output of the witness generation',
+      valueType: ValueType.INT,
+    });
+
+    this.proofSize = meter.createGauge(Metrics.CIRCUIT_PROVING_PROOF_SIZE, {
+      unit: 'By',
+      description: 'Records the size of the proof generated for a circuit',
+      valueType: ValueType.INT,
+    });
+
+    this.circuitPublicInputCount = meter.createGauge(Metrics.CIRCUIT_PUBLIC_INPUTS_COUNT, {
+      description: 'Records the number of public inputs in a circuit',
+      valueType: ValueType.INT,
+    });
+
+    this.circuitSize = meter.createGauge(Metrics.CIRCUIT_SIZE, {
+      description: 'Records the size of the circuit in gates',
+      valueType: ValueType.INT,
+    });
+  }
+
+  /**
+   * Records the duration of a circuit operation.
+   * @param metric - The metric to record
+   * @param circuitName - The name of the circuit
+   * @param timerOrS - The duration
+   */
+  recordDuration(
+    metric: 'simulationDuration' | 'witGenDuration' | 'provingDuration',
+    circuitName: CircuitName,
+    timerOrS: Timer | number,
+  ) {
+    const s = typeof timerOrS === 'number' ? timerOrS : timerOrS.s();
+    this[metric].record(s, {
+      [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+      [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+    });
+  }
+
+  /**
+   * Records the duration of an AVM circuit operation.
+   * @param metric - The metric to record
+   * @param appCircuitName - The name of the function circuit (should be a `contract:function` string)
+   * @param timerOrS - The duration
+   */
+  recordAvmDuration(metric: 'witGenDuration' | 'provingDuration', appCircuitName: string, timerOrS: Timer | number) {
+    const s = typeof timerOrS === 'number' ? timerOrS : timerOrS.s();
+    this[metric].record(s, {
+      [Attributes.APP_CIRCUIT_NAME]: appCircuitName,
+    });
+  }
+
+  /**
+   * Records the size of a circuit operation.
+   * @param metric - Records the size of a circuit operation.
+   * @param circuitName - The name of the circuit
+   * @param size - The size
+   */
+  recordSize(
+    metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount',
+    circuitName: CircuitName,
+    size: number,
+  ) {
+    this[metric].record(Math.ceil(size), {
+      [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName,
+      [Attributes.PROTOCOL_CIRCUIT_TYPE]: 'server',
+    });
+  }
+
+  /**
+   * Records the size of an AVM circuit operation.
+   * @param metric - The metric to record
+   * @param appCircuitName - The name of the function circuit (should be a `contract:function` string)
+   * @param size - The size
+   */
+  recordAvmSize(
+    metric: 'witGenInputSize' | 'witGenOutputSize' | 'proofSize' | 'circuitSize' | 'circuitPublicInputCount',
+    appCircuitName: string,
+    size: number,
+  ) {
+    this[metric].record(Math.ceil(size), {
+      [Attributes.APP_CIRCUIT_NAME]: appCircuitName,
+    });
+  }
+}

package/src/prover/bb_native_proof_creator.ts

@@ -42,6 +42,7 @@ import { type NoirCompiledCircuit } from '@aztec/types/noir';
 import { serializeWitness } from '@noir-lang/noirc_abi';
 import { type WitnessMap } from '@noir-lang/types';
 import * as fs from 'fs/promises';
+import { join } from 'path';
 
 import {
   BB_RESULT,
@@ -175,7 +176,7 @@ export class BBNativeProofCreator implements ProofCreator {
       throw new Error(errorMessage);
     }
 
-    this.log.info(`Successfully verified ${circuitType} proof in ${result.duration} ms`);
+    this.log.info(`Successfully verified ${circuitType} proof in ${Math.ceil(result.durationMs)} ms`);
   }
 
   private async verifyProofFromKey(
@@ -304,13 +305,14 @@ export class BBNativeProofCreator implements ProofCreator {
   }> {
     const compressedBincodedWitness = serializeWitness(partialWitness);
 
-    const inputsWitnessFile = `${directory}/witness.gz`;
+    const inputsWitnessFile = join(directory, 'witness.gz');
 
     await fs.writeFile(inputsWitnessFile, compressedBincodedWitness);
 
     this.log.debug(`Written ${inputsWitnessFile}`);
 
-    this.log.info(`Proving ${circuitType} circuit...`);
+    const dbgCircuitName = appCircuitName ? `(${appCircuitName})` : '';
+    this.log.info(`Proving ${circuitType}${dbgCircuitName} circuit...`);
 
     const timer = new Timer();
 
@@ -324,13 +326,11 @@ export class BBNativeProofCreator implements ProofCreator {
     );
 
     if (provingResult.status === BB_RESULT.FAILURE) {
-      this.log.error(`Failed to generate proof for ${circuitType}: ${provingResult.reason}`);
+      this.log.error(`Failed to generate proof for ${circuitType}${dbgCircuitName}: ${provingResult.reason}`);
       throw new Error(provingResult.reason);
     }
 
-    this.log.info(
-      `Generated ${circuitType === 'App' ? appCircuitName : circuitType} circuit proof in ${timer.ms()} ms`,
-    );
+    this.log.info(`Generated ${circuitType}${dbgCircuitName} circuit proof in ${Math.ceil(timer.ms())} ms`);
 
     if (circuitType === 'App') {
       const vkData = await extractVkData(directory);
@@ -339,7 +339,7 @@ export class BBNativeProofCreator implements ProofCreator {
       this.log.debug(`Generated proof`, {
         eventName: 'circuit-proving',
         circuitName: 'app-circuit',
-        duration: provingResult.duration,
+        duration: provingResult.durationMs,
         inputSize: compressedBincodedWitness.length,
         proofSize: proof.binaryProof.buffer.length,
         appCircuitName,
@@ -358,7 +358,7 @@ export class BBNativeProofCreator implements ProofCreator {
 
     this.log.debug(`Generated proof`, {
       circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-      duration: provingResult.duration,
+      duration: provingResult.durationMs,
       eventName: 'circuit-proving',
       inputSize: compressedBincodedWitness.length,
       proofSize: proof.binaryProof.buffer.length,

package/src/prover/bb_prover.ts

@@ -4,7 +4,6 @@ import {
   type PublicInputsAndRecursiveProof,
   type PublicKernelNonTailRequest,
   type PublicKernelTailRequest,
-  PublicKernelType,
   type ServerCircuitProver,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/circuit-types';
@@ -58,6 +57,7 @@ import {
   convertRootRollupOutputsFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 import { NativeACVMSimulator } from '@aztec/simulator';
+import { Attributes, type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
 import { abiEncode } from '@noir-lang/noirc_abi';
 import { type Abi, type WitnessMap } from '@noir-lang/types';
@@ -79,6 +79,7 @@ import {
   writeProofAsFields,
 } from '../bb/execute.js';
 import type { ACVMConfig, BBConfig } from '../config.js';
+import { ProverInstrumentation } from '../instrumentation.js';
 import { PublicKernelArtifactMapping } from '../mappings/mappings.js';
 import { mapProtocolArtifactNameToCircuitName } from '../stats.js';
 import { extractVkData } from '../verification_key/verification_key_data.js';
@@ -103,9 +104,18 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     ServerProtocolArtifact,
     Promise<VerificationKeyData>
   >();
-  constructor(private config: BBProverConfig) {}
 
-  static async new(config: BBProverConfig) {
+  private instrumentation: ProverInstrumentation;
+
+  constructor(private config: BBProverConfig, telemetry: TelemetryClient) {
+    this.instrumentation = new ProverInstrumentation(telemetry, 'BBNativeRollupProver');
+  }
+
+  get tracer() {
+    return this.instrumentation.tracer;
+  }
+
+  static async new(config: BBProverConfig, telemetry: TelemetryClient) {
     await fs.access(config.acvmBinaryPath, fs.constants.R_OK);
     await fs.mkdir(config.acvmWorkingDirectory, { recursive: true });
     await fs.access(config.bbBinaryPath, fs.constants.R_OK);
@@ -113,7 +123,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     logger.info(`Using native BB at ${config.bbBinaryPath} and working directory ${config.bbWorkingDirectory}`);
     logger.info(`Using native ACVM at ${config.acvmBinaryPath} and working directory ${config.acvmWorkingDirectory}`);
 
-    return new BBNativeRollupProver(config);
+    return new BBNativeRollupProver(config, telemetry);
   }
 
   /**
@@ -121,6 +131,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs of the parity circuit.
    */
+  @trackSpan('BBNativeRollupProver.getBaseParityProof', { [Attributes.PROTOCOL_CIRCUIT_NAME]: 'base-parity' })
   public async getBaseParityProof(inputs: BaseParityInputs): Promise<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>> {
     const { circuitOutput, proof } = await this.createRecursiveProof(
       inputs,
@@ -142,6 +153,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs of the parity circuit.
    */
+  @trackSpan('BBNativeRollupProver.getRootParityProof', { [Attributes.PROTOCOL_CIRCUIT_NAME]: 'root-parity' })
   public async getRootParityProof(
     inputs: RootParityInputs,
   ): Promise<RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
@@ -165,6 +177,9 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @param inputs - The inputs to the AVM circuit.
    * @returns The proof.
    */
+  @trackSpan('BBNativeRollupProver.getAvmProof', inputs => ({
+    [Attributes.APP_CIRCUIT_NAME]: inputs.functionName,
+  }))
   public async getAvmProof(inputs: AvmCircuitInputs): Promise<ProofAndVerificationKey> {
     const proofAndVk = await this.createAvmProof(inputs);
     await this.verifyAvmProof(proofAndVk.proof, proofAndVk.verificationKey);
@@ -176,12 +191,17 @@ export class BBNativeRollupProver implements ServerCircuitProver {
    * @param kernelRequest - The object encapsulating the request for a proof
    * @returns The requested circuit's public inputs and proof
    */
+  @trackSpan('BBNativeRollupProver.getPublicKernelProof', kernelReq => ({
+    [Attributes.PROTOCOL_CIRCUIT_NAME]: mapProtocolArtifactNameToCircuitName(
+      PublicKernelArtifactMapping[kernelReq.type]!.artifact,
+    ),
+  }))
   public async getPublicKernelProof(
     kernelRequest: PublicKernelNonTailRequest,
   ): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
     const kernelOps = PublicKernelArtifactMapping[kernelRequest.type];
     if (kernelOps === undefined) {
-      throw new Error(`Unable to prove kernel type ${PublicKernelType[kernelRequest.type]}`);
+      throw new Error(`Unable to prove kernel type ${kernelRequest.type}`);
     }
 
     // We may need to convert the recursive proof into fields format
@@ -386,11 +406,16 @@ export class BBNativeRollupProver implements ServerCircuitProver {
     const inputWitness = convertInput(input);
     const timer = new Timer();
     const outputWitness = await simulator.simulateCircuit(inputWitness, artifact);
-    const witnessGenerationDuration = timer.ms();
     const output = convertOutput(outputWitness);
+
+    const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
+    this.instrumentation.recordDuration('witGenDuration', circuitName, timer);
+    this.instrumentation.recordSize('witGenInputSize', circuitName, input.toBuffer().length);
+    this.instrumentation.recordSize('witGenOutputSize', circuitName, output.toBuffer().length);
+
     logger.debug(`Generated witness`, {
-      circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-      duration: witnessGenerationDuration,
+      circuitName,
+      duration: timer.ms(),
       inputSize: input.toBuffer().length,
       outputSize: output.toBuffer().length,
       eventName: 'circuit-witness-generation',
@@ -440,22 +465,24 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       const rawProof = await fs.readFile(`${provingResult.proofPath!}/${PROOF_FILENAME}`);
 
       const proof = new Proof(rawProof, vkData.numPublicInputs);
-      logger.info(
-        `Generated proof for ${circuitType} in ${Math.ceil(provingResult.duration)} ms, size: ${
-          proof.buffer.length
-        } bytes`,
-        {
-          circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
-          // does not include reading the proof from disk
-          duration: provingResult.duration,
-          proofSize: proof.buffer.length,
-          eventName: 'circuit-proving',
-          // circuitOutput is the partial witness that became the input to the proof
-          inputSize: output.toBuffer().length,
-          circuitSize: vkData.circuitSize,
-          numPublicInputs: vkData.numPublicInputs,
-        } satisfies CircuitProvingStats,
-      );
+      const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
+
+      this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs / 1000);
+      this.instrumentation.recordSize('proofSize', circuitName, proof.buffer.length);
+      this.instrumentation.recordSize('circuitPublicInputCount', circuitName, vkData.numPublicInputs);
+      this.instrumentation.recordSize('circuitSize', circuitName, vkData.circuitSize);
+
+      logger.info(`Generated proof for ${circuitType} in ${Math.ceil(provingResult.durationMs)} ms`, {
+        circuitName,
+        // does not include reading the proof from disk
+        duration: provingResult.durationMs,
+        proofSize: proof.buffer.length,
+        eventName: 'circuit-proving',
+        // circuitOutput is the partial witness that became the input to the proof
+        inputSize: output.toBuffer().length,
+        circuitSize: vkData.circuitSize,
+        numPublicInputs: vkData.numPublicInputs,
+      } satisfies CircuitProvingStats);
 
       return { circuitOutput: output, proof };
     };
@@ -463,12 +490,12 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }
 
   private async generateAvmProofWithBB(input: AvmCircuitInputs, workingDirectory: string): Promise<BBSuccess> {
-    logger.debug(`Proving avm-circuit...`);
+    logger.info(`Proving avm-circuit for ${input.functionName}...`);
 
-    const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger.debug);
+    const provingResult = await generateAvmProof(this.config.bbBinaryPath, workingDirectory, input, logger.verbose);
 
     if (provingResult.status === BB_RESULT.FAILURE) {
-      logger.error(`Failed to generate proof for avm-circuit: ${provingResult.reason}`);
+      logger.error(`Failed to generate AVM proof for ${input.functionName}: ${provingResult.reason}`);
       throw new Error(provingResult.reason);
     }
 
@@ -476,7 +503,11 @@ export class BBNativeRollupProver implements ServerCircuitProver {
   }
 
   private async createAvmProof(input: AvmCircuitInputs): Promise<ProofAndVerificationKey> {
+    const cleanupDir: boolean = !process.env.AVM_PROVING_PRESERVE_WORKING_DIR;
     const operation = async (bbWorkingDirectory: string): Promise<ProofAndVerificationKey> => {
+      if (!cleanupDir) {
+        logger.info(`Preserving working directory ${bbWorkingDirectory}`);
+      }
       const provingResult = await this.generateAvmProofWithBB(input, bbWorkingDirectory);
 
       const rawProof = await fs.readFile(provingResult.proofPath!);
@@ -486,25 +517,30 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       const proof = new Proof(rawProof, verificationKey.numPublicInputs);
 
       const circuitType = 'avm-circuit' as const;
+      const appCircuitName = 'unknown' as const;
+      this.instrumentation.recordAvmDuration('provingDuration', appCircuitName, provingResult.durationMs);
+      this.instrumentation.recordAvmSize('proofSize', appCircuitName, proof.buffer.length);
+      this.instrumentation.recordAvmSize('circuitPublicInputCount', appCircuitName, verificationKey.numPublicInputs);
+      this.instrumentation.recordAvmSize('circuitSize', appCircuitName, verificationKey.circuitSize);
+
       logger.info(
-        `Generated proof for ${circuitType} in ${Math.ceil(provingResult.duration)} ms, size: ${
-          proof.buffer.length
-        } bytes`,
+        `Generated proof for ${circuitType}(${input.functionName}) in ${Math.ceil(provingResult.durationMs)} ms`,
         {
           circuitName: circuitType,
+          appCircuitName: input.functionName,
           // does not include reading the proof from disk
-          duration: provingResult.duration,
+          duration: provingResult.durationMs,
           proofSize: proof.buffer.length,
           eventName: 'circuit-proving',
           inputSize: input.toBuffer().length,
-          circuitSize: verificationKey.circuitSize,
-          numPublicInputs: verificationKey.numPublicInputs,
+          circuitSize: verificationKey.circuitSize, // FIX: wrong in VK
+          numPublicInputs: verificationKey.numPublicInputs, // FIX: wrong in VK
         } satisfies CircuitProvingStats,
       );
 
       return { proof, verificationKey };
     };
-    return await runInDirectory(this.config.bbWorkingDirectory, operation);
+    return await runInDirectory(this.config.bbWorkingDirectory, operation, cleanupDir);
   }
 
   /**
@@ -537,14 +573,19 @@ export class BBNativeRollupProver implements ServerCircuitProver {
       // Read the proof as fields
       const proof = await this.readProofAsFields(provingResult.proofPath!, circuitType, proofLength);
 
+      const circuitName = mapProtocolArtifactNameToCircuitName(circuitType);
+      this.instrumentation.recordDuration('provingDuration', circuitName, provingResult.durationMs / 1000);
+      this.instrumentation.recordSize('proofSize', circuitName, proof.binaryProof.buffer.length);
+      this.instrumentation.recordSize('circuitPublicInputCount', circuitName, vkData.numPublicInputs);
+      this.instrumentation.recordSize('circuitSize', circuitName, vkData.circuitSize);
       logger.info(
-        `Generated proof for ${circuitType} in ${Math.ceil(provingResult.duration)} ms, size: ${
+        `Generated proof for ${circuitType} in ${Math.ceil(provingResult.durationMs)} ms, size: ${
           proof.proof.length
         } fields`,
         {
-          circuitName: mapProtocolArtifactNameToCircuitName(circuitType),
+          circuitName,
           circuitSize: vkData.circuitSize,
-          duration: provingResult.duration,
+          duration: provingResult.durationMs,
           inputSize: output.toBuffer().length,
           proofSize: proof.binaryProof.buffer.length,
           eventName: 'circuit-proving',
@@ -606,7 +647,7 @@ export class BBNativeRollupProver implements ServerCircuitProver {
         throw new Error(errorMessage);
       }
 
-      logger.debug(`Successfully verified proof from key in ${result.duration} ms`);
+      logger.debug(`Successfully verified proof from key in ${result.durationMs} ms`);
     };
 
     await runInDirectory(this.config.bbWorkingDirectory, operation);

package/src/stats.ts

@@ -1,21 +1,7 @@
-import { type PublicKernelRequest, PublicKernelType } from '@aztec/circuit-types';
 import type { CircuitName } from '@aztec/circuit-types/stats';
 import { type ClientProtocolArtifact, type ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types';
 
-export function mapPublicKernelToCircuitName(kernelType: PublicKernelRequest['type']): CircuitName {
-  switch (kernelType) {
-    case PublicKernelType.SETUP:
-      return 'public-kernel-setup';
-    case PublicKernelType.APP_LOGIC:
-      return 'public-kernel-app-logic';
-    case PublicKernelType.TEARDOWN:
-      return 'public-kernel-teardown';
-    case PublicKernelType.TAIL:
-      return 'public-kernel-tail';
-    default:
-      throw new Error(`Unknown kernel type: ${kernelType}`);
-  }
-}
+export { mapPublicKernelToCircuitName } from '@aztec/circuit-types';
 
 export function mapProtocolArtifactNameToCircuitName(
   artifact: ServerProtocolArtifact | ClientProtocolArtifact,

package/src/test/test_circuit_prover.ts

@@ -3,7 +3,6 @@ import {
   type PublicInputsAndRecursiveProof,
   type PublicKernelNonTailRequest,
   type PublicKernelTailRequest,
-  PublicKernelType,
   type ServerCircuitProver,
   makePublicInputsAndRecursiveProof,
 } from '@aztec/circuit-types';
@@ -58,7 +57,9 @@ import {
   convertSimulatedPublicTailOutputFromWitnessMap,
 } from '@aztec/noir-protocol-circuits-types';
 import { type SimulationProvider, WASMSimulator, emitCircuitSimulationStats } from '@aztec/simulator';
+import { type TelemetryClient, trackSpan } from '@aztec/telemetry-client';
 
+import { ProverInstrumentation } from '../instrumentation.js';
 import { SimulatedPublicKernelArtifactMapping } from '../mappings/mappings.js';
 import { mapPublicKernelToCircuitName } from '../stats.js';
 
@@ -82,11 +83,19 @@ const VERIFICATION_KEYS: Record<ServerProtocolArtifact, VerificationKeyAsFields>
  */
 export class TestCircuitProver implements ServerCircuitProver {
   private wasmSimulator = new WASMSimulator();
+  private instrumentation: ProverInstrumentation;
 
   constructor(
+    telemetry: TelemetryClient,
     private simulationProvider?: SimulationProvider,
     private logger = createDebugLogger('aztec:test-prover'),
-  ) {}
+  ) {
+    this.instrumentation = new ProverInstrumentation(telemetry, 'TestCircuitProver');
+  }
+
+  get tracer() {
+    return this.instrumentation.tracer;
+  }
 
   public async getEmptyPrivateKernelProof(
     inputs: PrivateKernelEmptyInputData,
@@ -112,6 +121,7 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs of the parity circuit.
    */
+  @trackSpan('TestCircuitProver.getBaseParityProof')
   public async getBaseParityProof(inputs: BaseParityInputs): Promise<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>> {
     const timer = new Timer();
     const witnessMap = convertBaseParityInputsToWitnessMap(inputs);
@@ -126,6 +136,8 @@ export class TestCircuitProver implements ServerCircuitProver {
       result,
     );
 
+    this.instrumentation.recordDuration('simulationDuration', 'base-parity', timer);
+
     emitCircuitSimulationStats(
       'base-parity',
       timer.ms(),
@@ -142,6 +154,7 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @param inputs - Inputs to the circuit.
    * @returns The public inputs of the parity circuit.
    */
+  @trackSpan('TestCircuitProver.getRootParityProof')
   public async getRootParityProof(
     inputs: RootParityInputs,
   ): Promise<RootParityInput<typeof NESTED_RECURSIVE_PROOF_LENGTH>> {
@@ -159,6 +172,7 @@ export class TestCircuitProver implements ServerCircuitProver {
       result,
     );
 
+    this.instrumentation.recordDuration('simulationDuration', 'root-parity', timer);
     emitCircuitSimulationStats(
       'root-parity',
       timer.ms(),
@@ -175,6 +189,7 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
+  @trackSpan('TestCircuitProver.getBaseRollupProof')
   public async getBaseRollupProof(
     input: BaseRollupInputs,
   ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
@@ -186,6 +201,7 @@ export class TestCircuitProver implements ServerCircuitProver {
 
     const result = convertSimulatedBaseRollupOutputsFromWitnessMap(witness);
 
+    this.instrumentation.recordDuration('simulationDuration', 'base-rollup', timer);
     emitCircuitSimulationStats(
       'base-rollup',
       timer.ms(),
@@ -204,6 +220,7 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
+  @trackSpan('TestCircuitProver.getMergeRollupProof')
   public async getMergeRollupProof(
     input: MergeRollupInputs,
   ): Promise<PublicInputsAndRecursiveProof<BaseOrMergeRollupPublicInputs>> {
@@ -215,6 +232,7 @@ export class TestCircuitProver implements ServerCircuitProver {
 
     const result = convertMergeRollupOutputsFromWitnessMap(witness);
 
+    this.instrumentation.recordDuration('simulationDuration', 'merge-rollup', timer);
     emitCircuitSimulationStats(
       'merge-rollup',
       timer.ms(),
@@ -234,6 +252,7 @@ export class TestCircuitProver implements ServerCircuitProver {
    * @param input - Inputs to the circuit.
    * @returns The public inputs as outputs of the simulation.
    */
+  @trackSpan('TestCircuitProver.getRootRollupProof')
   public async getRootRollupProof(
     input: RootRollupInputs,
   ): Promise<PublicInputsAndRecursiveProof<RootRollupPublicInputs>> {
@@ -245,6 +264,7 @@ export class TestCircuitProver implements ServerCircuitProver {
 
     const result = convertRootRollupOutputsFromWitnessMap(witness);
 
+    this.instrumentation.recordDuration('simulationDuration', 'root-rollup', timer);
     emitCircuitSimulationStats(
       'root-rollup',
       timer.ms(),
@@ -259,13 +279,14 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
+  @trackSpan('TestCircuitProver.getPublicKernelProof')
   public async getPublicKernelProof(
     kernelRequest: PublicKernelNonTailRequest,
   ): Promise<PublicInputsAndRecursiveProof<PublicKernelCircuitPublicInputs>> {
     const timer = new Timer();
     const kernelOps = SimulatedPublicKernelArtifactMapping[kernelRequest.type];
     if (kernelOps === undefined) {
-      throw new Error(`Unable to prove for kernel type ${PublicKernelType[kernelRequest.type]}`);
+      throw new Error(`Unable to prove for kernel type ${kernelRequest.type}`);
     }
     const witnessMap = kernelOps.convertInputs(kernelRequest.inputs);
 
@@ -275,8 +296,10 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
 
     const result = kernelOps.convertOutputs(witness);
+    const circuitName = mapPublicKernelToCircuitName(kernelRequest.type);
+    this.instrumentation.recordDuration('simulationDuration', circuitName, timer);
     emitCircuitSimulationStats(
-      mapPublicKernelToCircuitName(kernelRequest.type),
+      circuitName,
       timer.ms(),
       kernelRequest.inputs.toBuffer().length,
       result.toBuffer().length,
@@ -290,6 +313,7 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
   }
 
+  @trackSpan('TestCircuitProver.getPublicTailProof')
   public async getPublicTailProof(
     kernelRequest: PublicKernelTailRequest,
   ): Promise<PublicInputsAndRecursiveProof<KernelCircuitPublicInputs>> {
@@ -302,6 +326,7 @@ export class TestCircuitProver implements ServerCircuitProver {
     );
 
     const result = convertSimulatedPublicTailOutputFromWitnessMap(witness);
+    this.instrumentation.recordDuration('simulationDuration', 'public-kernel-tail', timer);
     emitCircuitSimulationStats(
       'public-kernel-tail',
       timer.ms(),