@aztec/sequencer-client 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/dest/sequencer/metrics.js

@@ -1,78 +1,106 @@
-import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
-import { sequencerStateToNumber } from './utils.js';
+import { Attributes, Metrics, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
+import { formatUnits } from 'viem';
+// TODO(palla/mbps): Review all metrics and add any missing ones per checkpoint
 export class SequencerMetrics {
+    rollup;
     tracer;
+    meter;
     blockCounter;
     blockBuildDuration;
     blockBuildManaPerSecond;
     stateTransitionBufferDuration;
-    currentBlockNumber;
-    currentBlockSize;
-    blockBuilderInsertions;
+    // these are gauges because for individual sequencers building a block is not something that happens often enough to warrant a histogram
     timeToCollectAttestations;
-    constructor(client, getState, name = 'Sequencer'){
-        const meter = client.getMeter(name);
+    allowanceToCollectAttestations;
+    requiredAttestions;
+    collectedAttestions;
+    rewards;
+    slots;
+    filledSlots;
+    blockProposalFailed;
+    blockProposalSuccess;
+    blockProposalPrecheckFailed;
+    checkpointSuccess;
+    slashingAttempts;
+    checkpointAttestationDelay;
+    // Fisherman fee analysis metrics
+    fishermanWouldBeIncluded;
+    fishermanTimeBeforeBlock;
+    fishermanPendingBlobTxCount;
+    fishermanIncludedBlobTxCount;
+    fishermanCalculatedPriorityFee;
+    fishermanPriorityFeeDelta;
+    fishermanEstimatedCost;
+    fishermanEstimatedOverpayment;
+    fishermanMinedBlobTxPriorityFee;
+    fishermanMinedBlobTxTotalCost;
+    lastSeenSlot;
+    constructor(client, rollup, name = 'Sequencer'){
+        this.rollup = rollup;
+        this.meter = client.getMeter(name);
         this.tracer = client.getTracer(name);
-        this.blockCounter = meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
-        this.blockBuildDuration = meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION, {
-            unit: 'ms',
-            description: 'Duration to build a block',
-            valueType: ValueType.INT
+        this.blockCounter = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_COUNT, {
+            [Attributes.STATUS]: [
+                'failed',
+                'built'
+            ]
         });
-        this.blockBuildManaPerSecond = meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND, {
-            unit: 'mana/s',
-            description: 'Mana per second when building a block',
-            valueType: ValueType.INT
+        this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION);
+        this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND);
+        this.stateTransitionBufferDuration = this.meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION);
+        this.checkpointAttestationDelay = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_ATTESTATION_DELAY);
+        this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS);
+        this.slots = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLOT_COUNT);
+        /**
+     * NOTE: we do not track missed slots as a separate metric. That would be difficult to determine
+     * Instead, use a computed metric, `slots - filledSlots` to get the number of slots a sequencer has missed.
+     */ this.filledSlots = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_FILLED_SLOT_COUNT);
+        this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION);
+        this.allowanceToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_TIME_ALLOWANCE);
+        this.requiredAttestions = this.meter.createGauge(Metrics.SEQUENCER_REQUIRED_ATTESTATIONS_COUNT);
+        this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT);
+        this.blockProposalFailed = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_PROPOSAL_FAILED_COUNT);
+        this.blockProposalSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_PROPOSAL_SUCCESS_COUNT);
+        this.checkpointSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
+        this.blockProposalPrecheckFailed = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_PROPOSAL_PRECHECK_FAILED_COUNT, {
+            [Attributes.ERROR_TYPE]: [
+                'slot_already_taken',
+                'rollup_contract_check_failed',
+                'slot_mismatch',
+                'block_number_mismatch'
+            ]
         });
