@aztec/sequencer-client 0.0.1-commit.b655e406 → 0.0.1-commit.b6e433891

package/dest/sequencer/metrics.js

@@ -1,4 +1,4 @@
-import { Attributes, Metrics, ValueType } from '@aztec/telemetry-client';
+import { Attributes, Metrics, createUpDownCounterWithDefault } from '@aztec/telemetry-client';
 import { formatUnits } from 'viem';
 export class SequencerMetrics {
     rollup;
@@ -16,67 +16,108 @@ export class SequencerMetrics {
     rewards;
     slots;
     filledSlots;
+    blockProposalFailed;
+    checkpointProposalSuccess;
+    checkpointPrecheckFailed;
+    checkpointProposalFailed;
+    checkpointSuccess;
+    slashingAttempts;
+    checkpointAttestationDelay;
+    checkpointBuildDuration;
+    checkpointBlockCount;
+    checkpointTxCount;
+    checkpointTotalMana;
+    pipelineDepth;
+    pipelineDiscards;
+    // Fisherman fee analysis metrics
+    fishermanWouldBeIncluded;
+    fishermanTimeBeforeBlock;
+    fishermanPendingBlobTxCount;
+    fishermanIncludedBlobTxCount;
+    fishermanPendingBlobCount;
+    fishermanIncludedBlobCount;
+    fishermanBlockBlobsFull;
+    fishermanMaxBlobCapacity;
+    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 = this.meter.createUpDownCounter(Metrics.SEQUENCER_BLOCK_COUNT);
-        this.blockBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_BLOCK_BUILD_DURATION, {
-            unit: 'ms',
-            description: 'Duration to build a block',
-            valueType: ValueType.INT
-        });
-        this.blockBuildManaPerSecond = this.meter.createGauge(Metrics.SEQUENCER_BLOCK_BUILD_MANA_PER_SECOND, {
-            unit: 'mana/s',
-            description: 'Mana per second when building a block',
-            valueType: ValueType.INT
-        });
-        this.stateTransitionBufferDuration = this.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
-        });
-        // Init gauges and counters
-        this.blockCounter.add(0, {
-            [Attributes.STATUS]: 'failed'
-        });
-        this.blockCounter.add(0, {
-            [Attributes.STATUS]: 'built'
-        });
-        this.rewards = this.meter.createGauge(Metrics.SEQUENCER_CURRENT_BLOCK_REWARDS, {
-            valueType: ValueType.DOUBLE,
-            description: 'The rewards earned'
-        });
-        this.slots = this.meter.createUpDownCounter(Metrics.SEQUENCER_SLOT_COUNT, {
-            valueType: ValueType.INT,
-            description: 'The number of slots this sequencer was selected for'
+        this.blockCounter = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_BLOCK_COUNT, {
+            [Attributes.STATUS]: [
+                'failed',
+                'built'
+            ]
         });
+        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_SLOT_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 = this.meter.createUpDownCounter(Metrics.SEQUENCER_FILLED_SLOT_COUNT, {
-            valueType: ValueType.INT,
-            description: 'The number of slots this sequencer has filled'
+     */ 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.checkpointProposalSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_PROPOSAL_SUCCESS_COUNT);
+        this.checkpointSuccess = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_SUCCESS_COUNT);
+        this.checkpointPrecheckFailed = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_PRECHECK_FAILED_COUNT, {
+            [Attributes.ERROR_TYPE]: [
+                'slot_already_taken',
+                'rollup_contract_check_failed',
+                'slot_mismatch',
+                'block_number_mismatch'
+            ]
         });
-        this.timeToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_DURATION, {
-            description: 'The time spent collecting attestations from committee members',
-            unit: 'ms',
-            valueType: ValueType.INT
+        this.checkpointProposalFailed = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_CHECKPOINT_PROPOSAL_FAILED_COUNT);
+        this.checkpointBuildDuration = this.meter.createHistogram(Metrics.SEQUENCER_CHECKPOINT_BUILD_DURATION);
+        this.checkpointBlockCount = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_BLOCK_COUNT);
+        this.checkpointTxCount = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TX_COUNT);
+        this.checkpointTotalMana = this.meter.createGauge(Metrics.SEQUENCER_CHECKPOINT_TOTAL_MANA);
+        this.slashingAttempts = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_SLASHING_ATTEMPTS_COUNT);
+        this.pipelineDepth = this.meter.createGauge(Metrics.SEQUENCER_PIPELINE_DEPTH);
+        this.pipelineDiscards = createUpDownCounterWithDefault(this.meter, Metrics.SEQUENCER_PIPELINE_DISCARDS_COUNT);
+        this.pipelineDepth.record(0);
+        // Fisherman fee analysis metrics
+        this.fishermanWouldBeIncluded = createUpDownCounterWithDefault(this.meter, Metrics.FISHERMAN_FEE_ANALYSIS_WOULD_BE_INCLUDED, {
+            [Attributes.OK]: [
+                true,
+                false
+            ],
+            [Attributes.BLOCK_FULL]: [
+                'true',
+                'false'
+            ]
         });
-        this.allowanceToCollectAttestations = this.meter.createGauge(Metrics.SEQUENCER_COLLECT_ATTESTATIONS_TIME_ALLOWANCE, {
-            description: 'Maximum amount of time to collect attestations',
-            unit: 'ms',
-            valueType: ValueType.INT
-        });
-        this.requiredAttestions = this.meter.createGauge(Metrics.SEQUENCER_REQUIRED_ATTESTATIONS_COUNT, {
-            valueType: ValueType.INT,
-            description: 'The minimum number of attestations required to publish a block'
-        });
-        this.collectedAttestions = this.meter.createGauge(Metrics.SEQUENCER_COLLECTED_ATTESTATIONS_COUNT, {
-            valueType: ValueType.INT,
-            description: 'The minimum number of attestations required to publish a block'
+        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);
+        this.fishermanPendingBlobCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_PENDING_BLOB_COUNT);
+        this.fishermanIncludedBlobCount = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_INCLUDED_BLOB_COUNT);
+        this.fishermanBlockBlobsFull = createUpDownCounterWithDefault(this.meter, Metrics.FISHERMAN_FEE_ANALYSIS_BLOCK_BLOBS_FULL, {
+            [Attributes.OK]: [
+                true,
+                false
+            ]
         });
