Beacon sync metrics managemnt update (#3016)

* Sync scheduler provides an independent `ticker` loop process

why:
  Can be used to update `metrics` and for debug logging. While an event
  driven solution would stall if there are no events at the moment (e.g.
  when the syncer hibernates, the `ticker` will run regardless.

* Use `runTicker()` loop interface alike for updating ticker

why:
  Not event driven anymore so it will not stall when the syncer
  hibernates.

* Re-implement logging ticker by running it within the `runTicker()` driver

why:
  Simplifies implementation

* Re-name metrics variable to better fit into the current naming schemes

* Fix copyright header

Author: mjfh

nimbus/db/ledger.nim

@@ -1,5 +1,5 @@
 # Nimbus
-# Copyright (c) 2023-2024 Status Research & Development GmbH
+# Copyright (c) 2023-2025 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
 #    http://www.apache.org/licenses/LICENSE-2.0)

nimbus/sync/beacon.nim

@@ -1,5 +1,5 @@
 # Nimbus
-# Copyright (c) 2023-2024 Status Research & Development GmbH
+# Copyright (c) 2023-2025 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
 #    http://www.apache.org/licenses/LICENSE-2.0)
@@ -36,6 +36,9 @@ proc runRelease(ctx: BeaconCtxRef) =
 proc runDaemon(ctx: BeaconCtxRef) {.async: (raises: []).} =
   await worker.runDaemon(ctx, "RunDaemon")
 
+proc runTicker(ctx: BeaconCtxRef) =
+  worker.runTicker(ctx, "RunTicker")
+
 proc runStart(buddy: BeaconBuddyRef): bool =
   worker.start(buddy, "RunStart")
 

nimbus/sync/beacon/README.md

@@ -307,19 +307,19 @@ The following metrics are defined in *worker/update/metrics.nim* which will
 be available if *nimbus* is compiled with the additional make flags
 *NIMFLAGS="-d:metrics \-\-threads:on"*:
 
-| *Variable*         | *Logic type* | *Short description* |
-|:-------------------|:------------:|:--------------------|
-|                    |              |                     |
-| beacon_base        | block height | **B**, *increasing* |
-| beacon_latest      | block height | **L**, *increasing* |
-| beacon_coupler     | block height | **C**, *increasing* |
-| beacon_dangling    | block height | **D**               |
-| beacon_head        | block height | **H**, *increasing* |
-| beacon_target      | block height | **T**, *increasing* |
-|                            |      |                     |
-| beacon_header_lists_staged | size | # of staged header list records      |
-| beacon_headers_unprocessed | size | # of accumulated header block numbers|
-| beacon_block_lists_staged  | size | # of staged block list records       |
-| beacon_blocks_unprocessed  | size | # of accumulated body block numbers  |
-|                            |      |                                      |
-| beacon_buddies             | size | # of peers working concurrently      |
+| *Variable*                   | *Logic type* | *Short description* |
+|:-----------------------------|:------------:|:--------------------|
+|                              |              |                     |
+| nec_base                     | block height | **B**, *increasing* |
+| nec_execution_head           | block height | **L**, *increasing* |
+| nec_sync_coupler             | block height | **C**, *increasing* |
+| nec_sync_dangling            | block height | **D**               |
+| nec_sync_head                | block height | **H**, *increasing* |
+| nec_consensus_head           | block height | **T**, *increasing* |
+|                              |              |                     |
+| nec_sync_header_lists_staged | size | # of staged header list records      |
+| nec_sync_headers_unprocessed | size | # of accumulated header block numbers|
+| nec_sync_block_lists_staged  | size | # of staged block list records       |
+| nec_sync_blocks_unprocessed  | size | # of accumulated body block numbers  |
+|                              |      |                                      |
+| nec_sync_peers               | size | # of peers working concurrently      |

nimbus/sync/beacon/worker.nim

@@ -1,5 +1,5 @@
 # Nimbus
-# Copyright (c) 2023-2024 Status Research & Development GmbH
+# Copyright (c) 2023-2025 Status Research & Development GmbH
 # Licensed and distributed under either of
 #   * MIT license (license terms in the root directory or at
 #     https://opensource.org/licenses/MIT).
@@ -15,6 +15,7 @@ import
   pkg/eth/[common, p2p],
   pkg/stew/[interval_set, sorted_set],
   ../../common,
+  ./worker/update/[metrics, ticker],
   ./worker/[blocks_staged, headers_staged, headers_unproc, start_stop, update],
   ./worker_desc
 
@@ -59,15 +60,11 @@ proc setup*(ctx: BeaconCtxRef; info: static[string]): bool =
 
   # Load initial state from database if there is any
   ctx.setupDatabase info
-
-  # Debugging stuff, might be an empty template
-  ctx.setupTicker()
   true
 
 proc release*(ctx: BeaconCtxRef; info: static[string]) =
   ## Global clean up
   ctx.destroyRpcMagic()
-  ctx.destroyTicker()
 
 
 proc start*(buddy: BeaconBuddyRef; info: static[string]): bool =
@@ -96,15 +93,18 @@ proc stop*(buddy: BeaconBuddyRef; info: static[string]) =
 # Public functions
 # ------------------------------------------------------------------------------
 
+proc runTicker*(ctx: BeaconCtxRef; info: static[string]) =
+  ## Global background job that is started every few seconds. It is to be
+  ## intended for updating metrics, debug logging etc.
+  ctx.updateMetrics()
+  ctx.updateTicker()
+
 proc runDaemon*(
     ctx: BeaconCtxRef;
     info: static[string];
       ) {.async: (raises: []).} =
   ## Global background job that will be re-started as long as the variable
-  ## `ctx.daemon` is set `true`. If that job was stopped due to re-setting
-  ## `ctx.daemon` to `false`, it will be restarted next after it was reset
-  ## as `true` not before there is some activity on the `runPool()`,
-  ## `runSingle()`, or `runMulti()` functions.
+  ## `ctx.daemon` is set `true`.
   ##
   ## On a fresh start, the flag `ctx.daemon` will not be set `true` before the
   ## first usable request from the CL (via RPC) stumbles in.

nimbus/sync/beacon/worker/blocks_staged.nim

@@ -17,7 +17,6 @@ import
   ../../../core/chain,
   ../worker_desc,
   ./blocks_staged/bodies,
-  ./update/metrics,
   "."/[blocks_unproc, db, helpers, update]
 
 # ------------------------------------------------------------------------------
@@ -194,9 +193,6 @@ proc blocksStagedCollect*(
       # response length from the network.
       nBlkBlocks = blk.blocks.len
 
-    # Update, so it can be followed nicely
-    ctx.updateMetrics()
-
     # Fetch and extend staging record
     if not await buddy.fetchAndCheck(ivReq, blk, info):
       haveError = true
@@ -258,9 +254,6 @@ proc blocksStagedCollect*(
     nBlocks=blk.blocks.len, nStaged=ctx.blk.staged.len,
     bdyErrors=buddy.bdyErrors
 
-  # Update, so it can be followed nicely
-  ctx.updateMetrics()
-
   return true
 
 
@@ -320,9 +313,6 @@ proc blocksStagedImport*(
         maxImport = ctx.chain.latestNumber()
         break importLoop
 
-      # Update, so it can be followed nicely
-      ctx.updateMetrics()
-
       # Allow pseudo/async thread switch.
       (await ctx.updateAsyncTasks()).isOkOr:
         maxImport = ctx.chain.latestNumber()
@@ -358,9 +348,6 @@ proc blocksStagedImport*(
   for bn in iv.minPt .. maxImport:
     ctx.dbHeaderUnstash bn
 
-  # Update, so it can be followed nicely
-  ctx.updateMetrics()
-
   info "Import done", iv, nBlocks, base=ctx.chain.baseNumber.bnStr,
     head=ctx.chain.latestNumber.bnStr, target=ctx.layout.final.bnStr
   return true

nimbus/sync/beacon/worker/headers_staged.nim

@@ -17,7 +17,6 @@ import
   pkg/stew/[interval_set, sorted_set],
   ../../../common,
   ../worker_desc,
-  ./update/metrics,
   ./headers_staged/[headers, linked_hchain],
   "."/[headers_unproc, update]
 
@@ -234,9 +233,6 @@ proc headersStagedProcess*(ctx: BeaconCtxRef; info: static[string]): int =
     # anymore.
     discard ctx.hdr.staged.delete(iv.maxPt)
 
-    # Update, so it can be followed nicely
-    ctx.updateMetrics()
-
     if qItem.data.hash != ctx.dbHeaderParentHash(dangling).expect "Hash32":
       # Discard wrong chain and merge back the range into the `unproc` list.
       ctx.headersUnprocCommit(0,iv)
@@ -257,9 +253,6 @@ proc headersStagedProcess*(ctx: BeaconCtxRef; info: static[string]): int =
   if headersStagedQueueLengthLwm < ctx.hdr.staged.len:
     ctx.poolMode = true
 
-  # Update, so it can be followed nicely
-  ctx.updateMetrics()
-
 
 proc headersStagedReorg*(ctx: BeaconCtxRef; info: static[string]) =
   ## Some pool mode intervention. The effect is that all concurrent peers
@@ -295,9 +288,6 @@ proc headersStagedReorg*(ctx: BeaconCtxRef; info: static[string]) =
       ctx.headersUnprocCommit(0, key - nHeaders + 1, key)
       discard ctx.hdr.staged.delete key
 
-    # Update, so it can be followed nicely
-    ctx.updateMetrics()
-
 # ------------------------------------------------------------------------------
 # End
 # ------------------------------------------------------------------------------

nimbus/sync/beacon/worker/start_stop.nim

@@ -1,5 +1,5 @@
 # Nimbus
-# Copyright (c) 2023-2024 Status Research & Development GmbH
+# Copyright (c) 2023-2025 Status Research & Development GmbH
 # Licensed and distributed under either of
 #   * MIT license (license terms in the root directory or at
 #     https://opensource.org/licenses/MIT).
@@ -17,46 +17,12 @@ import
   ../worker_desc,
   ./blocks_staged/staged_queue,
   ./headers_staged/staged_queue,
-  ./update/metrics,
   "."/[blocks_unproc, db, headers_unproc, update]
 
-when enableTicker:
-  import ./start_stop/ticker
-
 # ------------------------------------------------------------------------------
 # Private functions
 # ------------------------------------------------------------------------------
 
-when enableTicker:
-  proc tickerUpdater(ctx: BeaconCtxRef): TickerStatsUpdater =
-    ## Legacy stuff, will be probably be superseded by `metrics`
-    return proc: auto =
-      TickerStats(
-        base:            ctx.chain.baseNumber(),
-        latest:          ctx.chain.latestNumber(),
-        coupler:         ctx.layout.coupler,
-        dangling:        ctx.layout.dangling,
-        head:            ctx.layout.head,
-        headOk:          ctx.layout.lastState != idleSyncState,
-        target:          ctx.target.consHead.number,
-        targetOk:        ctx.target.final != 0,
-
-        nHdrStaged:      ctx.headersStagedQueueLen(),
-        hdrStagedTop:    ctx.headersStagedQueueTopKey(),
-        hdrUnprocTop:    ctx.headersUnprocTop(),
-        nHdrUnprocessed: ctx.headersUnprocTotal() + ctx.headersUnprocBorrowed(),
-        nHdrUnprocFragm: ctx.headersUnprocChunks(),
-
-        nBlkStaged:      ctx.blocksStagedQueueLen(),
-        blkStagedBottom: ctx.blocksStagedQueueBottomKey(),
-        blkUnprocBottom: ctx.blocksUnprocBottom(),
-        nBlkUnprocessed: ctx.blocksUnprocTotal() + ctx.blocksUnprocBorrowed(),
-        nBlkUnprocFragm: ctx.blocksUnprocChunks(),
-
-        reorg:           ctx.pool.nReorg,
-        nBuddies:        ctx.pool.nBuddies)
-
-
 proc updateBeaconHeaderCB(
     ctx: BeaconCtxRef;
     info: static[string];
@@ -93,22 +59,6 @@ proc updateBeaconHeaderCB(
 # Public functions
 # ------------------------------------------------------------------------------
 
-when enableTicker:
-  proc setupTicker*(ctx: BeaconCtxRef) =
-    ## Helper for `setup()`: Start ticker
-    ctx.pool.ticker = TickerRef.init(ctx.tickerUpdater)
-
-  proc destroyTicker*(ctx: BeaconCtxRef) =
-    ## Helper for `release()`
-    ctx.pool.ticker.destroy()
-    ctx.pool.ticker = TickerRef(nil)
-
-else:
-  template setupTicker*(ctx: BeaconCtxRef) = discard
-  template destroyTicker*(ctx: BeaconCtxRef) = discard
-
-# ---------
-
 proc setupDatabase*(ctx: BeaconCtxRef; info: static[string]) =
   ## Initalise database related stuff
 
@@ -157,13 +107,11 @@ proc startBuddy*(buddy: BeaconBuddyRef): bool =
     peer = buddy.peer
   if peer.supports(protocol.eth) and peer.state(protocol.eth).initialized:
     ctx.pool.nBuddies.inc
-    ctx.updateMetrics()
     return true
 
 proc stopBuddy*(buddy: BeaconBuddyRef) =
   let ctx = buddy.ctx
   ctx.pool.nBuddies.dec
-  ctx.updateMetrics(force=(ctx.pool.nBuddies == 0))
 
 # ------------------------------------------------------------------------------
 # End

nimbus/sync/beacon/worker/update.nim

@@ -16,7 +16,6 @@ import
   pkg/stew/[byteutils, sorted_set],
   ../../../core/chain,
   ../worker_desc,
-  ./update/metrics,
   ./blocks_staged/staged_queue,
   ./headers_staged/staged_queue,
   "."/[blocks_unproc, db, headers_unproc, helpers]
@@ -123,9 +122,6 @@ proc startHibernating(ctx: BeaconCtxRef; info: static[string]) =
 
   info "Suspending syncer", head=ctx.chain.latestNumber.bnStr
 
-  # Update, so it can be followed nicely
-  ctx.updateMetrics()
-
 
 proc setupCollectingHeaders(ctx: BeaconCtxRef; info: static[string]) =
   ## Set up sync target (see clause *(9)* in `README.md`) by modifying
@@ -171,9 +167,6 @@ proc setupCollectingHeaders(ctx: BeaconCtxRef; info: static[string]) =
     # Update range
     ctx.headersUnprocSet(c+1, h-1)
 
-    # Update, so it can be followed nicely
-    ctx.updateMetrics()
-
     # Mark target used, reset for re-fill
     ctx.target.changed = false
 
@@ -238,9 +231,6 @@ proc linkIntoFc(ctx: BeaconCtxRef; info: static[string]): bool =
 
       # Save layout state
       ctx.dbStoreSyncStateLayout info
-
-      # Update, so it can be followed nicely
-      ctx.updateMetrics()
       return true
 
   trace info & ": cannot link into FC", B=b.bnStr, L=l.bnStr,
@@ -341,9 +331,6 @@ proc updateFinalBlockHeader*(
       info "Activating syncer", base=b.bnStr, head=ctx.chain.latestNumber.bnStr,
         finalised=f.bnStr, target=ctx.target.consHead.bnStr
 
-    # Update, so it can be followed nicely
-    ctx.updateMetrics()
-
 
 proc updateAsyncTasks*(
     ctx: BeaconCtxRef;