@lodestar/beacon-node 1.30.0 → 1.31.0-dev.065cb80811

package/lib/metrics/metrics/lodestar.d.ts

@@ -1,7 +1,8 @@
+import { BlockInputSource } from "../../chain/blocks/blockInput/index.js";
 import { BlobsSource, BlockSource } from "../../chain/blocks/types.js";
 import { JobQueueItemType } from "../../chain/bls/index.js";
 import { AttestationErrorCode, BlockErrorCode } from "../../chain/errors/index.js";
-import { ScannedSlotsTerminationReason } from "../../chain/opPools/aggregatedAttestationPool.js";
+import { type InvalidAttestationData, ScannedSlotsTerminationReason } from "../../chain/opPools/aggregatedAttestationPool.js";
 import { InsertOutcome } from "../../chain/opPools/types.js";
 import { RegenCaller, RegenFnName } from "../../chain/regen/interface.js";
 import { ReprocessStatus } from "../../chain/reprocess.js";
@@ -236,7 +237,9 @@ export declare function createLodestarMetrics(register: RegistryMetricCreator, m
         attestationNonBatchCount: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
     };
     gossipBlock: {
-        elapsedTimeTillReceived: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
+        elapsedTimeTillReceived: import("@lodestar/utils").Histogram<{
+            source: OpSource;
+        }>;
         elapsedTimeTillProcessed: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
         gossipValidation: {
             recvToValidation: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
@@ -342,7 +345,9 @@ export declare function createLodestarMetrics(register: RegistryMetricCreator, m
                 poolSlots: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
                 totalConsolidations: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
                 emptyAttestationData: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-                invalidAttestationData: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+                invalidAttestationData: import("@lodestar/utils").GaugeExtra<{
+                    reason: InvalidAttestationData;
+                }>;
                 seenCommittees: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
             };
         };
@@ -364,77 +369,30 @@ export declare function createLodestarMetrics(register: RegistryMetricCreator, m
         syncCommitteeMessagePoolInsertOutcome: import("@lodestar/utils").Counter<{
             insertOutcome: InsertOutcome;
         }>;
-        syncContributionAndProofPoolSize: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+        syncContributionAndProofPool: {
+            size: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+            gossipInsertOutcome: import("@lodestar/utils").Counter<{
+                insertOutcome: InsertOutcome;
+            }>;
+            apiInsertOutcome: import("@lodestar/utils").Counter<{
+                insertOutcome: InsertOutcome;
+            }>;
+            blockRootsPerSlot: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+            subnetsByBlockRoot: import("@lodestar/utils").GaugeExtra<{
+                index: number;
+            }>;
+            participantsByBlockRoot: import("@lodestar/utils").GaugeExtra<{
+                index: number;
+            }>;
+            getAggregateRoots: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+            getAggregateSubnets: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+            getAggregateParticipants: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+            getAggregateReturnsEmpty: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+        };
     };
     chain: {
         blacklistedBlocks: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
     };
-    validatorMonitor: {
-        validatorsConnected: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        validatorsInSyncCommittee: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochOnChainBalance: import("@lodestar/utils").GaugeExtra<{
-            index: number;
-        }>;
-        prevEpochOnChainAttesterHit: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochOnChainAttesterMiss: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochOnChainSourceAttesterHit: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochOnChainSourceAttesterMiss: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochOnChainHeadAttesterHit: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochOnChainHeadAttesterMiss: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevOnChainAttesterCorrectHead: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevOnChainAttesterIncorrectHead: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochOnChainTargetAttesterHit: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochOnChainTargetAttesterMiss: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochOnChainInclusionDistance: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochAttestations: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochAttestationsMinDelaySeconds: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochAttestationAggregateInclusions: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochAttestationBlockInclusions: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochAttestationBlockMinInclusionDistance: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochBeaconBlocks: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochBeaconBlocksMinDelaySeconds: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochAggregatesTotal: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochAggregatesMinDelaySeconds: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochSyncCommitteeHits: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochSyncCommitteeMisses: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        prevEpochSyncSignatureAggregateInclusions: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        prevEpochAttestationSummary: import("@lodestar/utils").GaugeExtra<{
-            summary: string;
-        }>;
-        prevEpochBlockProposalSummary: import("@lodestar/utils").GaugeExtra<{
-            summary: string;
-        }>;
-        unaggregatedAttestationTotal: import("@lodestar/utils").GaugeExtra<{
-            src: OpSource;
-        }>;
-        unaggregatedAttestationDelaySeconds: import("@lodestar/utils").Histogram<{
-            src: OpSource;
-        }>;
-        unaggregatedAttestationSubmittedSentPeers: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        aggregatedAttestationTotal: import("@lodestar/utils").GaugeExtra<{
-            src: OpSource;
-        }>;
-        aggregatedAttestationDelaySeconds: import("@lodestar/utils").Histogram<{
-            src: OpSource;
-        }>;
-        attestationInAggregateTotal: import("@lodestar/utils").GaugeExtra<{
-            src: OpSource;
-        }>;
-        attestationInAggregateDelaySeconds: import("@lodestar/utils").Histogram<{
-            src: OpSource;
-        }>;
-        attestationInBlockTotal: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        attestationInBlockDelaySlots: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        attestationInBlockParticipants: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-        syncSignatureInAggregateTotal: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
-        beaconBlockTotal: import("@lodestar/utils").GaugeExtra<{
-            src: OpSource;
-        }>;
-        beaconBlockDelaySeconds: import("@lodestar/utils").Histogram<{
-            src: OpSource;
-        }>;
-        proposerBalanceDeltaKnown: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
-    };
     proposerBalanceDeltaAny: import("@lodestar/utils").Histogram<import("@lodestar/utils").NoLabels>;
     stateCache: {
         lookups: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
@@ -521,6 +479,17 @@ export declare function createLodestarMetrics(register: RegistryMetricCreator, m
                 reason: RejectReason;
             }>;
         };
+        blockInput: {
+            blockInputCount: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+            duplicateBlockCount: import("@lodestar/utils").GaugeExtra<{
+                source: BlockInputSource;
+            }>;
+            duplicateBlobCount: import("@lodestar/utils").GaugeExtra<{
+                source: BlockInputSource;
+            }>;
+            createdByBlock: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+            createdByBlob: import("@lodestar/utils").GaugeExtra<import("@lodestar/utils").NoLabels>;
+        };
     };
     regenFnCallTotal: import("@lodestar/utils").GaugeExtra<{
         entrypoint: RegenFnName;

package/lib/metrics/metrics/lodestar.js

@@ -556,6 +556,7 @@ export function createLodestarMetrics(register, metadata, genesisTime) {
             elapsedTimeTillReceived: register.histogram({
                 name: "lodestar_gossip_block_elapsed_time_till_received",
                 help: "Time elapsed between block slot time and the time block received via gossip",
+                labelNames: ["source"],
                 buckets: [0.5, 1, 2, 4, 6, 12],
             }),
             elapsedTimeTillProcessed: register.histogram({
@@ -814,6 +815,7 @@ export function createLodestarMetrics(register, metadata, genesisTime) {
                     invalidAttestationData: register.gauge({
                         name: "lodestar_oppool_aggregated_attestation_pool_packed_attestations_invalid_attestation_data_total",
                         help: "Total number of invalid attestation data when producing packed attestation",
+                        labelNames: ["reason"],
                     }),
                     seenCommittees: register.gauge({
                         name: "lodestar_oppool_aggregated_attestation_pool_packed_attestations_seen_committees_total",
@@ -866,10 +868,52 @@ export function createLodestarMetrics(register, metadata, genesisTime) {
                 help: "Total number of InsertOutcome as a result of adding a SyncCommitteeMessage to pool",
                 labelNames: ["insertOutcome"],
             }),
-            syncContributionAndProofPoolSize: register.gauge({
-                name: "lodestar_oppool_sync_contribution_and_proof_pool_pool_size",
-                help: "Current size of the SyncContributionAndProofPool unique by slot subnet and block root",
-            }),
+            syncContributionAndProofPool: {
+                size: register.gauge({
+                    name: "lodestar_oppool_sync_contribution_and_proof_pool_size",
+                    help: "Current size of the SyncContributionAndProofPool unique by slot subnet and block root",
+                }),
+                gossipInsertOutcome: register.counter({
+                    name: "lodestar_oppool_sync_contribution_and_proof_pool_gossip_insert_outcome_total",
+                    help: "Total number of InsertOutcome as a result of adding a ContributionAndProof from gossip into the pool",
+                    labelNames: ["insertOutcome"],
+                }),
+                apiInsertOutcome: register.counter({
+                    name: "lodestar_oppool_sync_contribution_and_proof_pool_api_insert_outcome_total",
+                    help: "Total number of InsertOutcome as a result of adding a ContributionAndProof from api into the pool",
+                    labelNames: ["insertOutcome"],
+                }),
+                blockRootsPerSlot: register.gauge({
+                    name: "lodestar_oppool_sync_contribution_and_proof_pool_block_roots_per_slot_total",
+                    help: "Total number of block roots per slot in SyncContributionAndProofPool",
+                }),
+                subnetsByBlockRoot: register.gauge({
+                    name: "lodestar_oppool_sync_contribution_and_proof_pool_subnets_by_block_root_total",
+                    help: "Total number of subnets per block root in SyncContributionAndProofPool",
+                    labelNames: ["index"],
+                }),
+                participantsByBlockRoot: register.gauge({
+                    name: "lodestar_oppool_sync_contribution_and_proof_pool_participants_by_block_root_total",
+                    help: "Total number of participants per block root in SyncContributionAndProofPool",
+                    labelNames: ["index"],
+                }),
+                getAggregateRoots: register.gauge({
+                    name: "lodestar_oppool_sync_contribution_and_proof_pool_get_aggregate_roots_total",
+                    help: "Total number of block roots in SyncContributionAndProofPool.getAggregate(slot)",
+                }),
+                getAggregateSubnets: register.gauge({
+                    name: "lodestar_oppool_sync_contribution_and_proof_pool_get_aggregate_subnets_total",
+                    help: "Total number of subnets in SyncContributionAndProofPool.getAggregate(slot, root)",
+                }),
+                getAggregateParticipants: register.gauge({
+                    name: "lodestar_oppool_sync_contribution_and_proof_pool_get_aggregate_participants_total",
+                    help: "Total number of participants in SyncContributionAndProofPool.getAggregate(slot, root)",
+                }),
+                getAggregateReturnsEmpty: register.gauge({
+                    name: "lodestar_oppool_sync_contribution_and_proof_pool_get_aggregate_returns_empty_total",
+                    help: "Total number of empty returns in SyncContributionAndProofPool.getAggregate(slot, root)",
+                }),
+            },
         },
         chain: {
             blacklistedBlocks: register.gauge({
@@ -877,217 +921,6 @@ export function createLodestarMetrics(register, metadata, genesisTime) {
                 help: "Total number of blacklisted blocks",
             }),
         },
-        // Validator monitoring
-        validatorMonitor: {
-            validatorsConnected: register.gauge({
-                name: "validator_monitor_validators",
-                help: "Count of validators that are specifically monitored by this beacon node",
-            }),
-            validatorsInSyncCommittee: register.gauge({
-                name: "validator_monitor_validators_in_sync_committee",
-                help: "Count of validators monitored by this beacon node that are part of sync committee",
-            }),
-            // Validator Monitor Metrics (per-epoch summaries)
-            // Only track prevEpochOnChainBalance per index
-            prevEpochOnChainBalance: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_balance",
-                help: "Balance of validator after an epoch",
-                labelNames: ["index"],
-            }),
-            prevEpochOnChainAttesterHit: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_attester_hit_total",
-                help: "Incremented if validator's submitted attestation is included in some blocks",
-            }),
-            prevEpochOnChainAttesterMiss: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_attester_miss_total",
-                help: "Incremented if validator's submitted attestation is not included in any blocks",
-            }),
-            prevEpochOnChainSourceAttesterHit: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_source_attester_hit_total",
-                help: "Incremented if the validator is flagged as a previous epoch source attester during per epoch processing",
-            }),
-            prevEpochOnChainSourceAttesterMiss: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_source_attester_miss_total",
-                help: "Incremented if the validator is not flagged as a previous epoch source attester during per epoch processing",
-            }),
-            prevEpochOnChainHeadAttesterHit: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_head_attester_hit_total",
-                help: "Incremented if the validator is flagged as a previous epoch head attester during per epoch processing",
-            }),
-            prevEpochOnChainHeadAttesterMiss: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_head_attester_miss_total",
-                help: "Incremented if the validator is not flagged as a previous epoch head attester during per epoch processing",
-            }),
-            prevOnChainAttesterCorrectHead: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_attester_correct_head_total",
-                help: "Total count of times a validator votes correct head",
-            }),
-            prevOnChainAttesterIncorrectHead: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_attester_incorrect_head_total",
-                help: "Total count of times a validator votes incorrect head",
-            }),
-            prevEpochOnChainTargetAttesterHit: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_target_attester_hit_total",
-                help: "Incremented if the validator is flagged as a previous epoch target attester during per epoch processing",
-            }),
-            prevEpochOnChainTargetAttesterMiss: register.gauge({
-                name: "validator_monitor_prev_epoch_on_chain_target_attester_miss_total",
-                help: "Incremented if the validator is not flagged as a previous epoch target attester during per epoch processing",
-            }),
-            prevEpochOnChainInclusionDistance: register.histogram({
-                name: "validator_monitor_prev_epoch_on_chain_inclusion_distance",
-                help: "The attestation inclusion distance calculated during per epoch processing",
-                // min inclusion distance is 1, usual values are 1,2,3 max is 32 (1 epoch)
-                buckets: [1, 2, 3, 5, 10, 32],
-            }),
-            prevEpochAttestations: register.histogram({
-                name: "validator_monitor_prev_epoch_attestations",
-                help: "The number of unagg. attestations seen in the previous epoch",
-                buckets: [0, 1, 2, 3],
-            }),
-            prevEpochAttestationsMinDelaySeconds: register.histogram({
-                name: "validator_monitor_prev_epoch_attestations_min_delay_seconds",
-                help: "The min delay between when the validator should send the attestation and when it was received",
-                buckets: [0.1, 0.25, 0.5, 1, 2, 5, 10],
-            }),
-            prevEpochAttestationAggregateInclusions: register.histogram({
-                name: "validator_monitor_prev_epoch_attestation_aggregate_inclusions",
-                help: "The count of times an attestation was seen inside an aggregate",
-                buckets: [0, 1, 2, 3, 5, 10],
-            }),
-            prevEpochAttestationBlockInclusions: register.histogram({
-                name: "validator_monitor_prev_epoch_attestation_block_inclusions",
-                help: "The count of times an attestation was seen inside a block",
-                buckets: [0, 1, 2, 3, 5],
-            }),
-            prevEpochAttestationBlockMinInclusionDistance: register.histogram({
-                name: "validator_monitor_prev_epoch_attestation_block_min_inclusion_distance",
-                help: "The minimum inclusion distance observed for the inclusion of an attestation in a block",
-                buckets: [1, 2, 3, 5, 10, 32],
-            }),
-            prevEpochBeaconBlocks: register.histogram({
-                name: "validator_monitor_prev_epoch_beacon_blocks",
-                help: "The number of beacon_blocks seen in the previous epoch",
-                buckets: [0, 1, 2, 3, 5, 10],
-            }),
-            prevEpochBeaconBlocksMinDelaySeconds: register.histogram({
-                name: "validator_monitor_prev_epoch_beacon_blocks_min_delay_seconds",
-                help: "The min delay between when the validator should send the block and when it was received",
-                buckets: [0.1, 0.25, 0.5, 1, 2, 5, 10],
-            }),
-            prevEpochAggregatesTotal: register.histogram({
-                name: "validator_monitor_prev_epoch_aggregates",
-                help: "The number of aggregates seen in the previous epoch",
-                buckets: [0, 1, 2, 3, 5, 10],
-            }),
-            prevEpochAggregatesMinDelaySeconds: register.histogram({
-                name: "validator_monitor_prev_epoch_aggregates_min_delay_seconds",
-                help: "The min delay between when the validator should send the aggregate and when it was received",
-                buckets: [0.1, 0.25, 0.5, 1, 2, 5, 10],
-            }),
-            prevEpochSyncCommitteeHits: register.gauge({
-                name: "validator_monitor_prev_epoch_sync_committee_hits",
-                help: "Count of times in prev epoch connected validators participated in imported block's syncAggregate",
-            }),
-            prevEpochSyncCommitteeMisses: register.gauge({
-                name: "validator_monitor_prev_epoch_sync_committee_misses",
-                help: "Count of times in prev epoch connected validators fail to participate in imported block's syncAggregate",
-            }),
-            prevEpochSyncSignatureAggregateInclusions: register.histogram({
-                name: "validator_monitor_prev_epoch_sync_signature_aggregate_inclusions",
-                help: "The count of times a sync signature was seen inside an aggregate",
-                buckets: [0, 1, 2, 3, 5, 10],
-            }),
-            prevEpochAttestationSummary: register.gauge({
-                name: "validator_monitor_prev_epoch_attestation_summary",
-                help: "Best guess of the node of the result of previous epoch validators attestation actions and causality",
-                labelNames: ["summary"],
-            }),
-            prevEpochBlockProposalSummary: register.gauge({
-                name: "validator_monitor_prev_epoch_block_proposal_summary",
-                help: "Best guess of the node of the result of previous epoch validators block proposal actions and causality",
-                labelNames: ["summary"],
-            }),
-            // Validator Monitor Metrics (real-time)
-            unaggregatedAttestationTotal: register.gauge({
-                name: "validator_monitor_unaggregated_attestation_total",
-                help: "Number of unaggregated attestations seen",
-                labelNames: ["src"],
-            }),
-            unaggregatedAttestationDelaySeconds: register.histogram({
-                name: "validator_monitor_unaggregated_attestation_delay_seconds",
-                help: "The delay between when the validator should send the attestation and when it was received",
-                labelNames: ["src"],
-                buckets: [0.1, 0.25, 0.5, 1, 2, 5, 10],
-            }),
-            unaggregatedAttestationSubmittedSentPeers: register.histogram({
-                name: "validator_monitor_unaggregated_attestation_submitted_sent_peers_count",
-                help: "Number of peers that an unaggregated attestation sent to",
-                // as of Apr 2022, most of the time we sent to >30 peers per attestations
-                // these bucket values just base on that fact to get equal range
-                // refine if we want more reasonable values
-                buckets: [0, 10, 20, 30],
-            }),
-            aggregatedAttestationTotal: register.gauge({
-                name: "validator_monitor_aggregated_attestation_total",
-                help: "Number of aggregated attestations seen",
-                labelNames: ["src"],
-            }),
-            aggregatedAttestationDelaySeconds: register.histogram({
-                name: "validator_monitor_aggregated_attestation_delay_seconds",
-                help: "The delay between then the validator should send the aggregate and when it was received",
-                labelNames: ["src"],
-                buckets: [0.1, 0.25, 0.5, 1, 2, 5, 10],
-            }),
-            attestationInAggregateTotal: register.gauge({
-                name: "validator_monitor_attestation_in_aggregate_total",
-                help: "Number of times an attestation has been seen in an aggregate",
-                labelNames: ["src"],
-            }),
-            attestationInAggregateDelaySeconds: register.histogram({
-                name: "validator_monitor_attestation_in_aggregate_delay_seconds",
-                help: "The delay between when the validator should send the aggregate and when it was received",
-                labelNames: ["src"],
-                buckets: [0.1, 0.25, 0.5, 1, 2, 5, 10],
-            }),
-            attestationInBlockTotal: register.gauge({
-                name: "validator_monitor_attestation_in_block_total",
-                help: "Number of times an attestation has been seen in a block",
-            }),
-            attestationInBlockDelaySlots: register.histogram({
-                name: "validator_monitor_attestation_in_block_delay_slots",
-                help: "The excess slots (beyond the minimum delay) between the attestation slot and the block slot",
-                buckets: [0.1, 0.25, 0.5, 1, 2, 5, 10],
-            }),
-            attestationInBlockParticipants: register.histogram({
-                name: "validator_monitor_attestation_in_block_participants",
-                help: "The total participants in attestations of monitored validators included in blocks",
-                buckets: [1, 5, 20, 50, 100, 200],
-            }),
-            syncSignatureInAggregateTotal: register.gauge({
-                name: "validator_monitor_sync_signature_in_aggregate_total",
-                help: "Number of times a sync signature has been seen in an aggregate",
-            }),
-            beaconBlockTotal: register.gauge({
-                name: "validator_monitor_beacon_block_total",
-                help: "Total number of beacon blocks seen",
-                labelNames: ["src"],
-            }),
-            beaconBlockDelaySeconds: register.histogram({
-                name: "validator_monitor_beacon_block_delay_seconds",
-                help: "The delay between when the validator should send the block and when it was received",
-                labelNames: ["src"],
-                // we also want other nodes to received our published before 4s so add bucket 3 and 3.5
-                buckets: [0.1, 0.25, 0.5, 1, 2, 3, 4, 6, 10],
-            }),
-            // Only for known
-            proposerBalanceDeltaKnown: register.histogram({
-                name: "validator_monitor_proposer_balance_delta_known_gwei",
-                help: "Balance delta of known block proposer after importing a valid block",
-                // Jul22 mainnet block reward is consistently between 29,000,000-28,000,000 GWei
-                buckets: [10_000, 100_000, 1e6, 10e6, 20e6, 50e6, 100e6, 1000e6],
-            }),
-        },
         proposerBalanceDeltaAny: register.histogram({
             name: "lodestar_proposer_balance_delta_any_gwei",
             help: "Balance delta of every block proposer after importing a valid block",
@@ -1347,6 +1180,30 @@ export function createLodestarMetrics(register, metadata, genesisTime) {
                     labelNames: ["reason"],
                 }),
             },
+            blockInput: {
+                blockInputCount: register.gauge({
+                    name: "lodestar_seen_block_input_cache_size",
+                    help: "Number of cached BlockInputs",
+                }),
+                duplicateBlockCount: register.gauge({
+                    name: "lodestar_seen_block_input_cache_duplicate_block_count",
+                    help: "Total number of duplicate blocks that pass validation and attempt to be cached but are known",
+                    labelNames: ["source"],
+                }),
+                duplicateBlobCount: register.gauge({
+                    name: "lodestar_seen_block_input_cache_duplicate_blob_count",
+                    help: "Total number of duplicate blobs that pass validation and attempt to be cached but are known",
+                    labelNames: ["source"],
+                }),
+                createdByBlock: register.gauge({
+                    name: "lodestar_seen_block_input_cache_items_created_by_block",
+                    help: "Number of BlockInputs created via a block being seen first",
+                }),
+                createdByBlob: register.gauge({
+                    name: "lodestar_seen_block_input_cache_items_created_by_blob",
+                    help: "Number of BlockInputs created via a blob being seen first",
+                }),
+            },
         },
         regenFnCallTotal: register.gauge({
             name: "lodestar_regen_fn_call_total",