+        this.fishermanMaxBlobCapacity = this.meter.createHistogram(Metrics.FISHERMAN_FEE_ANALYSIS_MAX_BLOB_CAPACITY);
     }
     recordRequiredAttestations(requiredAttestationsCount, allowanceMs) {
         this.requiredAttestions.record(requiredAttestationsCount);
@@ -85,6 +126,9 @@ export class SequencerMetrics {
         this.collectedAttestions.record(0);
         this.timeToCollectAttestations.record(0);
     }
+    recordCheckpointAttestationDelay(duration) {
+        this.checkpointAttestationDelay.record(duration);
+    }
     recordCollectedAttestations(count, durationMs) {
         this.collectedAttestions.record(count);
         this.timeToCollectAttestations.record(Math.ceil(durationMs));
@@ -106,6 +150,12 @@ export class SequencerMetrics {
             [Attributes.SEQUENCER_STATE]: state
         });
     }
+    recordPipelineDepth(depth) {
+        this.pipelineDepth.record(depth);
+    }
+    recordPipelineDiscard(count = 1) {
+        this.pipelineDiscards.add(count);
+    }
     incOpenSlot(slot, proposer) {
         // sequencer went through the loop a second time. Noop
         if (slot === this.lastSeenSlot) {
@@ -133,4 +183,147 @@ export class SequencerMetrics {
             }
         }
     }
+    recordCheckpointSuccess() {
+        this.checkpointSuccess.add(1);
+    }
+    recordBlockProposalFailed(reason) {
+        this.blockProposalFailed.add(1, {
+            ...reason && {
+                [Attributes.ERROR_TYPE]: reason
+            }
+        });
+    }
+    recordCheckpointProposalSuccess() {
+        this.checkpointProposalSuccess.add(1);
+    }
+    recordCheckpointPrecheckFailed(checkType) {
+        this.checkpointPrecheckFailed.add(1, {
+            [Attributes.ERROR_TYPE]: checkType
+        });
+    }
+    recordCheckpointProposalFailed(reason) {
+        this.checkpointProposalFailed.add(1, {
+            ...reason && {
+                [Attributes.ERROR_TYPE]: reason
+            }
+        });
+    }
+    /** Records aggregate metrics for a completed checkpoint build. */ recordCheckpointBuild(durationMs, blockCount, txCount, totalMana) {
+        this.checkpointBuildDuration.record(Math.ceil(durationMs));
+        this.checkpointBlockCount.record(blockCount);
+        this.checkpointTxCount.record(txCount);
+        this.checkpointTotalMana.record(totalMana);
+    }
+    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);
+            this.fishermanPendingBlobCount.record(analysis.pendingSnapshot.pendingBlobCount, strategyAttributes);
+            // Record mined block data if available
+            if (analysis.minedBlock) {
+                this.fishermanIncludedBlobTxCount.record(analysis.minedBlock.includedBlobTxCount, strategyAttributes);
+                this.fishermanIncludedBlobCount.record(analysis.minedBlock.includedBlobCount, 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 whether the block reached 100% blob capacity
+                if (analysis.analysis.blockBlobsFull) {
+                    this.fishermanBlockBlobsFull.add(1, {
+                        ...strategyAttributes,
+                        [Attributes.OK]: true
+                    });
+                } else {
+                    this.fishermanBlockBlobsFull.add(1, {
+                        ...strategyAttributes,
+                        [Attributes.OK]: false
+                    });
+                }
+                // Record the max blob capacity for this block
+                this.fishermanMaxBlobCapacity.record(analysis.analysis.maxBlobCapacity, strategyAttributes);
+                // Record strategy-specific inclusion result
+                if (strategyResult.wouldBeIncluded !== undefined) {
+                    const inclusionAttributes = {
+                        ...strategyAttributes,
+                        [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false'
+                    };
+                    if (strategyResult.wouldBeIncluded) {
+                        this.fishermanWouldBeIncluded.add(1, {
+                            ...inclusionAttributes,
+                            [Attributes.OK]: true
+                        });
+                    } else {
+                        this.fishermanWouldBeIncluded.add(1, {
+                            ...inclusionAttributes,
+                            [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;
+                    const deltaAttributes = {
+                        ...strategyAttributes,
+                        [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false'
+                    };
+                    this.fishermanPriorityFeeDelta.record(priorityFeeDeltaGwei, deltaAttributes);
+                }
+                // Record estimated cost if available
+                if (strategyResult.estimatedCostEth !== undefined) {
+                    const costAttributes = {
+                        ...strategyAttributes,
+                        [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false'
+                    };
+                    this.fishermanEstimatedCost.record(strategyResult.estimatedCostEth, costAttributes);
+                }
+                // Record estimated overpayment if available
+                if (strategyResult.estimatedOverpaymentEth !== undefined) {
+                    const overpaymentAttributes = {
+                        ...strategyAttributes,
+                        [Attributes.BLOCK_FULL]: analysis.analysis.blockBlobsFull ? 'true' : 'false'
+                    };
+                    this.fishermanEstimatedOverpayment.record(strategyResult.estimatedOverpaymentEth, overpaymentAttributes);
+                }
+            }
+        }
+    }
 }