@aztec/prover-client 0.0.0-test.0

package/src/proving_broker/config.ts

@@ -0,0 +1,138 @@
+import { type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum';
+import {
+  type ConfigMappingsType,
+  booleanConfigHelper,
+  getDefaultConfig,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
+import { type DataStoreConfig, dataConfigMappings } from '@aztec/kv-store/config';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+
+import { z } from 'zod';
+
+export const ProverBrokerConfig = z.object({
+  /** If starting a prover broker locally, the max number of retries per proving job */
+  proverBrokerJobMaxRetries: z.number().int().nonnegative(),
+  /** If starting a prover broker locally, the time after which a job times out and gets assigned to a different agent */
+  proverBrokerJobTimeoutMs: z.number().int().nonnegative(),
+  /** If starting a prover broker locally, the interval the broker checks for timed out jobs */
+  proverBrokerPollIntervalMs: z.number().int().nonnegative(),
+  /** If starting a prover broker locally, the directory to store broker data */
+  dataDirectory: z.string().optional(),
+  /** The size of the data store map */
+  dataStoreMapSizeKB: z.number().int().nonnegative(),
+  /** The prover broker may batch jobs together before writing to the database */
+  proverBrokerBatchSize: z.number().int().nonnegative(),
+  /** How often the job batches get flushed */
+  proverBrokerBatchIntervalMs: z.number().int().nonnegative(),
+  /** The maximum number of epochs to keep results for */
+  proverBrokerMaxEpochsToKeepResultsFor: z.number().int().nonnegative(),
+});
+
+export type ProverBrokerConfig = z.infer<typeof ProverBrokerConfig> &
+  Pick<DataStoreConfig, 'dataStoreMapSizeKB' | 'dataDirectory'> &
+  L1ReaderConfig;
+
+export const proverBrokerConfigMappings: ConfigMappingsType<ProverBrokerConfig> = {
+  proverBrokerJobTimeoutMs: {
+    env: 'PROVER_BROKER_JOB_TIMEOUT_MS',
+    description: 'Jobs are retried if not kept alive for this long',
+    ...numberConfigHelper(30_000),
+  },
+  proverBrokerPollIntervalMs: {
+    env: 'PROVER_BROKER_POLL_INTERVAL_MS',
+    description: 'The interval to check job health status',
+    ...numberConfigHelper(1_000),
+  },
+  proverBrokerJobMaxRetries: {
+    env: 'PROVER_BROKER_JOB_MAX_RETRIES',
+    description: 'If starting a prover broker locally, the max number of retries per proving job',
+    ...numberConfigHelper(3),
+  },
+  proverBrokerBatchSize: {
+    env: 'PROVER_BROKER_BATCH_SIZE',
+    description: 'The prover broker writes jobs to disk in batches',
+    ...numberConfigHelper(100),
+  },
+  proverBrokerBatchIntervalMs: {
+    env: 'PROVER_BROKER_BATCH_INTERVAL_MS',
+    description: 'How often to flush batches to disk',
+    ...numberConfigHelper(50),
+  },
+  proverBrokerMaxEpochsToKeepResultsFor: {
+    env: 'PROVER_BROKER_MAX_EPOCHS_TO_KEEP_RESULTS_FOR',
+    description: 'The maximum number of epochs to keep results for',
+    ...numberConfigHelper(1),
+  },
+  ...l1ReaderConfigMappings,
+  ...dataConfigMappings,
+};
+
+export const defaultProverBrokerConfig: ProverBrokerConfig = getDefaultConfig(proverBrokerConfigMappings);
+
+export const ProverAgentConfig = z.object({
+  /** The number of prover agents to start */
+  proverAgentCount: z.number(),
+  /** The types of proofs the prover agent can generate */
+  proverAgentProofTypes: z.array(z.nativeEnum(ProvingRequestType)),
+  /** How often the prover agents poll for jobs */
+  proverAgentPollIntervalMs: z.number(),
+  /** The URL where this agent takes jobs from */
+  proverBrokerUrl: z.string().optional(),
+  /** Whether to construct real proofs */
+  realProofs: z.boolean(),
+  /** The type of artificial delay to introduce */
+  proverTestDelayType: z.enum(['fixed', 'realistic']),
+  /** If using fixed delay, the time each operation takes. */
+  proverTestDelayMs: z.number(),
+  /** If using realistic delays, what percentage of realistic times to apply. */
+  proverTestDelayFactor: z.number(),
+});
+
+export type ProverAgentConfig = z.infer<typeof ProverAgentConfig>;
+
+export const proverAgentConfigMappings: ConfigMappingsType<ProverAgentConfig> = {
+  proverAgentCount: {
+    env: 'PROVER_AGENT_COUNT',
+    description: 'Whether this prover has a local prover agent',
+    ...numberConfigHelper(1),
+  },
+  proverAgentPollIntervalMs: {
+    env: 'PROVER_AGENT_POLL_INTERVAL_MS',
+    description: 'The interval agents poll for jobs at',
+    ...numberConfigHelper(100),
+  },
+  proverAgentProofTypes: {
+    env: 'PROVER_AGENT_PROOF_TYPES',
+    description: 'The types of proofs the prover agent can generate',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(v => ProvingRequestType[v as any])
+        .filter(v => typeof v === 'number'),
+  },
+  proverBrokerUrl: {
+    env: 'PROVER_BROKER_HOST',
+    description: 'The URL where this agent takes jobs from',
+  },
+  realProofs: {
+    env: 'PROVER_REAL_PROOFS',
+    description: 'Whether to construct real proofs',
+    ...booleanConfigHelper(false),
+  },
+  proverTestDelayType: {
+    env: 'PROVER_TEST_DELAY_TYPE',
+    description: 'The type of artificial delay to introduce',
+    defaultValue: 'fixed',
+  },
+  proverTestDelayMs: {
+    env: 'PROVER_TEST_DELAY_MS',
+    description: 'Artificial delay to introduce to all operations to the test prover.',
+    ...numberConfigHelper(0),
+  },
+  proverTestDelayFactor: {
+    env: 'PROVER_TEST_DELAY_FACTOR',
+    description: 'If using realistic delays, what percentage of realistic times to apply.',
+    ...numberConfigHelper(1),
+  },
+};

package/src/proving_broker/factory.ts

@@ -0,0 +1,18 @@
+import type { TelemetryClient } from '@aztec/telemetry-client';
+
+import type { ProverBrokerConfig } from './config.js';
+import { ProvingBroker } from './proving_broker.js';
+import { InMemoryBrokerDatabase } from './proving_broker_database/memory.js';
+import { KVBrokerDatabase } from './proving_broker_database/persisted.js';
+
+export async function createAndStartProvingBroker(
+  config: ProverBrokerConfig,
+  client: TelemetryClient,
+): Promise<ProvingBroker> {
+  const database = config.dataDirectory ? await KVBrokerDatabase.new(config, client) : new InMemoryBrokerDatabase();
+
+  const broker = new ProvingBroker(database, config, client);
+
+  await broker.start();
+  return broker;
+}

package/src/proving_broker/fixtures.ts

@@ -0,0 +1,15 @@
+import { randomBytes } from '@aztec/foundation/crypto';
+import { type ProofUri, type ProvingJobId, makeProvingJobId } from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+
+export function makeRandomProvingJobId(epochNumber?: number): ProvingJobId {
+  return makeProvingJobId(epochNumber ?? 1, ProvingRequestType.BASE_PARITY, randomBytes(8).toString('hex'));
+}
+
+export function makeInputsUri(): ProofUri {
+  return randomBytes(8).toString('hex') as ProofUri;
+}
+
+export function makeOutputsUri(): ProofUri {
+  return randomBytes(8).toString('hex') as ProofUri;
+}

package/src/proving_broker/index.ts

@@ -0,0 +1,9 @@
+export * from './proving_agent.js';
+export * from './proving_broker.js';
+export * from './rpc.js';
+export * from './proving_broker_database.js';
+export * from './proving_broker_database/memory.js';
+export * from './proving_broker_database/persisted.js';
+export * from './proof_store/index.js';
+export * from './factory.js';
+export * from './config.js';

package/src/proving_broker/proof_store/factory.ts

@@ -0,0 +1,42 @@
+import { createLogger } from '@aztec/foundation/log';
+
+import { GoogleCloudStorageProofStore } from './gcs_proof_store.js';
+import { InlineProofStore } from './inline_proof_store.js';
+import type { ProofStore } from './proof_store.js';
+
+export function createProofStore(config: string | undefined, logger = createLogger('prover-client:proof-store')) {
+  if (config === undefined) {
+    logger.info('Creating inline proof store');
+    return new InlineProofStore();
+  } else if (config.startsWith('gs://')) {
+    try {
+      const url = new URL(config);
+      const bucket = url.host;
+      const path = url.pathname.replace(/^\/+/, '');
+      logger.info(`Creating google cloud proof store at ${bucket}`, { bucket, path });
+      return new GoogleCloudStorageProofStore(bucket, path);
+    } catch (err) {
+      throw new Error(
+        `Invalid google cloud proof store definition: '${config}'. Supported values are 'gs://bucket-name/path/to/store'.`,
+      );
+    }
+  } else {
+    throw new Error(`Unknown proof store config: '${config}'. Supported values are 'gs://bucket-name/path/to/store'.`);
+  }
+}
+
+export function createProofStoreForUri(
+  uri: string,
+  logger = createLogger('prover-client:proof-store'),
+): Pick<ProofStore, 'getProofInput' | 'getProofOutput'> {
+  if (uri.startsWith('data://')) {
+    return createProofStore(undefined, logger);
+  } else if (uri.startsWith('gs://')) {
+    const url = new URL(uri);
+    const basePath = url.pathname.replace(/^\/+/, '').split('/').slice(0, -3);
+    url.pathname = basePath.join('/');
+    return createProofStore(uri, logger);
+  } else {
+    throw new Error(`Unknown proof store config: '${uri}'. Supported protocols are 'data://' and 'gs://'.`);
+  }
+}

package/src/proving_broker/proof_store/gcs_proof_store.ts

@@ -0,0 +1,72 @@
+import {
+  type ProofUri,
+  type ProvingJobId,
+  type ProvingJobInputs,
+  type ProvingJobInputsMap,
+  type ProvingJobResult,
+  type ProvingJobResultsMap,
+  getProvingJobInputClassFor,
+} from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+
+import { Storage } from '@google-cloud/storage';
+import { join } from 'path';
+
+import type { ProofStore } from './proof_store.js';
+
+const INPUTS_PATH = 'inputs';
+
+export class GoogleCloudStorageProofStore implements ProofStore {
+  private readonly storage: Storage;
+
+  constructor(private readonly bucketName: string, private readonly path: string) {
+    this.storage = new Storage();
+  }
+
+  public async saveProofInput<T extends ProvingRequestType>(
+    id: ProvingJobId,
+    type: T,
+    inputs: ProvingJobInputsMap[T],
+  ): Promise<ProofUri> {
+    const path = join(this.path, INPUTS_PATH, ProvingRequestType[type], id);
+    const file = this.storage.bucket(this.bucketName).file(path);
+    await file.save(inputs.toBuffer());
+    return file.cloudStorageURI.toString() as ProofUri;
+  }
+
+  saveProofOutput<T extends ProvingRequestType>(
+    _id: ProvingJobId,
+    _type: T,
+    _result: ProvingJobResultsMap[T],
+  ): Promise<ProofUri> {
+    throw new Error('Not implemented');
+  }
+
+  public async getProofInput(uri: ProofUri): Promise<ProvingJobInputs> {
+    try {
+      const url = new URL(uri);
+      const bucket = this.storage.bucket(url.host);
+      const path = url.pathname.replace(/^\/+/, '');
+      const file = bucket.file(path);
+      if (!(await file.exists())) {
+        throw new Error(`File at ${uri} does not exist`);
+      }
+
+      const typeString = path.split('/').at(-2);
+      const type = typeString ? ProvingRequestType[typeString as keyof typeof ProvingRequestType] : undefined;
+      if (type === undefined) {
+        throw new Error(`Unrecognized proof type ${type} in path ${path}`);
+      }
+
+      const contents = await file.download();
+      const inputs = getProvingJobInputClassFor(type).fromBuffer(contents[0]);
+      return { inputs, type } as ProvingJobInputs;
+    } catch (err) {
+      throw new Error(`Error getting proof input at ${uri}: ${err}`);
+    }
+  }
+
+  getProofOutput(_uri: ProofUri): Promise<ProvingJobResult> {
+    throw new Error('Not implemented');
+  }
+}

package/src/proving_broker/proof_store/index.ts

@@ -0,0 +1,3 @@
+export * from './proof_store.js';
+export * from './inline_proof_store.js';
+export * from './factory.js';

package/src/proving_broker/proof_store/inline_proof_store.ts

@@ -0,0 +1,63 @@
+import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc';
+import {
+  type ProofUri,
+  type ProvingJobId,
+  ProvingJobInputs,
+  type ProvingJobInputsMap,
+  ProvingJobResult,
+  type ProvingJobResultsMap,
+} from '@aztec/stdlib/interfaces/server';
+import type { ProvingRequestType } from '@aztec/stdlib/proofs';
+import type { ZodFor } from '@aztec/stdlib/schemas';
+
+import type { ProofStore } from './proof_store.js';
+
+// use an ASCII encoded data uri https://datatracker.ietf.org/doc/html/rfc2397#section-2
+// we do this to avoid double encoding to base64 (since the inputs already serialize to a base64 string)
+const PREFIX = 'data:application/json;charset=utf-8';
+const SEPARATOR = ',';
+
+/**
+ * An implementation of a proof input/output database that stores data inline in the URI.
+ */
+export class InlineProofStore implements ProofStore {
+  saveProofInput<T extends ProvingRequestType>(
+    _id: ProvingJobId,
+    type: T,
+    inputs: ProvingJobInputsMap[T],
+  ): Promise<ProofUri> {
+    const jobInputs = { type, inputs } as ProvingJobInputs;
+    return Promise.resolve(this.encode(jobInputs));
+  }
+
+  saveProofOutput<T extends ProvingRequestType>(
+    _id: ProvingJobId,
+    type: T,
+    result: ProvingJobResultsMap[T],
+  ): Promise<ProofUri> {
+    const jobResult = { type, result } as ProvingJobResult;
+    return Promise.resolve(this.encode(jobResult));
+  }
+
+  getProofInput(uri: ProofUri): Promise<ProvingJobInputs> {
+    return Promise.resolve(this.decode(uri, ProvingJobInputs));
+  }
+
+  getProofOutput(uri: ProofUri): Promise<ProvingJobResult> {
+    return Promise.resolve(this.decode(uri, ProvingJobResult));
+  }
+
+  private encode(obj: object): ProofUri {
+    const encoded = encodeURIComponent(jsonStringify(obj));
+    return (PREFIX + SEPARATOR + encoded) as ProofUri;
+  }
+
+  private decode<T>(uri: ProofUri, schema: ZodFor<T>): Promise<T> {
+    const [prefix, data] = uri.split(SEPARATOR);
+    if (prefix !== PREFIX) {
+      throw new Error('Invalid proof input URI: ' + prefix);
+    }
+
+    return jsonParseWithSchema(decodeURIComponent(data), schema);
+  }
+}

package/src/proving_broker/proof_store/proof_store.ts

@@ -0,0 +1,54 @@
+import type {
+  ProofUri,
+  ProvingJobId,
+  ProvingJobInputs,
+  ProvingJobInputsMap,
+  ProvingJobResult,
+  ProvingJobResultsMap,
+} from '@aztec/stdlib/interfaces/server';
+import type { ProvingRequestType } from '@aztec/stdlib/proofs';
+
+/**
+ * A database for storing proof inputs and outputs.
+ */
+export interface ProofStore {
+  /**
+   * Save a proof input to the database.
+   * @param jobId - The ID of the job the proof input is associated with.
+   * @param type - The type of the proving request.
+   * @param inputs - The proof input to save.
+   * @returns The URI of the saved proof input.
+   */
+  saveProofInput<T extends ProvingRequestType>(
+    jobId: ProvingJobId,
+    type: T,
+    inputs: ProvingJobInputsMap[T],
+  ): Promise<ProofUri>;
+
+  /**
+   * Save a proof output to the database.
+   * @param jobId - The ID of the job the proof input is associated with.
+   * @param type - The type of the proving request.
+   * @param result - The proof output to save.
+   * @returns The URI of the saved proof output.
+   */
+  saveProofOutput<T extends ProvingRequestType>(
+    id: ProvingJobId,
+    type: T,
+    result: ProvingJobResultsMap[T],
+  ): Promise<ProofUri>;
+
+  /**
+   * Retrieve a proof input from the database.
+   * @param uri - The URI of the proof input to retrieve.
+   * @returns The proof input.
+   */
+  getProofInput(uri: ProofUri): Promise<ProvingJobInputs>;
+
+  /**
+   * Retrieve a proof output from the database.
+   * @param uri - The URI of the proof output to retrieve.
+   * @returns The proof output.
+   */
+  getProofOutput(uri: ProofUri): Promise<ProvingJobResult>;
+}

package/src/proving_broker/proving_agent.ts

@@ -0,0 +1,181 @@
+import { createLogger } from '@aztec/foundation/log';
+import { RunningPromise } from '@aztec/foundation/running-promise';
+import { truncate } from '@aztec/foundation/string';
+import { Timer } from '@aztec/foundation/timer';
+import { ProvingError } from '@aztec/stdlib/errors';
+import type {
+  ProvingJob,
+  ProvingJobConsumer,
+  ProvingJobId,
+  ProvingJobInputs,
+  ProvingJobResultsMap,
+  ServerCircuitProver,
+} from '@aztec/stdlib/interfaces/server';
+import { ProvingRequestType } from '@aztec/stdlib/proofs';
+import {
+  type TelemetryClient,
+  type Traceable,
+  type Tracer,
+  getTelemetryClient,
+  trackSpan,
+} from '@aztec/telemetry-client';
+
+import type { ProofStore } from './proof_store/index.js';
+import { ProvingAgentInstrumentation } from './proving_agent_instrumentation.js';
+import { ProvingJobController, ProvingJobControllerStatus } from './proving_job_controller.js';
+
+/**
+ * A helper class that encapsulates a circuit prover and connects it to a job source.
+ */
+export class ProvingAgent implements Traceable {
+  private currentJobController?: ProvingJobController;
+  private runningPromise: RunningPromise;
+  private instrumentation: ProvingAgentInstrumentation;
+  private idleTimer: Timer | undefined;
+
+  public readonly tracer: Tracer;
+
+  constructor(
+    /** The source of proving jobs */
+    private broker: ProvingJobConsumer,
+    /** Database holding proof inputs and outputs */
+    private proofStore: ProofStore,
+    /** The prover implementation to defer jobs to */
+    private circuitProver: ServerCircuitProver,
+    /** Optional list of allowed proof types to build */
+    private proofAllowList: Array<ProvingRequestType> = [],
+    /** How long to wait between jobs */
+    private pollIntervalMs = 1000,
+    /** A telemetry client through which to emit metrics */
+    client: TelemetryClient = getTelemetryClient(),
+    private log = createLogger('prover-client:proving-agent'),
+  ) {
+    this.tracer = client.getTracer('ProvingAgent');
+    this.instrumentation = new ProvingAgentInstrumentation(client);
+    this.runningPromise = new RunningPromise(this.work.bind(this), this.log, this.pollIntervalMs);
+  }
+
+  public setCircuitProver(circuitProver: ServerCircuitProver): void {
+    this.circuitProver = circuitProver;
+  }
+
+  public isRunning(): boolean {
+    return this.runningPromise?.isRunning() ?? false;
+  }
+
+  public start(): void {
+    this.idleTimer = new Timer();
+    this.runningPromise.start();
+  }
+
+  public async stop(): Promise<void> {
+    this.currentJobController?.abort();
+    await this.runningPromise.stop();
+  }
+
+  @trackSpan('ProvingAgent.safeWork')
+  private async work() {
+    // every tick we need to
+    // (1) either do a heartbeat, telling the broker that we're working
+    // (2) get a new job
+    // If during (1) the broker returns a new job that means we can cancel the current job and start the new one
+    let maybeJob: { job: ProvingJob; time: number } | undefined;
+    if (this.currentJobController?.getStatus() === ProvingJobControllerStatus.PROVING) {
+      maybeJob = await this.broker.reportProvingJobProgress(
+        this.currentJobController.getJobId(),
+        this.currentJobController.getStartedAt(),
+        { allowList: this.proofAllowList },
+      );
+    } else {
+      maybeJob = await this.broker.getProvingJob({ allowList: this.proofAllowList });
+    }
+
+    if (!maybeJob) {
+      return;
+    }
+
+    if (this.idleTimer) {
+      this.instrumentation.recordIdleTime(this.idleTimer);
+    }
+    this.idleTimer = undefined;
+
+    const { job, time } = maybeJob;
+    await this.startJob(job, time);
+  }
+
+  private async startJob(job: ProvingJob, startedAt: number): Promise<void> {
+    let abortedProofJobId: string | undefined;
+    let abortedProofName: string | undefined;
+
+    if (this.currentJobController?.getStatus() === ProvingJobControllerStatus.PROVING) {
+      abortedProofJobId = this.currentJobController.getJobId();
+      abortedProofName = this.currentJobController.getProofTypeName();
+      this.currentJobController?.abort();
+    }
+
+    let inputs: ProvingJobInputs;
+    try {
+      inputs = await this.proofStore.getProofInput(job.inputsUri);
+    } catch (err) {
+      const maybeJob = await this.broker.reportProvingJobError(job.id, 'Failed to load proof inputs', true, {
+        allowList: this.proofAllowList,
+      });
+
+      if (maybeJob) {
+        return this.startJob(maybeJob.job, maybeJob.time);
+      }
+
+      return;
+    }
+
+    this.currentJobController = new ProvingJobController(
+      job.id,
+      inputs,
+      job.epochNumber,
+      startedAt,
+      this.circuitProver,
+      this.handleJobResult,
+    );
+
+    if (abortedProofJobId) {
+      this.log.info(
+        `Aborting job id=${abortedProofJobId} type=${abortedProofName} to start new job id=${this.currentJobController.getJobId()} type=${this.currentJobController.getProofTypeName()} inputsUri=${truncate(
+          job.inputsUri,
+        )}`,
+      );
+    } else {
+      this.log.info(
+        `Starting job id=${this.currentJobController.getJobId()} type=${this.currentJobController.getProofTypeName()} inputsUri=${truncate(
+          job.inputsUri,
+        )}`,
+      );
+    }
+
+    this.currentJobController.start();
+  }
+
+  handleJobResult = async <T extends ProvingRequestType>(
+    jobId: ProvingJobId,
+    type: T,
+    err: Error | undefined,
+    result: ProvingJobResultsMap[T] | undefined,
+  ) => {
+    let maybeJob: { job: ProvingJob; time: number } | undefined;
+    if (err) {
+      const retry = err.name === ProvingError.NAME ? (err as ProvingError).retry : false;
+      this.log.error(`Job id=${jobId} type=${ProvingRequestType[type]} failed err=${err.message} retry=${retry}`, err);
+      maybeJob = await this.broker.reportProvingJobError(jobId, err.message, retry, { allowList: this.proofAllowList });
+    } else if (result) {
+      const outputUri = await this.proofStore.saveProofOutput(jobId, type, result);
+      this.log.info(`Job id=${jobId} type=${ProvingRequestType[type]} completed outputUri=${truncate(outputUri)}`);
+      maybeJob = await this.broker.reportProvingJobSuccess(jobId, outputUri, { allowList: this.proofAllowList });
+    }
+
+    if (maybeJob) {
+      const { job, time } = maybeJob;
+      await this.startJob(job, time);
+    } else {
+      this.idleTimer = new Timer();
+    }
+  };
+}

package/src/proving_broker/proving_agent_instrumentation.ts

@@ -0,0 +1,21 @@
+import type { Timer } from '@aztec/foundation/timer';
+import { type Histogram, Metrics, type TelemetryClient, ValueType } from '@aztec/telemetry-client';
+
+export class ProvingAgentInstrumentation {
+  private idleTime: Histogram;
+
+  constructor(client: TelemetryClient, name = 'ProvingAgent') {
+    const meter = client.getMeter(name);
+
+    this.idleTime = meter.createHistogram(Metrics.PROVING_AGENT_IDLE, {
+      description: 'Records how long an agent was idle',
+      unit: 's',
+      valueType: ValueType.DOUBLE,
+    });
+  }
+
+  recordIdleTime(msOrTimer: Timer | number) {
+    const duration = typeof msOrTimer === 'number' ? msOrTimer : msOrTimer.ms();
+    this.idleTime.record(duration / 1000);
+  }
+}