-        this.stateTransitionBufferDuration = meter.createHistogram(Metrics.SEQUENCER_STATE_TRANSITION_BUFFER_DURATION, {
-            unit: 'ms',
-            description: 'The time difference between when the sequencer needed to transition to a new state and when it actually did.',
-            valueType: ValueType.INT
+        this.slashingAttempts = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
+        // Fisherman fee analysis metrics
+        this.fishermanWouldBeIncluded = createUpDownCounterWithDefault(this.meter, Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED, {
+            [Attributes.OK]: [
+                true,
+                false
+            ]
         });
-        const currentState = meter.createObservableGauge(Metrics.SEQUENCER_CURRENT_STATE, {
-            description: 'Current state of the sequencer'
-        });
-        currentState.addCallback((observer)=>{
-            observer.observe(sequencerStateToNumber(getState()));
-        });
-        this.currentBlockNumber = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_NUMBER, {
-            description: 'Current block number',
-            valueType: ValueType.INT
-        });
-        this.currentBlockSize = meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_SIZE, {
-            description: 'Current block size',
-            valueType: ValueType.INT
-        });
-        this.timeToCollectAttestations = meter.createGauge(Metrics.SEQUENCER_TIME_TO_COLLECT_ATTESTATIONS, {
-            description: 'The time spent collecting attestations from committee members',
-            valueType: ValueType.INT
-        });
-        this.blockBuilderInsertions = meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_INSERTION_TIME, {
-            description: 'Timer for tree insertions performed by the block builder',
-            unit: 'us',
-            valueType: ValueType.INT
-        });
-        this.setCurrentBlock(0, 0);
+        this.fishermanTimeBeforeBlock = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_TIME_BEFORE_BLOCK);
+        this.fishermanPendingBlobTxCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PENDING_BLOB_TX_COUNT);
+        this.fishermanIncludedBlobTxCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_INCLUDED_BLOB_TX_COUNT);
+        this.fishermanCalculatedPriorityFee = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_CALCULATED_PRIORITY_FEE);
+        this.fishermanPriorityFeeDelta = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PRIORITY_FEE_DELTA);
+        this.fishermanEstimatedCost = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_COST);
+        this.fishermanEstimatedOverpayment = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_ESTIMATED_OVERPAYMENT);
+        this.fishermanMinedBlobTxPriorityFee = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_PRIORITY_FEE);
+        this.fishermanMinedBlobTxTotalCost = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_MINED_BLOB_TX_TOTAL_COST);
     }
