feat: add prom metrics for stacks block count at previous burn block

src/datastore/pg-store.ts

@@ -4524,4 +4524,13 @@ export class PgStore extends BasePgStore {
     `;
     if (result.count) return result[0];
   }
+
+  async getStacksBlockCountAtBurnBlock(burnBlockHeight: number): Promise<number> {
+    const result = await this.sql<{ count: string }[]>`
+      SELECT COUNT(*) AS count
+      FROM blocks
+      WHERE burn_block_height = ${burnBlockHeight} AND canonical = TRUE
+    `;
+    return parseInt(result[0]?.count ?? '0');
+  }
 }

src/datastore/pg-write-store.ts

@@ -1780,6 +1780,12 @@ export class PgWriteStore extends PgStore {
     });
   }
 
+  async updateBurnChainBlockHeight(args: { blockHeight: number }): Promise<void> {
+    await this.sql`
+      UPDATE chain_tip SET burn_block_height = GREATEST(${args.blockHeight}, burn_block_height)
+    `;
+  }
+
   async insertSlotHoldersBatch(sql: PgSqlClient, slotHolders: DbRewardSlotHolder[]): Promise<void> {
     const slotValues: RewardSlotHolderInsertValues[] = slotHolders.map(slot => ({
       canonical: true,

src/event-stream/event-server.ts

@@ -130,6 +130,7 @@ async function handleBurnBlockMessage(
     burnchainBlockHeight: burnBlockMsg.burn_block_height,
     slotHolders: slotHolders,
   });
+  await db.updateBurnChainBlockHeight({ blockHeight: burnBlockMsg.burn_block_height });
 }
 
 async function handleMempoolTxsMessage(rawTxs: string[], db: PgWriteStore): Promise<void> {
@@ -635,14 +636,26 @@ function createMessageProcessorQueue(): EventMessageHandler {
   // Create a promise queue so that only one message is handled at a time.
   const processorQueue = new PQueue({ concurrency: 1 });
 
-  let eventTimer: prom.Histogram<'event'> | undefined;
+  let metrics:
+    | {
+        eventTimer: prom.Histogram;
+        blocksInPreviousBurnBlock: prom.Gauge;
+      }
+    | undefined;
   if (isProdEnv) {
-    eventTimer = new prom.Histogram({
-      name: 'stacks_event_ingestion_timers',
-      help: 'Event ingestion timers',
-      labelNames: ['event'],
-      buckets: prom.exponentialBuckets(50, 3, 10), // 10 buckets, from 50 ms to 15 minutes
-    });
+    metrics = {
+      eventTimer: new prom.Histogram({
+        name: 'stacks_event_ingestion_timers',
+        help: 'Event ingestion timers',
+        labelNames: ['event'],
+        buckets: prom.exponentialBuckets(50, 3, 10), // 10 buckets, from 50 ms to 15 minutes
+      }),
+      blocksInPreviousBurnBlock: new prom.Gauge({
+        name: 'stacks_blocks_in_previous_burn_block',
+        help: 'Number of Stacks blocks produced in the previous burn block',
+      }),
+    };
+    metrics.blocksInPreviousBurnBlock.remove();
   }
 
   const observeEvent = async (event: string, fn: () => Promise<void>) => {
@@ -651,7 +664,7 @@ function createMessageProcessorQueue(): EventMessageHandler {
       await fn();
     } finally {
       const elapsedMs = timer.getElapsed();
-      eventTimer?.observe({ event }, elapsedMs);
+      metrics?.eventTimer.observe({ event }, elapsedMs);
     }
   };
 
@@ -686,7 +699,14 @@ function createMessageProcessorQueue(): EventMessageHandler {
     },
     handleBurnBlock: (msg: CoreNodeBurnBlockMessage, db: PgWriteStore) => {
       return processorQueue
-        .add(() => observeEvent('burn_block', () => handleBurnBlockMessage(msg, db)))
+        .add(async () => {
+          await observeEvent('burn_block', () => handleBurnBlockMessage(msg, db));
+          if (metrics) {
+            metrics.blocksInPreviousBurnBlock.set(
+              await db.getStacksBlockCountAtBurnBlock(msg.burn_block_height - 1)
+            );
+          }
+        })
         .catch(e => {
           logger.error(e, 'Error processing core node burn block message');
           throw e;