-    startCollectingAttestationsTimer() {
-        const startTime = Date.now();
-        const stop = ()=>{
-            const duration = Date.now() - startTime;
-            this.recordTimeToCollectAttestations(duration);
-        };
-        return stop.bind(this);
+    recordRequiredAttestations(requiredAttestationsCount, allowanceMs) {
+        this.requiredAttestions.record(requiredAttestationsCount);
+        this.allowanceToCollectAttestations.record(Math.ceil(allowanceMs));
+        // reset
+        this.collectedAttestions.record(0);
+        this.timeToCollectAttestations.record(0);
     }
-    recordTimeToCollectAttestations(time) {
-        this.timeToCollectAttestations.record(time);
+    recordCheckpointAttestationDelay(duration) {
+        this.checkpointAttestationDelay.record(duration);
     }
-    recordBlockBuilderTreeInsertions(timeUs) {
-        this.blockBuilderInsertions.record(Math.ceil(timeUs));
-    }
-    recordCancelledBlock() {
-        this.blockCounter.add(1, {
-            [Attributes.STATUS]: 'cancelled'
-        });
-        this.setCurrentBlock(0, 0);
+    recordCollectedAttestations(count, durationMs) {
+        this.collectedAttestions.record(count);
+        this.timeToCollectAttestations.record(Math.ceil(durationMs));
     }
     recordBuiltBlock(buildDurationMs, totalMana) {
         this.blockCounter.add(1, {
@@ -85,18 +113,135 @@ export class SequencerMetrics {
         this.blockCounter.add(1, {
             [Attributes.STATUS]: 'failed'
         });
-        this.setCurrentBlock(0, 0);
-    }
-    recordNewBlock(blockNumber, txCount) {
-        this.setCurrentBlock(blockNumber, txCount);
     }
     recordStateTransitionBufferMs(durationMs, state) {
         this.stateTransitionBufferDuration.record(durationMs, {
             [Attributes.SEQUENCER_STATE]: state
         });
     }
-    setCurrentBlock(blockNumber, txCount) {
-        this.currentBlockNumber.record(blockNumber);
-        this.currentBlockSize.record(txCount);
+    incOpenSlot(slot, proposer) {
+        // sequencer went through the loop a second time. Noop
+        if (slot === this.lastSeenSlot) {
+            return;
+        }
+        this.slots.add(1, {
+            [Attributes.BLOCK_PROPOSER]: proposer
+        });
+        this.lastSeenSlot = slot;
+    }
+    async incFilledSlot(proposer, coinbase) {
+        this.filledSlots.add(1, {
+            [Attributes.BLOCK_PROPOSER]: proposer
+        });
+        this.lastSeenSlot = undefined;
+        if (coinbase) {
+            try {
+                const rewards = await this.rollup.getSequencerRewards(coinbase);
+                const fmt = parseFloat(formatUnits(rewards, 18));
+                this.rewards.record(fmt, {
+                    [Attributes.COINBASE]: coinbase.toString()
+                });
+            } catch  {
+            // no-op
+            }
+        }
+    }
+    recordCheckpointSuccess() {
+        this.checkpointSuccess.add(1);
+    }
+    recordBlockProposalFailed(reason) {
+        this.blockProposalFailed.add(1, {
+            ...reason && {
+                [Attributes.ERROR_TYPE]: reason
+            }
+        });
+    }
+    recordBlockProposalSuccess() {
+        this.blockProposalSuccess.add(1);
+    }
+    recordBlockProposalPrecheckFailed(checkType) {
+        this.blockProposalPrecheckFailed.add(1, {
+            [Attributes.ERROR_TYPE]: checkType
+        });
+    }
+    recordSlashingAttempt(actionCount) {
+        this.slashingAttempts.add(actionCount);
+    }
+    /**
+   * Records metrics for a completed fisherman fee analysis
+   * @param analysis - The completed fee analysis result
+   */ recordFishermanFeeAnalysis(analysis) {
+        // In fisherman mode, we should always have strategy results
+        if (!analysis.computedPrices.strategyResults || analysis.computedPrices.strategyResults.length === 0) {
+            // This should never happen in fisherman mode - log an error
+            // We don't record metrics without strategy IDs as that defeats the purpose
+            throw new Error(`No strategy results found in fisherman fee analysis ${analysis.id}. This indicates a bug in the fee analysis.`);
+        }
+        // Record metrics for each strategy separately
+        for (const strategyResult of analysis.computedPrices.strategyResults){
+            const strategyAttributes = {
+                [Attributes.FISHERMAN_FEE_STRATEGY_ID]: strategyResult.strategyId
+            };
+            // Record pending block snapshot data (once per strategy for comparison)
+            this.fishermanPendingBlobTxCount.record(analysis.pendingSnapshot.pendingBlobTxCount, strategyAttributes);
+            // Record mined block data if available
+            if (analysis.minedBlock) {
+                this.fishermanIncludedBlobTxCount.record(analysis.minedBlock.includedBlobTxCount, strategyAttributes);
+                // Record actual fees from blob transactions in the mined block
+                for (const blobTx of analysis.minedBlock.includedBlobTxs){
+                    // Record priority fee per gas in Gwei
+                    const priorityFeeGwei = Number(blobTx.maxPriorityFeePerGas) / 1e9;
+                    this.fishermanMinedBlobTxPriorityFee.record(priorityFeeGwei, strategyAttributes);
+                    // Calculate total cost in ETH
+                    // Cost = (gas * (baseFee + priorityFee)) + (blobCount * blobGasPerBlob * blobBaseFee)
+                    const baseFee = analysis.minedBlock.baseFeePerGas;
+                    const effectiveGasPrice = baseFee + blobTx.maxPriorityFeePerGas;
+                    // Calculate execution cost using actual gas limit from the transaction
+                    const executionCost = blobTx.gas * effectiveGasPrice;
+                    // Calculate blob cost using maxFeePerBlobGas * blobCount * GAS_PER_BLOB
+                    const blobCost = blobTx.maxFeePerBlobGas * BigInt(blobTx.blobCount) * 131072n; // 128KB per blob
+                    const totalCostWei = executionCost + blobCost;
+                    const totalCostEth = Number(totalCostWei) / 1e18;
+                    this.fishermanMinedBlobTxTotalCost.record(totalCostEth, strategyAttributes);
+                }
+            }
+            // Record the calculated priority fee for this strategy
+            const calculatedPriorityFeeGwei = Number(strategyResult.calculatedPriorityFee) / 1e9;
+            this.fishermanCalculatedPriorityFee.record(calculatedPriorityFeeGwei, strategyAttributes);
+            // Record analysis results if available
+            if (analysis.analysis) {
+                this.fishermanTimeBeforeBlock.record(Math.ceil(analysis.analysis.timeBeforeBlockMs), strategyAttributes);
+                // Record strategy-specific inclusion result
+                if (strategyResult.wouldBeIncluded !== undefined) {
+                    if (strategyResult.wouldBeIncluded) {
+                        this.fishermanWouldBeIncluded.add(1, {
+                            ...strategyAttributes,
+                            [Attributes.OK]: true
+                        });
+                    } else {
+                        this.fishermanWouldBeIncluded.add(1, {
+                            ...strategyAttributes,
+                            [Attributes.OK]: false,
+                            ...strategyResult.exclusionReason && {
+                                [Attributes.ERROR_TYPE]: strategyResult.exclusionReason
+                            }
+                        });
+                    }
+                }
+                // Record strategy-specific priority fee delta
+                if (strategyResult.priorityFeeDelta !== undefined) {
+                    const priorityFeeDeltaGwei = Number(strategyResult.priorityFeeDelta) / 1e9;
+                    this.fishermanPriorityFeeDelta.record(priorityFeeDeltaGwei, strategyAttributes);
+                }
+                // Record estimated cost if available
+                if (strategyResult.estimatedCostEth !== undefined) {
+                    this.fishermanEstimatedCost.record(strategyResult.estimatedCostEth, strategyAttributes);
+                }
+                // Record estimated overpayment if available
+                if (strategyResult.estimatedOverpaymentEth !== undefined) {
+                    this.fishermanEstimatedOverpayment.record(strategyResult.estimatedOverpaymentEth, strategyAttributes);
+                }
+            }
+        }
     }
 }