package events.v1

Get desktop application:
View/edit binary Protocol Buffers messages

An event server for receiving application reported events. Auth is via bearer token. Client must ed25519 sign the challenge token returned by Authenticate and present it in the `authorization` header as `Bearer <hex(token)>.<hex(sig)>`.

• rpc Authenticate (AuthenticateRequest, AuthenticateResponse)

  event.proto:57

  Generate an authentication challenge token for the client to sign.

  message AuthenticateRequest

  event.proto:27

  • bytes identity_pubkey = 1

  • string version = 2

  • string commit_hash = 3

  • bytes genesis_hash = 4

  • uint64 shred_version = 5

  • uint64 instance_id = 6

  • uint64 machine_id = 7

  • uint64 boot_id = 8

  • string action = 9

  • uint64 protocol_version = 10

  message AuthenticateResponse

  event.proto:40

  • bytes challenge = 1

  • uint64 max_stream_body = 2

• rpc StreamEvents (stream StreamEventsRequest, stream StreamEventsResponse)

  event.proto:61

  Stream of events from client to server, and acknowledgements from server to client. The client authenticates by presenting the signed challenge token in the authorization header.

  message StreamEventsRequest

  event.proto:8

  An event sent from the application to the event server

  • uint64 nonce = 1

    A nonce provided by the application to identify this event, should be acknowledged back in StreamEventsResponse

  • uint64 event_id = 2

    The unique ID of the event from this application instance, monotonically increasing from zero; restarts from zero when the validator restarts (scope by AuthenticateRequest.instance_id), may have gaps if events get dropped

  • uint64 link_seq = 3

    The producer's per-link sequence number, monotonically increasing from zero, gaps indicate the producer's link to the event tile overran and dropped events

  • uint64 timestamp_nanos = 4

    The wall clock time when the event was recorded, in nanoseconds since the Unix epoch

  • optional Event event = 5

    The actual event

  message StreamEventsResponse

  event.proto:22

  Acknowledgement of an event received by the server

  • uint64 nonce = 1

    The nonce of the acknowledged event

• rpc StreamEventsZstd (stream StreamEventsZstdRequest, stream StreamEventsZstdResponse)

  event.proto:66

  StreamEvents compressed as one zstd stream per call. Each message is the compressor output at one flush, ending on an event boundary, decompressed, the stream is varint(len) | StreamEventsRequest, repeated. An empty message is a heartbeat.

  message StreamEventsZstdRequest

  event.proto:45

  (message has no fields)

  message StreamEventsZstdResponse

  event.proto:47

  • uint64 nonce = 1

A single accounts-database partition finished compacting. Compaction scans one partition, relocates its still-live account records forward into the next storage tier, and reclaims the partition. Emitted once per partition per compaction pass by the accdb tile. Partitions are large (e.g. 32 GiB) so this is a rare, coarse-grained event rather than a hot-path counter.

Used in: Event

• uint64 partition_idx = 1

  Index of the partition that was compacted, identifying its slot in the accdb partition pool.

• uint32 src_layer = 2

  Storage tier the partition was compacted from. Layer 0 is the hot tier that takes live execution writes; higher layers are progressively colder. Records are promoted one tier per compaction.

• uint32 dest_layer = 3

  Storage tier the surviving live records were relocated into, normally src_layer+1, clamped at the coldest tier.

• uint64 bytes_scanned = 4

  Total bytes of account records walked in the partition this pass, live and dead combined. Equals the partition's written extent at the time compaction started.

• uint64 bytes_freed = 5

  Dead bytes in the partition that triggered compaction: space held by account records that had been superseded by newer versions. This is the space compaction reclaims.

• uint64 accounts_relocated = 6

  Number of still-live account records copied forward into dest_layer this pass.

• uint64 bytes_relocated = 7

  Total bytes of live account records copied forward into dest_layer this pass. Compare to bytes_scanned for the live fraction of the partition.

• uint64 dead_records = 8

  Number of records skipped because no live index entry referenced them, i.e. records that were already superseded. Together with accounts_relocated this accounts for every record scanned.

• uint64 start_time = 9

  Wall-clock time at which this compaction pass began, in nanoseconds since the Unix epoch.

• uint64 end_time = 10

  Wall-clock time at which this compaction pass completed, in nanoseconds since the Unix epoch. Subtract start_time for the pass duration.

The accounts database grew its backing file by one partition. The accounts DB is a single file divided into fixed-size partitions; when a write head runs off the end of the allocated file, a new partition is fallocated and the file grows. Emitted once per grow by the accdb tile. Partitions are large (e.g. 32 GiB) so grows are infrequent and each one is a meaningful step in the database's on-disk footprint.

Used in: Event

• uint64 partition_idx = 1

  Index of the newly allocated partition. Equals old_partition_max, i.e. it is appended at the end of the previously allocated range.

• uint64 prior_partition_idx = 2

  Index of the partition the write head rotated off of to trigger this grow, i.e. the partition that just filled up. UINT64_MAX when there was no prior write head (the very first partition allocated on this layer).

• uint32 layer = 3

  Storage tier whose write head triggered the grow. Layer 0 is the hot tier fed by live execution writes; higher layers are colder compaction-destination tiers. A layer-0 grow means live ingest outran reclamation; a higher-layer grow means compaction is staging more cold data.

• uint64 old_partition_max = 4

  Number of allocated partitions before this grow.

• uint64 new_partition_max = 5

  Number of allocated partitions after this grow, always old_partition_max+1.

• uint64 partition_sz = 6

  Size of a single partition in bytes; the increment by which the backing file grows.

• uint64 disk_allocated_bytes = 7

  Total fallocated size of the accounts database file in bytes after this grow, equal to new_partition_max times partition_sz. Tracks the database's on-disk footprint over time.

• uint64 duration_fallocate_nanos = 8

  Wall time the fallocate call that grew the file by this partition took, in nanoseconds. Slow filesystems can take seconds.

• bool preallocated = 9

  True if the accdb tile grew the file ahead of any write head so a later rotation does not wait on fallocate. layer is then 0 and prior_partition_idx is UINT64_MAX, and neither names a triggering write head.

An admin command completed. Emitted once for every command processed by the running validator, whether it succeeded or failed.

Used in: Event

• AdminCommandType type = 1

  The admin command that was processed.

• AdminCommandResult result = 2

  The result of processing the admin command.

• bytes custom_result = 3

  The command-specific result when result is custom.

• uint64 start_time = 4

  Wall-clock nanosecond unix timestamp at which the command started getting processed.

• uint64 end_time = 5

  Wall-clock nanosecond unix timestamp at which the command completed.

• uint64 payload_version = 6

  Payload version requested by the command. Valid only when has_payload_version is true.

• bool has_payload_version = 7

  Whether the command payload was large enough to contain payload_version.

• uint64 payload_size = 8

  Size of the received command payload in bytes.

• bytes args_json = 9

  Command-specific public values serialized as JSON. Unavailable values are omitted. Private key material is never included.

The result of processing the admin command.

Used in: AdminCommand

• ADMIN_COMMAND_RESULT_UNSPECIFIED = 0

• ADMIN_COMMAND_RESULT_SUCCESS = 1

  The command completed successfully.

• ADMIN_COMMAND_RESULT_UNKNOWN_COMMAND = 2

  The running validator does not recognize this command.

• ADMIN_COMMAND_RESULT_ABI_VERSION_MISMATCH = 3

  The request used an unsupported admin command ABI version.

• ADMIN_COMMAND_RESULT_ABI_SIZE_MISMATCH = 4

  The request size did not match the admin command ABI.

• ADMIN_COMMAND_RESULT_UNSUPPORTED = 5

  The command is not supported by this validator configuration.

• ADMIN_COMMAND_RESULT_CUSTOM = 6

  The command returned a command-specific result described by custom_result.

The admin command that was processed.

Used in: AdminCommand

• ADMIN_COMMAND_TYPE_UNSPECIFIED = 0

• ADMIN_COMMAND_TYPE_SET_IDENTITY = 1

  Change the running validator identity.

• ADMIN_COMMAND_TYPE_GET_IDENTITY = 2

  Read the running validator identity.

• ADMIN_COMMAND_TYPE_ADD_AUTHORIZED_VOTER = 3

  Add an authorized voter key.

• ADMIN_COMMAND_TYPE_REMOVE_ALL_AUTHORIZED_VOTERS = 4

  Remove every authorized voter key.

• ADMIN_COMMAND_TYPE_SNAPSHOT_CREATE = 5

  Request creation of a snapshot.

• ADMIN_COMMAND_TYPE_FAILOVER_PROMOTE = 6

  Take over the identity specified by the given keypair from the machine currently running it.

An Alpenglow consensus cert we received from a peer or constructed ourselves (see our_cert). Unparseable certs are not included. The row timestamp is when we finished processing the cert; the *_time columns are the phases before it, each running until the next. References: Table 6, Definition 12, Algorithm 1, Lemma 48

Used in: Event

• uint64 slot = 1

  Which slot the cert is for.

• bytes block_id = 2

  Which block the cert is for (only for fast_final, notar and notar_fallback, all zeros otherwise).

• AlpenglowCertKind kind = 3

  What kind of cert is this.

• bytes voters = 4

  Which validators' primary votes the cert aggregates (NotarVote for notar, fast_final and notar_fallback; FinalVote for final; SkipVote for skip), as a bitmap over the voter's rank in the slot's epoch: rank r is bit r%8 of byte r/8, bytes through the highest signer.

• bytes fallback_voters = 5

  Fallback signer set (NotarFallbackVote for notar_fallback, SkipFallbackVote for skip), a bitmap by rank like voters. Empty for other kinds.

• bytes relayer_ip = 6

  IPv4 address of the peer that relayed the cert to us; ourselves if our_cert, stored as an IPv4-mapped IPv6 address (all zeros if unknown).

• bytes relayer_identity = 7

  Validator identity of the peer that relayed the cert to us (determined from the QUIC client-side TLS certificate); ourselves if our_cert (all zeros if unknown_peer). Not necessarily the creator of the cert: a node re-broadcasts the first valid cert it obtains (whether from self or others).

• bool our_cert = 8

  Whether we constructed the cert ourselves from the votes we had received, rather than a peer delivering it first. Not every cert is self-made; when it is, we reached the threshold before any peer's copy arrived, i.e. we are running fast.

• repeated AlpenglowCertBroadcastTo broadcast_to = 9

  Who we sent the cert to, indexed by rank like voters: identity and address at each rank, all zeros where we did not send (only if our_cert, empty otherwise).

• AlpenglowCertProcessingResult processing_result = 10

  What we did with the cert. unknown_peer and banned_peer are decided on the connection before the cert is decoded, shred_version_mismatch and unranked_peer after decoding, in that order; the rest are Alpenglow-specific.

• uint64 verify_start_time = 11

  When we started BLS verifying the cert (unset if our_cert).

• uint64 broadcast_start_time = 12

  When we started broadcasting the cert to our peers, BLS verification having finished (only if our_cert, 0 otherwise).

• uint64 done_time = 13

  When we finished processing the cert, may be any of the above stages including short-circuiting at earlier stages.

The peer at this rank.

Used in: AlpenglowCert

• bytes identity = 1

  Validator identity of the peer (all zeros if not sent).

• bytes ip = 2

  IPv4 address of the peer as an IPv4-mapped IPv6 address (all zeros if not sent).

• uint32 port = 3

  Port of the peer's Alpenglow QUIC endpoint (0 if not sent).

What kind of cert is this.

Used in: AlpenglowCert

• ALPENGLOW_CERT_KIND_UNSPECIFIED = 0

• ALPENGLOW_CERT_KIND_FINAL = 1

  FinalVote aggregate that sums >= 60% of stake, for slot. There is guaranteed to be one unique notarized block_id Final corresponds to.

• ALPENGLOW_CERT_KIND_FAST_FINAL = 2

  NotarVote aggregate that sums >= 80% of stake, for block_id; finalizes it in one round.

• ALPENGLOW_CERT_KIND_NOTAR = 3

  NotarVote aggregate that sums >= 60% of stake, for block_id (BlockNotarized; Definition 15).

• ALPENGLOW_CERT_KIND_NOTAR_FALLBACK = 4

  NotarVote or NotarFallbackVote aggregate that sums >= 60% of stake, for block_id. At most four blocks per slot (Lemma 48).

• ALPENGLOW_CERT_KIND_SKIP = 5

  SkipVote or SkipFallbackVote aggregate that sums >= 60% of stake, for slot.

What we did with the cert. unknown_peer and banned_peer are decided on the connection before the cert is decoded, shred_version_mismatch and unranked_peer after decoding, in that order; the rest are Alpenglow-specific.

Used in: AlpenglowCert

• ALPENGLOW_CERT_PROCESSING_RESULT_UNSPECIFIED = 0

• ALPENGLOW_CERT_PROCESSING_RESULT_UNKNOWN_PEER = 1

  The connection had no known peer: we cleared its identity while closing it, or accepted it before we knew the epoch's validators.

• ALPENGLOW_CERT_PROCESSING_RESULT_BANNED_PEER = 2

  The peer is banned for an earlier invalid signature or cert; connection closed.

• ALPENGLOW_CERT_PROCESSING_RESULT_SHRED_VERSION_MISMATCH = 3

  Signed under a different shred version than ours.

• ALPENGLOW_CERT_PROCESSING_RESULT_UNRANKED_PEER = 4

  The peer has no rank in the slot's epoch.

• ALPENGLOW_CERT_PROCESSING_RESULT_SLOT_TOO_OLD = 5

  The slot is behind our finality frontier, or in an earlier epoch we have no stake information for.

• ALPENGLOW_CERT_PROCESSING_RESULT_SLOT_TOO_NEW = 6

  The slot is beyond our look-ahead window, or in an epoch we have no stake information for.

• ALPENGLOW_CERT_PROCESSING_RESULT_DUPLICATE = 7

  We already held a cert of this kind for the slot, or for this block if notar_fallback; we keep one per kind (Definition 13), so we dropped the copy without verifying it. The common case: every node broadcasts each cert it accepts. Recorded for notar certs only.

• ALPENGLOW_CERT_PROCESSING_RESULT_IGNORED_REDUNDANT = 8

  We already hold a valid cert that supersedes this one, e.g. a fast-finalization cert for the block a notarization cert arrives for; ignored.

• ALPENGLOW_CERT_PROCESSING_RESULT_FAILED_BLS_VERIFY = 9

  The signers' stake is below the threshold (Table 6), a signer rank is outside the epoch, or the aggregate BLS signature is invalid; peer banned.

• ALPENGLOW_CERT_PROCESSING_RESULT_ACCEPTED = 10

  BLS verified (stake threshold of Table 6 and aggregate BLS signature) and stored as the first cert of its kind for the slot, then broadcast to our peers (Definition 13); see broadcast_start_time and broadcast_to.

An Alpenglow consensus vote we received from a peer or cast ourselves (see our_vote). Unparseable votes are not included. The row timestamp is when we finished processing the vote; the *_time columns are the phases before it, each running until the next. References: Table 6, Definition 12, Algorithm 1, Lemma 48

Used in: Event

• uint64 slot = 1

  Which slot the vote is for.

• bytes block_id = 2

  Which block the vote is for (only for notar and notar_fallback, all zeros otherwise).

• uint32 voter_rank = 3

  Where the voter ranks in the slot's epoch (only if ranked, 65535 otherwise). Also marks their position in the Cert array

• bytes voter_identity = 4

  Validator identity of the voter, looked up from voter_rank in the slot's epoch (all zeros if voter_rank is 65535).

• AlpenglowVoteKind kind = 5

  What kind of vote is this.

• bytes received_from_ip = 6

  IPv4 address of the peer we received the vote from; ourselves if our_vote, stored as an IPv4-mapped IPv6 address (all zeros if unknown).

• bytes received_from_identity = 7

  Validator identity of the peer we received the vote from (determined from the QUIC client-side TLS certificate); ourselves if our_vote (all zeros if unknown_peer). This is the voter whenever voter_rank is set, since votes are only accepted from their voter.

• bool our_vote = 8

  Whether this is our own vote, which we store like any other; received_from_identity is then our identity.

• AlpenglowVoteReason reason = 9

  Why we cast the vote, based on the Alpenglow voting algorithm (not_our_vote if it is not ours). References: Algorithms 1 and 2, Definitions 15, 16 and 17.

• repeated AlpenglowVoteBroadcastTo broadcast_to = 10

  Who we sent the vote to, by rank like voters: identity and address at each rank, all zeros where we did not send (only if our_vote, empty otherwise).

• AlpenglowVoteProcessingResult processing_result = 11

  What we did with the vote. unknown_peer and banned_peer are decided on the connection before the vote is decoded, shred_version_mismatch and unranked_peer after decoding, in that order; the rest are Alpenglow-specific validation.

• bool quorum_reached_final_cert = 12

  Final votes for the slot reached 60% of stake (Table 6). Crossing a quorum triggers BLS verification of the votes (see verify_start_time).

• bool quorum_reached_fast_final_cert = 13

  Notar votes for block_id reached 80% of stake (Table 6). Crossing a quorum triggers BLS verification of the votes (see verify_start_time).

• bool quorum_reached_notar_cert = 14

  Notar votes for block_id reached 60% of stake (Table 6). Crossing a quorum triggers BLS verification of the votes (see verify_start_time).

• bool quorum_reached_notar_fallback_cert = 15

  Notar and notar-fallback votes for block_id reached 60% of stake (Table 6). Crossing a quorum triggers BLS verification of the votes (see verify_start_time).

• bool quorum_reached_skip_cert = 16

  Skip and skip-fallback votes for the slot reached 60% of stake (Table 6). Crossing a quorum triggers BLS verification of the votes (see verify_start_time).

• bool quorum_reached_safe_to_notar = 17

  Notar votes for block_id reached 40% of stake, or 20% with skip votes bringing the total to 60% (Definition 16). Crossing a quorum triggers BLS verification of the votes (see verify_start_time).

• bool quorum_reached_safe_to_skip = 18

  Skip votes plus notar votes for every block but the most-voted one reached 40% of stake (Definition 16). Crossing a quorum triggers BLS verification of the votes (see verify_start_time).

• uint64 aggregation_start_time = 19

  When we started aggregating the vote into the running BLS aggregate for its slot, kind and block (only if processing_result is accepted, 0 otherwise).

• uint64 verify_start_time = 20

  When we started BLS verifying the aggregate this vote completed (only if this vote brought a tally to a quorum of Table 6 or Definition 16, which is when we verify signatures, 0 otherwise).

• uint64 broadcast_start_time = 21

  When we started broadcasting the vote to our peers (only if our_vote, 0 otherwise).

• uint64 done_time = 22

  When we finished processing the vote, may be any of the above stages including short-circuiting at earlier stages.

The peer at this rank.

Used in: AlpenglowVote

• bytes identity = 1

  Validator identity of the peer (all zeros if not sent).

• bytes ip = 2

  IPv4 address of the peer as an IPv4-mapped IPv6 address (all zeros if not sent).

• uint32 port = 3

  Port of the peer's Alpenglow QUIC endpoint (0 if not sent).

What kind of vote is this.

Used in: AlpenglowVote

• ALPENGLOW_VOTE_KIND_UNSPECIFIED = 0

• ALPENGLOW_VOTE_KIND_NOTAR = 1

  Cast on the slot's first block once its parent is ready at a window start, or once we notarized its parent in the previous slot (Algorithm 2, Definition 15).

• ALPENGLOW_VOTE_KIND_FINAL = 2

  Cast once the block we notarized has a notarization cert and we cast no skip or fallback vote in the slot (Algorithm 2, Definition 18). Names only the slot.

• ALPENGLOW_VOTE_KIND_SKIP = 3

  Cast for every unvoted slot of the leader window on timeout (Definition 17), or on SafeToNotar or SafeToSkip (Algorithm 1). Names only the slot.

• ALPENGLOW_VOTE_KIND_NOTAR_FALLBACK = 4

  Cast on SafeToNotar. At most three per slot (Definition 12).

• ALPENGLOW_VOTE_KIND_SKIP_FALLBACK = 5

  Cast on SafeToSkip. Names only the slot.

What we did with the vote. unknown_peer and banned_peer are decided on the connection before the vote is decoded, shred_version_mismatch and unranked_peer after decoding, in that order; the rest are Alpenglow-specific validation.

Used in: AlpenglowVote

• ALPENGLOW_VOTE_PROCESSING_RESULT_UNSPECIFIED = 0

• ALPENGLOW_VOTE_PROCESSING_RESULT_UNKNOWN_PEER = 1

  The connection had no known peer: we cleared its identity while closing it, or accepted it before we knew the epoch's validators.

• ALPENGLOW_VOTE_PROCESSING_RESULT_BANNED_PEER = 2

  The peer is banned for an earlier invalid signature or cert; connection closed.

• ALPENGLOW_VOTE_PROCESSING_RESULT_SHRED_VERSION_MISMATCH = 3

  Signed under a different shred version than ours.

• ALPENGLOW_VOTE_PROCESSING_RESULT_UNRANKED_PEER = 4

  The peer has no rank in the slot's epoch.

• ALPENGLOW_VOTE_PROCESSING_RESULT_SLOT_TOO_OLD = 5

  The slot is more than eight slots behind our finality frontier, or in an earlier epoch we have no stake information for.

• ALPENGLOW_VOTE_PROCESSING_RESULT_SLOT_TOO_NEW = 6

  The slot is beyond our look-ahead window, or in an epoch we have no stake information for.

• ALPENGLOW_VOTE_PROCESSING_RESULT_SLASHABLE = 7

  Conflicts with a vote the peer already cast for the slot (Lemma 22, Definition 12).

• ALPENGLOW_VOTE_PROCESSING_RESULT_DUPLICATE = 8

  We already stored this vote or one that covers it: notar and notar-fallback for one block, skip and skip-fallback (Definition 12); ignored.

• ALPENGLOW_VOTE_PROCESSING_RESULT_IGNORED_REDUNDANT = 9

  We already hold a valid cert for the slot, or block, this vote would count toward; ignored.

• ALPENGLOW_VOTE_PROCESSING_RESULT_ACCEPTED = 10

  Vote is accepted and next step is to aggregate (and broadcast, if our_vote).

Why we cast the vote, based on the Alpenglow voting algorithm (not_our_vote if it is not ours). References: Algorithms 1 and 2, Definitions 15, 16 and 17.

Used in: AlpenglowVote

• ALPENGLOW_VOTE_REASON_UNSPECIFIED = 0

• ALPENGLOW_VOTE_REASON_NOT_OUR_VOTE = 1

  Not our vote; see our_vote.

• ALPENGLOW_VOTE_REASON_BLOCK_REPLAYED = 2

  Replay completed the block normally, so we vote notar for it.

• ALPENGLOW_VOTE_REASON_PARENT_READY = 3

  We hold the certs that make a block a valid parent for the leader window starting at this slot (a notar, notar-fallback or fast-final cert for it, or it is finalized, and skip certs for every slot in between), so we vote notar for the window's first block we held pending.

• ALPENGLOW_VOTE_REASON_BLOCK_NOTARIZED = 4

  We hold a notar cert for the block we voted notar for and cast no skip or fallback vote in the slot, so we vote final for it.

• ALPENGLOW_VOTE_REASON_TIMEOUT = 5

  The slot's timeout fired with no vote cast in it, so we vote skip on the entire rest of the window containing this slot.

• ALPENGLOW_VOTE_REASON_SAFE_TO_NOTAR = 6

  No block but this one can be fast-finalized in the slot: notar votes for it reach 40% of stake, or 20% with skip votes bringing the total to 60%, and its parent is notar-fallback certified (Definition 16). Having voted skip or notar for another block in the slot, we vote notar-fallback for it and skip every unvoted slot of the window.

• ALPENGLOW_VOTE_REASON_SAFE_TO_SKIP = 7

  No block can be fast-finalized in the slot: skip votes plus notar votes for every block but the most-voted one reach 40% of stake (Definition 16). Having voted notar in the slot, we vote skip-fallback for it and skip every unvoted slot of the window.

• ALPENGLOW_VOTE_REASON_REWARD = 8

  Our notar or skip vote sent to the leader of slot+8, who packs the slot's reward cert, apart from the broadcast, and resent every probe timeout until that leader acknowledges it or we replay slot+8.

• ALPENGLOW_VOTE_REASON_REWARD_ACKED = 9

  The leader of slot+8 acknowledged a packet carrying our notar or skip vote, which ends its reward resends. The row timestamp is when the acknowledgement arrived; broadcast_to is empty.

• ALPENGLOW_VOTE_REASON_REWARD_NO_CONNECTION = 10

  We are trying to cast a notar or skip vote whose reward (slot+8) leader we have no active connection to. The problematic gossip ip and port is in broadcast_to.

A block finished production, or replay on this validator, or was marked dead, or was abandoned before completing. A block gets a row if it was ever replayed or produced (had a bank), or if it finished reception on a fork that had already died or been discarded; a block dropped before reception finished gets no row. Under alpenglow, fork knowledge is much more transient, so blocks that were never replayed due to a parent getting discarded gets no row, even if reception finished. Delivery is best-effort: rows travel a lossy telemetry link, and a large burst of simultaneous rows (mass death of a fork) can drop some. On-chain data is deliberately not part of this event. Reception and repair tallies are best-effort: they restart if repair transiently stopped tracking the block (forest eviction), and on equivocated slots they are slot-scoped — shreds from all observed versions of the slot merge into the same counts on every version's row.

Used in: Event

• uint64 bank_seq = 1

  Bank sequence number, counting from 1 within a run; the join key to confirmation events. Not meaningful across restarts. 0 means no bank was ever allocated (a block completing reception under a dead or discarded lineage without ever getting a bank), leaving nothing to join on bank_seq; any forward confirmations for such a block join on slot and block_id. The boot bank (bank_seq 1) emits confirmation events but no block_completed row.

• uint64 bank_idx = 2

  Bank pool index the block was tracked under: the identifier log lines print. Instance-local and recycled across blocks within a run; correlate with logs only within one validator instance and time window. Reported whenever a bank existed (any row with nonzero bank_seq). The *_fork_id and cost_tracker_pool_idx columns are debug identifiers with the same scope, reported as held when the row was emitted, and 0 unless the block began replay or production (preparation_begin_time set).

• uint32 txncache_fork_id = 3

  Transaction cache fork handle held by the bank. See bank_idx for scope.

• uint64 progcache_fork_id = 4

  Program cache fork handle held by the bank. See bank_idx for scope.

• uint32 accdb_fork_id = 5

  Account database fork handle held by the bank. See bank_idx for scope.

• uint64 vote_stakes_fork_id = 6

  Vote stakes fork handle held by the bank. See bank_idx for scope.

• uint32 collector_overrides_fork_id = 7

  Deprecated collector overrides fork handle. Always 0.

• uint32 stake_rewards_fork_id = 8

  Stake rewards fork handle held by the bank. See bank_idx for scope.

• uint32 epoch_credits_fork_id = 9

  Epoch credits fork handle held by the bank. See bank_idx for scope.

• uint32 stake_delegations_fork_id = 10

  Stake delegations fork handle held by the bank. See bank_idx for scope.

• uint64 cost_tracker_pool_idx = 11

  Cost tracker pool index the bank held: snapshotted just before the freeze releases it on completed rows, read live on dead and abandoned rows; 0 if the block never began replay or production. See bank_idx for scope.

• uint64 slot = 12

  Slot number of the block.

• uint64 epoch = 13

  Epoch containing the slot.

• uint64 parent_slot = 14

  Slot number of the parent block. 0 if the parent was no longer locally known when the row was emitted; on genesis-booted clusters, 0 is also the genuine parent slot of blocks chaining directly off genesis.

• uint64 root_slot = 15

  Finalized root slot when the row was emitted.

• uint64 storage_slot = 16

  Lowest slot still held in memory when the row was emitted.

• uint64 turbine_slot = 17

  Highest slot observed in completed FEC sets from the network (own leader blocks excluded) when the row was emitted: the validator's estimate of the cluster tip. Minus slot: how far behind this row was - 0 to 2 in steady state, large during boot catch-up and while racing back after any stall, re-detecting mid-run lag that caught_up cannot. 0 before any shred has been observed.

• bool caught_up = 18

  Whether the validator considered itself caught up to the cluster when the row was emitted. False from boot until replay closes on the network tip (set immediately for genesis bootstrap); never cleared within a run.

• uint64 fork_width = 19

  Number of forks executing concurrently when the row was emitted. 1 in calm operation; higher values mark fork storms, explaining replay contention, evictions, and prune bursts on the rows that suffered them.

• bool snapshot_in_progress = 20

  Whether this validator was writing a snapshot when the row was emitted; snapshot creation periodically stalls replay, so timing outliers on these rows are expected. Always false when snapshot creation is unsupported or disabled.

• uint64 live_bank_count = 21

  Banks allocated when the row was emitted: executing, awaiting replay, and completed or dead awaiting prune. Bank tracking pressure; blocks are evicted when this reaches the pool bound. fork_width isolates the concurrently-executing component.

• bytes block_id = 22

  Block identifier. For blocks that never completed reception (dead or abandoned early): the merkle root of the latest piece received.

• bytes parent_block_id = 23

  Block id of the parent this block chained from, recovered from the reception chain; disambiguates the parent version when the parent slot equivocated. 0 if the reception chain could not be walked to the parent: reassembly no longer tracked the block, or an abandoned leader block that shredded nothing; parent_slot can still be known on such rows.

• bytes bank_hash = 24

  Bank hash computed by replaying the block; the state commitment consensus votes on. Rows sharing slot and block_id but differing here indicate state divergence. 0 if the block never froze (dead or abandoned).

• bool dead = 25

  Whether the block was ruled invalid. Blocks merely given up on are not dead; see abandoned_reason. State accumulated before the ruling is still reported, so execution fields may be partially filled.

• BlockCompletedDeadReason dead_reason = 26

  Why the block was ruled invalid; not_dead otherwise. Blocks this validator produced are never dead: they do not go through replay's block checks. A block invalid for several independent reasons records the first one detected locally, which can differ across validators for the same block.

• uint64 dead_time = 27

  When the block was ruled invalid; 0 if not dead.

• bool abandoned = 28

  Whether this validator gave up on the block before it completed. Independent of dead: an abandoned block was not invalid. Equivalent to abandoned_reason != not_abandoned. State accumulated before abandonment is still reported, so execution fields may be partially filled.

• BlockCompletedAbandonedReason abandoned_reason = 29

  Why this validator gave up on the block before it completed; not_abandoned otherwise. Independent of dead.

• uint64 abandoned_time = 30

  When the block was abandoned; 0 if not abandoned.

• bool is_leader = 31

  Whether this validator produced the block as leader.

• uint64 first_shred_received_time = 32

  Network arrival at the shred tile of the block's first shred, stamped before signature verification. Leader blocks: when the first entry batch reached the shredding stage, before any network send. 0 if repair pruned the block before completion.

• uint64 last_shred_received_time = 33

  Network arrival of the shred that made the block contiguous; not necessarily the highest-numbered shred. Minus first_shred_received_time: reception duration, valid only when this is nonzero. Leader blocks: when the final entry batch reached the shredding stage. 0 if the block never became fully contiguous (dead or abandoned mid-reception) or repair pruned it before completion.

• uint64 first_repair_request_time = 34

  First repair request for a specific missing shred (window request); highest-shred and orphan requests do not stamp this, so it can be 0 while their request counts are not. 0 if no window request was sent or repair pruned the block; always 0 for leader blocks.

• uint64 last_repair_received_time = 35

  Arrival of the last repair response matched to an outstanding specific-shred request; shreds from highest-shred and orphan responses do not stamp this. 0 if none was matched or repair pruned the block; always 0 for leader blocks.

• uint64 first_fec_set_received_time = 36

  When the block's first complete FEC set reached replay, after verification and reassembly. Minus first_shred_received_time: internal pipeline latency from network to replay, valid only when both are nonzero. Leader blocks: when the block's own first FEC set returned to replay through reassembly; follows rather than precedes preparation_begin_time, since production shreds the block as it goes. 0 if no bank was ever allocated, and on abandoned leader blocks whose first FEC set had not returned through reassembly when production was abandoned.

• uint64 preparation_begin_time = 37

  When replay began setting up the block's execution state: cloning from the parent and applying start-of-block updates (epoch boundary processing, fee and rent state). Follows first_fec_set_received_time on replayed blocks; leader blocks reverse that order (see that field). Gap to first_transaction_scheduled_time: setup cost, which for leader blocks includes waiting for pack to schedule the first transaction; valid only when first_transaction_scheduled_time is nonzero. 0 if the block was dropped before setup.

• uint64 first_transaction_scheduled_time = 38

  When replay dispatched the block's first transaction to an execution tile. Leader blocks: when an execution tile began the first packed transaction. Execution and verification run from here to last_transaction_finished_time; equal to it if the block executed no transactions or, for leader blocks, if production timing was unavailable (see txn_timing). 0 on dead and abandoned rows if no transaction was ever dispatched.

• uint64 last_transaction_finished_time = 39

  When the block became fully executed and verified and end-of-block processing began: all execution and signature-verification results returned, the final FEC set received, PoH verified. At the live tip this trails the last execution result by trailing-tick reception and verification; per-transaction results are txn_timing.replayed_time. Leader blocks: when the block was fully produced (final PoH hash received, block id returned through reassembly), trailing the last execution result by the PoH tail and final-entry shredding, most visibly when a limit ended the block early. 0 if the block never finished executing (dead or abandoned).

• uint64 block_completed_time = 40

  When end-of-block processing finished and the block froze: state hashing complete, no further changes. Minus last_transaction_finished_time: finalization cost. 0 if the block never completed (dead or abandoned).

• uint64 parent_block_completed_time = 41

  The parent's block_completed_time, denormalized to avoid a self-join; for blocks chaining directly off the snapshot or genesis boot bank, when the boot bank finished loading. 0 if the parent's completion was never observed: parent untracked, or parent never froze (dead or abandoned lineage). Slot-time queries (block_completed_time minus this) should filter on caught_up, parent_slot = slot - 1, and a nonzero value here.

• uint64 fec_set_count = 42

  Number of FEC sets in the block; for blocks that never completed reception, the number delivered to replay when the row was emitted. 0 if reassembly no longer tracked the block when the row was emitted.

• uint32 data_shred_count = 43

  Data shreds received or recovered. Leader blocks: shreds produced. 0 if repair pruned the block before completion.

• uint32 parity_shred_count = 44

  Parity (recovery) shreds received. Near 0 for leader blocks: only network echoes of the block's own parity shreds land here. 0 if repair pruned the block before completion.

• uint32 turbine_shred_count = 45

  Shreds received over the network via turbine, plus repair deliveries whose provenance could not be verified (failed nonce) and coding shreds arriving in repair responses (nonconformant: repair serves only data shreds). Pieces cleared and re-fetched after a wrong-version detection or eviction count once per delivery, so source tallies can exceed the block's shred counts. Near 0 for leader blocks. 0 if repair pruned the block before completion.

• uint32 repair_shred_count = 46

  Shreds obtained from peers via repair; nonce-verified deliveries only. Re-fetched pieces count once per delivery (see turbine_shred_count). Always 0 for leader blocks. 0 if repair pruned the block before completion.

• uint32 recovered_shred_count = 47

  Shreds reconstructed locally from parity data. Re-recovered pieces count once per recovery (see turbine_shred_count). Always 0 for leader blocks, which produce rather than recover their shreds. 0 if repair pruned the block before completion.

• bool chain_confirmed = 48

  Whether every FEC set was verified to chain back to the confirmed block identity, i.e. the assembled data matches the block the cluster confirmed. Verification is confirmation-triggered and the value is snapshotted at the block's last received FEC set, so false means it had not run by then, not that it failed; at the live tip confirmation usually arrives later. Always false under alpenglow. True mainly when confirmation precedes reception completing, e.g. during catch-up. See lowest_verified_fec_index.

• uint32 lowest_verified_fec_index = 49

  Lowest FEC set index reached by chain verification as of the block's last received FEC set; the walk anchors at the confirmed block identity and works backwards. 0 means the whole block verified. 4294967295 means no verification information (verification never ran, or repair pruned the block); not a FEC index. Always 0 under alpenglow.

• uint32 last_completed_fec_set_index = 50

  FEC set index of the last piece of the block to complete reception, which with out-of-order repair need not be the block's final index. 4294967295 when the reception statistics are unpopulated; not a FEC index.

• bool slot_complete_flag = 51

  Whether the shred marking the block complete was received. False if repair pruned the block before completion.

• bool equivocation_detected_shred = 52

  Whether any of the block's FEC sets was ever quarantined by an equivocation hold: set when a conflicting version of a FEC set was assembled at that position, and inherited by everything chaining onto or arriving during an unresolved conflict, including from ancestor slots; persists after resolution. A lone conflicting shred discarded before reassembly does not register. False if reassembly no longer tracked the block when the row was emitted.

• uint32 repair_requests_retransmitted = 53

  Repair requests re-sent after a response timeout. Always 0 for leader blocks. 0 if repair pruned the block before completion.

• uint32 repair_responses_received = 54

  Repair responses matched to an outstanding specific-shred request. Shreds delivered by verified highest-shred and orphan responses count in repair_shred_count but are not matched here, so this can be 0 while repair_shred_count is not. Always 0 for leader blocks. 0 if repair pruned the block before completion.

• uint32 repair_request_window_count = 55

  Repair requests for one specific missing shred, by index. Always 0 for leader blocks. 0 if repair pruned the block before completion.

• uint32 repair_request_highest_window_count = 56

  Repair requests for the highest-numbered shred a peer holds, used to learn the block's length. Highest-shred requests seeded at boot, before the block was tracked, bypass this counter. Always 0 for leader blocks. 0 if repair pruned the block before completion.

• uint32 repair_request_orphan_count = 57

  Repair requests for the block's ancestry when its parent is unknown; a response carries shreds from up to 11 ancestor blocks. Always 0 for leader blocks. 0 if repair pruned the block before completion.

• bool repair_failed_chain_verify = 58

  Whether chain verification against the confirmed block identity found a mismatched (wrong-version) FEC held for this block; the piece was cleared and re-repaired, but may have arrived by any route, turbine included. Always false for leader blocks and under alpenglow. False if repair pruned the block before completion.

• uint64 cost_tracker_block_cost = 59

  Compute units used by all transactions, votes included; the vote/non-vote split is not part of this event. 0 if no cost tracker existed for the block (never prepared for replay, or no bank).

• uint64 cost_tracker_allocated_accounts_data_size = 60

  New account data allocated, in bytes. 0 if no cost tracker existed for the block.

• uint64 cost_tracker_block_cost_limit = 61

  Block compute unit limit. 0 if no cost tracker existed for the block (never prepared for replay, or no bank).

• uint64 cost_tracker_vote_cost_limit = 62

  Deprecated runtime vote compute unit limit. Always 0.

• uint64 cost_tracker_account_cost_limit = 63

  Per-account compute unit limit. 0 if no cost tracker existed for the block.

• uint64 became_leader_time = 64

  When replay began block production for the slot, all prerequisites (e.g. parent block identity) in hand. Minus leader_slot_start_time: local production start delay. 0 for blocks this validator did not produce.

• uint64 leader_slot_start_time = 65

  When the leader slot was scheduled to begin, estimated locally by projecting slot durations from the reset onto the parent fork; embeds upstream lateness rather than tracking a cluster-absolute timeline. 0 for blocks this validator did not produce.

• uint64 pack_start_time = 66

  When block production began. 0 for blocks this validator did not produce.

• uint64 pack_end_time = 67

  When block production ended. 0 for blocks this validator did not produce.

• uint64 microblock_count = 68

  Microblocks pack scheduled during production. A microblock whose transactions all failed execution is skipped at PoH mixin and absent from the block, so this can exceed block content. 0 for blocks this validator did not produce.

• uint64 pack_block_cost = 69

  Compute units pack reserved while building the block, votes included. Reservations are refunded as transactions finish, so this can exceed cost_tracker_block_cost (the charged amount) by refunds unsettled at slot end. 0 for blocks this validator did not produce.

• uint64 pack_vote_cost = 70

  Deprecated (0) since Firedancer v26.11.

• uint64 pack_data_bytes = 71

  Bytes pack's cost model reserved for block content: transaction payloads plus a 48-byte header per microblock, net of rebates settled by slot end. Excludes tick entries; can exceed the block's actual content by rebates unsettled at slot end. A size, not a compute measure. 0 for blocks this validator did not produce.

• BlockCompletedPackEndReason pack_end_reason = 72

  Why block production stopped; not_leader for blocks this validator did not produce.

• uint64 bundle_txn_count = 73

  Bundled transactions pack scheduled during production, counted whether or not the bundle survived to the block (aborted bundles are skipped at PoH mixin). 0 for blocks this validator did not produce.

• repeated BlockCompletedTxnTiming txn_timing = 74

  Per-transaction timestamps, one entry per transaction in block order. Replayed blocks: stamped by the replay scheduler. Leader blocks: stamped by the production pipeline. Columns exclusive to the other path are 0. Empty on dead and abandoned replay rows; an abandoned leader block reports the transactions mixed into the block before production was abandoned. Otherwise best-effort: empty when no capture slot was free (more than 16 blocks replaying at once) or the production timing table was unavailable. Empty does not mean the block had no transactions.

• bool votor_repaired = 75

  Whether the block reached replay after a votor event named that block and we repaired that version, rather than through the version received over turbine. Always false before alpenglow, and false for blocks this validator produced as leader. A slot can report both, on separate rows.

• uint32 repair_request_shred_block_id_count = 76

  Alpenglow ShredForBlockId requests, analogous to legacy window requests. Asks a peer for a specific missing shred, addressed by the block id it belongs to. Always 0 before alpenglow and for leader blocks.

• uint32 repair_request_parent_count = 77

  Alpenglow ParentAndFecCount requests, analogous to legacy orphan requests. Asks a peer for the block's parent and its FEC set count. Always 0 before alpenglow and for leader blocks.

• uint32 repair_request_fec_root_count = 78

  Alpenglow FecRoot requests: asks a peer for a FEC set's merkle root for a specified FEC set index. Always 0 before alpenglow and for leader blocks.

Why this validator gave up on the block before it completed; not_abandoned otherwise. Independent of dead.

Used in: BlockCompleted

• BLOCK_COMPLETED_ABANDONED_REASON_UNSPECIFIED = 0

• BLOCK_COMPLETED_ABANDONED_REASON_NOT_ABANDONED = 1

  Not abandoned; the block completed or was ruled invalid.

• BLOCK_COMPLETED_ABANDONED_REASON_PRUNED = 2

  A block on another fork was rooted, discarding this fork before replay finished.

• BLOCK_COMPLETED_ABANDONED_REASON_EVICTED = 3

  Dropped for lack of room to track in-progress blocks. The row is emitted once the block's in-flight verification has drained without ruling it invalid; a block ruled invalid while draining emits a dead row instead. May be replayed later, producing a second row for the same slot and block id under a new bank_seq; the retry usually completes but can itself end dead, evicted, or pruned. Blocks evicted after freezing already emitted a completed row and emit nothing further. Dedup on slot and block_id, keeping the highest bank_seq.

• BLOCK_COMPLETED_ABANDONED_REASON_RESET = 4

  Production of this leader block was abandoned mid-slot: consensus reset block production onto another fork before the slot completed. Only on blocks this validator produced; pack_end_reason is abandoned on the same row. The partial block never finished shredding, so block_id holds the merkle root of the last piece that had returned through reassembly when production was abandoned (may trail the last piece actually shredded), or 0 if none had.

• BLOCK_COMPLETED_ABANDONED_REASON_REPARENTED = 5

  Prefix of a block we executed before detecting an UpdateParent marker. The prefix execution is abandoned, and the block execution after the UpdateParent marker shows up as new row.

Why the block was ruled invalid; not_dead otherwise. Blocks this validator produced are never dead: they do not go through replay's block checks. A block invalid for several independent reasons records the first one detected locally, which can differ across validators for the same block.

Used in: BlockCompleted

• BLOCK_COMPLETED_DEAD_REASON_UNSPECIFIED = 0

• BLOCK_COMPLETED_DEAD_REASON_NOT_DEAD = 1

  Not ruled invalid.

• BLOCK_COMPLETED_DEAD_REASON_PARENT_DEAD = 2

  The block went down with its lineage: an ancestor was ruled invalid, so this block cannot be replayed.

• BLOCK_COMPLETED_DEAD_REASON_UNPARSEABLE_CONTENT = 3

  Bytes at the head of the stream failed to parse as any structure (transaction, microblock header, or count) within the largest size a valid block allows: malformed content.

• BLOCK_COMPLETED_DEAD_REASON_SHORT_BLOCK = 4

  Block bytes ended short of the microblocks and transactions declared.

• BLOCK_COMPLETED_DEAD_REASON_TRAILING_ENTRY = 5

  Block did not end on a tick; a transaction entry trailed the final tick. Checked before tick-count verification, so a block Agave rules TooFewTicks can report trailing_entry here.

• BLOCK_COMPLETED_DEAD_REASON_TOO_MANY_MICROBLOCKS = 6

  More microblocks than a valid block can hold.

• BLOCK_COMPLETED_DEAD_REASON_TICK_HASHES_OVERFLOW = 7

  More hashes since the last tick than hashes per tick allows, detected at tick verification.

• BLOCK_COMPLETED_DEAD_REASON_TICK_HASHES_OVERFLOW_INGEST = 8

  A microblock header declared more hashes than fit before the next tick, detected at FEC ingest.

• BLOCK_COMPLETED_DEAD_REASON_INCONSISTENT_TICK_HASHES = 9

  A tick's hash count differs from the block's preceding ticks, detected at FEC ingest.

• BLOCK_COMPLETED_DEAD_REASON_ZERO_HASH_TICK = 10

  A tick advanced zero hashes, detected at tick verification because proof-of-history parameters were unknown when the tick parsed.

• BLOCK_COMPLETED_DEAD_REASON_ZERO_HASH_TICK_INGEST = 11

  A tick advanced zero hashes, detected at FEC ingest.

• BLOCK_COMPLETED_DEAD_REASON_ZERO_MICROBLOCKS = 12

  A batch header declared zero microblocks.

• BLOCK_COMPLETED_DEAD_REASON_TOO_MANY_TXNS = 13

  More transactions than a valid block can hold.

• BLOCK_COMPLETED_DEAD_REASON_TOO_MANY_TICKS = 14

  More ticks than allowed.

• BLOCK_COMPLETED_DEAD_REASON_WRONG_HASHES_PER_TICK = 15

  Tick hash count did not advance the expected hashes per tick.

• BLOCK_COMPLETED_DEAD_REASON_TOO_FEW_TICKS = 16

  Fewer ticks than required.

• BLOCK_COMPLETED_DEAD_REASON_TICK_HASH_MISMATCH = 17

  Proof-of-history hash of a tick did not verify.

• BLOCK_COMPLETED_DEAD_REASON_ENTRY_HASH_MISMATCH = 18

  Proof-of-history hash of a transaction entry did not verify, detected when the entry's hashing task completed.

• BLOCK_COMPLETED_DEAD_REASON_ENTRY_HASH_MISMATCH_INGEST = 19

  Proof-of-history hash of a transaction entry did not verify, detected at FEC ingest when a later FEC set completed the entry's transactions.

• BLOCK_COMPLETED_DEAD_REASON_SIGVERIFY_FAILED = 20

  A transaction failed signature verification.

• BLOCK_COMPLETED_DEAD_REASON_TXN_FAILED_TO_LOAD = 21

  A transaction failed a pre-execution check: already processed, expired or unknown recent blockhash, address lookup table resolution failure, account lock limit, compute budget error, unsupported transaction version or sanitization failure, or fee-payer validation failure.

• BLOCK_COMPLETED_DEAD_REASON_BLOCK_COST_LIMIT = 22

  A transaction pushed the block over its compute limit.

• BLOCK_COMPLETED_DEAD_REASON_ACCOUNT_COST_LIMIT = 23

  A transaction pushed one account over its per-block compute limit.

• BLOCK_COMPLETED_DEAD_REASON_VOTE_COST_LIMIT = 24

  A vote transaction pushed the block over its vote compute limit.

• BLOCK_COMPLETED_DEAD_REASON_ACCOUNT_DATA_LIMIT = 25

  A transaction pushed the block over its account data size limit.

• BLOCK_COMPLETED_DEAD_REASON_DUPLICATE_ACCOUNT = 26

  A transaction referenced the same account more than once.

• BLOCK_COMPLETED_DEAD_REASON_BAD_FOOTER = 27

  An Alpenglow block's footer could not be applied or declared a bank hash that did not match execution.

• BLOCK_COMPLETED_DEAD_REASON_ALPENGLOW_HASH_CNT = 28

  An Alpenglow block had an entry whose hash count was not exactly one.

• BLOCK_COMPLETED_DEAD_REASON_MISSING_PARENT_MARKER = 29

  An Alpenglow block carried an entry batch or footer before any block header.

• BLOCK_COMPLETED_DEAD_REASON_MULTIPLE_BLOCK_HEADERS = 30

  An Alpenglow block carried more than one block header.

• BLOCK_COMPLETED_DEAD_REASON_GENESIS_CERT_OUT_OF_ORDER = 31

  An Alpenglow genesis certificate marker did not immediately follow the block header.

• BLOCK_COMPLETED_DEAD_REASON_MULTIPLE_BLOCK_FOOTERS = 32

  An Alpenglow block carried more than one block footer.

• BLOCK_COMPLETED_DEAD_REASON_ENTRY_AFTER_BLOCK_FOOTER = 33

  An Alpenglow block carried an entry batch other than the alpentick after its footer.

• BLOCK_COMPLETED_DEAD_REASON_INVALID_ALPENTICK_POSITION = 34

  An Alpenglow block ended without the alpentick directly after its footer.

• BLOCK_COMPLETED_DEAD_REASON_MISSING_BLOCK_FOOTER = 35

  An Alpenglow block ended without a block footer.

• BLOCK_COMPLETED_DEAD_REASON_SPURIOUS_UPDATE_PARENT = 36

  An Alpenglow block started on a UpdateParent marker, or found one after its footer.

• BLOCK_COMPLETED_DEAD_REASON_BAD_BLOCK_MARKER = 37

  An Alpenglow block marker (header, footer, genesis certificate or update parent) failed to parse or had an unknown kind.

• BLOCK_COMPLETED_DEAD_REASON_TOO_MANY_WRITABLE_ACCOUNTS = 38

  The block's transactions declare more writable accounts than a valid block can afford.

• BLOCK_COMPLETED_DEAD_REASON_MULTIPLE_UPDATE_PARENTS = 39

  An Alpenglow block carried more than one UpdateParent marker.

• BLOCK_COMPLETED_DEAD_REASON_UPDATE_PARENT_MISMATCH = 40

  An Alpenglow block's initial UpdateParent named a parent other than the one replay built it on.

Why block production stopped; not_leader for blocks this validator did not produce.

Used in: BlockCompleted

• BLOCK_COMPLETED_PACK_END_REASON_UNSPECIFIED = 0

• BLOCK_COMPLETED_PACK_END_REASON_NOT_LEADER = 1

  Not produced by this validator.

• BLOCK_COMPLETED_PACK_END_REASON_TIME = 2

  The leader slot's time window ended, the normal case. Blocks that filled a consensus limit also end here; measure saturation via pack_block_cost and pack_data_bytes against the protocol caps.

• BLOCK_COMPLETED_PACK_END_REASON_MICROBLOCK_LIMIT = 3

  Microblock count limit reached.

• BLOCK_COMPLETED_PACK_END_REASON_ABANDONED = 4

  Production was abandoned mid-slot by a reset onto another fork; only on abandoned leader blocks (abandoned_reason reset). Pack ends the block early and its summary rides on the terminating message, so microblock_count, pack costs, pack timings, and bundle_txn_count reflect what was produced before the abandonment.

Timestamps for one transaction. A zero timestamp means the stage did not occur on this path, was never reached, or its stamp was unavailable.

Used in: BlockCompleted

• uint64 received_time = 1

  Earliest time attributable to the transaction. Replayed blocks: network arrival of the shred completing the FEC set carrying the transaction; gap to parsed_time is the internal latency to parse. Leader blocks: entry into this validator — TPU network arrival, block engine receipt (bundles), gossip receipt (votes), or creation time (self-originated).

• uint64 parsed_time = 2

  When the scheduler parsed the transaction out of received data, including address lookup table resolution. Gap from received_time covers the pipeline hop, in-order delivery waits, and parse position within the FEC set. 0 for leader blocks.

• uint64 dispatched_time = 3

  Replayed blocks: when the scheduler handed the transaction to an execution tile. Leader blocks: when an execution tile began executing it; transactions of one bundle share the stamp.

• uint64 replayed_time = 4

  Replayed blocks: when the scheduler received the execution result, including the return hop and replay's polling delay, not only execution. Leader blocks: when execution finished and results were committed to the block's state.

• uint64 sigverify_dispatched_time = 5

  When the scheduler dispatched signature verification, which runs in parallel with execution. 0 for leader blocks (verified upstream of pack).

• uint64 sigverify_done_time = 6

  When the signature verification result returned to the scheduler. 0 for leader blocks.

• uint64 poh_mixed_time = 7

  When the transaction was mixed into the PoH stream, fixing its position in the block; transactions of one microblock share the stamp. 0 for blocks this validator did not produce.

Two different blocks (different block ids) were observed for the same slot. Emitted once when the validator first detects the equivocation, after both blocks are known.

Used in: Event

• uint64 bank_seq = 1

  Sequence number of this validator's replayed block, joining to block_completed; zero if there is no local replayed bank (forward-confirmed or shred-proof detection).

• uint64 slot = 2

  The slot that equivocates (has more than one block).

• uint64 parent_slot = 3

  The slot number of the parent block.

• uint64 epoch = 4

  The epoch this slot belongs to.

• bytes block_id = 5

  Identifier of the block this validator replayed for the slot.

• bytes sibling_block_id = 6

  Identifier of the conflicting block for the same slot; zero if not known (shred-proof detection).

• bytes bank_hash = 7

  This validator's bank hash for the block it replayed; zero if the block was not replayed locally.

• bytes block_hash = 8

  Last microblock header hash of the block this validator replayed; zero if not replayed locally.

• bool is_leader = 9

  Whether this validator produced the equivocating block it replayed.

• bool our_block_voted = 10

  Whether this validator had voted for its replayed block when the equivocation was detected.

• bool our_block_confirmed = 11

  Whether this validator's replayed block had been duplicate confirmed when the equivocation was detected.

• uint64 block_stake = 12

  Stake in lamports voted on the block this validator replayed at detection; zero if none/unknown. Typically small, as an equivocating block usually did not win confirmation.

• uint64 sibling_stake = 13

  Stake in lamports on the conflicting (typically confirmed) block at detection; zero if not known.

• uint64 total_stake = 14

  Total cluster stake in lamports at detection; the denominator for the stake fields. Zero if not known.

• BlockEquivocatedDetection detection = 15

  How the equivocation was detected.

How the equivocation was detected.

Used in: BlockEquivocated

• BLOCK_EQUIVOCATED_DETECTION_UNSPECIFIED = 0

• BLOCK_EQUIVOCATED_DETECTION_DUPLICATE_REPLAY = 1

  A second, different block for the slot finished replaying locally.

• BLOCK_EQUIVOCATED_DETECTION_CONFIRM_MISMATCH = 2

  Votes confirmed a block id for the slot that differs from the one this validator replayed.

• BLOCK_EQUIVOCATED_DETECTION_SHRED_PROOF = 3

  A duplicate-shred proof showed the slot equivocates; the conflicting block id is not known, so sibling_block_id is zero.

A block that completed reception on this validator or was abandoned and pruned. A block gets a row if it received a shred marked as final in the slot, and received all shreds up to the final shred, or if it was incomplete but collected later during pruning. Tallies are best-effort: on equivocated slots, shreds shared between versions of the slot may merge or double count. Delivery is best-effort: rows travel a lossy telemetry link, so a block_completed row can arrive without its block_received row or vice versa.

Used in: Event

• uint64 slot = 1

  Slot number of the block.

• bytes block_id = 2

  Block identifier; with slot, the alternate join key to block_completed. For blocks that never completed reception (or were abandoned early), this can be the null hash.

• uint64 parent_slot = 3

  Slot number of the block's parent. If unknown, this will be UINT64_MAX, and likely means that a block header could not be parsed for this slot.

• bytes parent_block_id = 4

  Block identifier of the block's parent. If unknown, this will be the null hash, and likely means that a block header could not be parsed for this slot.

• bool cancelled = 5

  Whether the block was cancelled due to a notar version becoming known. These blocks will only get reported if they are eventually pruned, so if the root does not advance, they will not be reported.

• BlockReceivedCancelledReason cancelled_reason = 6

  The reason the block was no longer attempted to be repaired.

• uint64 cancelled_time = 7

  When the block was cancelled. Only turbine versions are cancelled. Occurs when a votor-driven version of the slot arrives while this version's block id is still unknown, or for invalid turbine blocks. 0 if not cancelled.

• bool notarized = 8

  Either reached SafeToNotar locally or attached to a NotarFallback or stronger cert, rather than being the version received over turbine. Always false for blocks this validator produced as leader. A slot can report both a notarized and a non-notarized version, on separate rows.

• bool is_leader = 9

  Whether the block was produced as leader.

• bool caught_up = 10

  Whether the validator considered itself caught up to the cluster when the row was emitted. False from boot until repair closes on the network tip (set immediately for genesis bootstrap); otherwise during regular operation is set to True if the highest slot the validator has received completely is no more than one leader window behind its view of the current cluster slot.

• uint64 fec_set_count = 11

  Number of FEC sets in the block; for blocks that never completed reception, this could be 0 if the shred with the slot_complete flag never arrived.

• uint64 first_shred_received_time = 12

  Network arrival at the shred tile of the block's first shred, stamped before signature verification. Leader blocks: when the first entry batch reached the shredding stage, before any network send.

• uint64 last_shred_received_time = 13

  Network arrival of the shred that made the block contiguous; not necessarily the highest-numbered shred. Minus first_shred_received_time: reception duration, valid only when this is nonzero. Leader blocks: when the final entry batch reached the shredding stage. 0 if the block never became fully contiguous (pruned or abandoned mid-reception).

• uint64 first_repair_request_time = 14

  First repair request for a specific missing shred (window or ShredForBlockId request); highest-shred, orphan, ParentAndFecCount and FecRoot requests do not stamp this, so it can be 0 while their request counts are not. 0 if no window or ShredForBlockId request was sent; always 0 for leader blocks.

• uint64 last_repair_received_time = 15

  Network arrival at the shred tile of the last repair response matched to an outstanding specific-shred request; other responses do not stamp this. 0 if none was matched; always 0 for leader blocks.

• uint64 first_meta_received_time = 16

  Network arrival at the repair tile of the block's first verified getParentAndFecCount or FecRoot response, including a FecRoot answer for a FEC set already held. 0 if no verified metadata response was received.

• uint32 turbine_shred_received = 17

  Shreds received over the network via turbine, plus repair deliveries whose provenance could not be verified (failed nonce) and coding shreds. Near 0 for leader blocks.

• uint32 parity_shred_received = 18

  Parity (recovery) shreds received. Near 0 for leader blocks: only network echoes of the block's own parity shreds land here.

• uint32 repair_shred_received = 19

  Shreds obtained from peers via repair; nonce-verified deliveries only. Re-fetched pieces count once per delivery. Always 0 for leader blocks.

• uint32 recovered_shred_count = 20

  Shreds reconstructed locally from parity data. Always 0 for leader blocks, which produce rather than recover their shreds.

• uint32 last_completed_fec_set_index = 21

  FEC set index of the last piece of the block to complete Reed-Solomon reconstruction, which with out-of-order repair need not be the block's final index. UINT32_MAX if no FEC set was completed.

• bool slot_complete = 22

  Whether the shred marking the block complete was received, or it became known through a getParentAndFecCount request.

• bool equivocation_detected_shred = 23

  Whether equivocating shreds were detected on this slot before any notarized version arrived.

• uint32 repair_shred_responses_received = 24

  Repair responses matched to an outstanding specific-shred request. Shreds delivered by verified highest-shred and orphan responses count in repair_shred_received but are not matched here, so this can be 0 while repair_shred_received is not. Always 0 for leader blocks.

• uint32 parent_fec_count_responses_received = 25

  Metadata responses matched to an outstanding getParentAndFecCount request that pass proof-check.

• uint32 fec_root_responses_received = 26

  Metadata responses matched to an outstanding FecRoot request that pass proof-check.

• uint32 repair_request_window_count = 27

  Repair requests for one specific missing shred, by index. Always 0 for leader blocks.

• uint32 repair_request_highest_window_count = 28

  Repair requests for the highest-numbered shred a peer holds, used to learn the block's length. Highest-shred requests seeded at boot, before the block was tracked, bypass this counter. Always 0 for leader blocks.

• uint32 repair_request_orphan_count = 29

  Repair requests for the block's ancestry when its parent is unknown; a response carries shreds from up to 11 ancestor blocks. Always 0 for leader blocks.

• uint32 repair_request_shred_for_block_id_count = 30

  Alpenglow ShredForBlockId requests, analogous to legacy window requests. Asks a peer for a specific missing shred, addressed by the block id it belongs to. Always 0 before Alpenglow and for leader blocks.

• uint32 repair_request_parent_fec_count = 31

  Alpenglow ParentAndFecCount requests, analogous to legacy orphan requests. Asks a peer for the block's parent and its FEC set count. Always 0 before Alpenglow and for leader blocks.

• uint32 repair_request_fec_root_count = 32

  Alpenglow FecRoot requests. Asks a peer for the merkle root of the FEC set at a given index. Always 0 before Alpenglow and for leader blocks.

• repeated BlockReceivedFecSets fec_sets = 33

  Per-FEC-set reception detail, one entry per FEC set in block order: which pieces made up the block, how each arrived, and when. Summed, the counts may reconcile with the block-level shred counts on this row, except in the case of equivocation where FEC sets may be shared between versions of the slot. Best-effort for pruned incomplete blocks: empty does not mean the block had no FEC sets, but that the FEC may have been pruned before it was able to be reported.

The reason the block was no longer attempted to be repaired.

Used in: BlockReceived

• BLOCK_RECEIVED_CANCELLED_REASON_UNSPECIFIED = 0

• BLOCK_RECEIVED_CANCELLED_REASON_NOT_CANCELLED = 1

  Not cancelled.

• BLOCK_RECEIVED_CANCELLED_REASON_MERKLE_ROOT_MISMATCH = 2

  Received two merkle roots for the same FEC set.

• BLOCK_RECEIVED_CANCELLED_REASON_NOTARIZED_VERSION = 3

  A verified version of the block became known.

• BLOCK_RECEIVED_CANCELLED_REASON_VERIFIED_PARENT = 4

  A verified version of a verified block's parent became known.

• BLOCK_RECEIVED_CANCELLED_REASON_PARENT_OFF_MISMATCH = 5

  A data shred's parent_off disagreed with the slot's other shreds or with its block header.

• BLOCK_RECEIVED_CANCELLED_REASON_INVALID_BLOCK_HEADER = 6

  Shred 0 did not carry a valid block header.

• BLOCK_RECEIVED_CANCELLED_REASON_SLOT_COMPLETE_MISMATCH = 7

  A data shred's slot complete flag disagreed with the slot's other shreds.

• BLOCK_RECEIVED_CANCELLED_REASON_INVALID_UPDATE_PARENT = 8

  An UpdateParent marker broke a rule: not in the first slot of its leader window, a second UpdateParent, a parent below the root or newer than the header's, a null parent block id, or naming the header's own parent.

Reception detail for one FEC set. A zero timestamp means the stage was never reached or its stamp was unavailable.

Used in: BlockReceived

• bytes merkle_root = 1

  Merkle root of the FEC set: its identity. The final FEC set's merkle root is the block id.

• uint32 index = 2

  Index of the FEC set's first data shred within the block; FEC sets are listed in block order, so for a fully received block the indices ascend from 0 without gaps.

• uint32 data_shreds_received_mask = 3

  Bitmap of data shreds of the FEC set received (vs recovered). Bit j set if the data shred with data index j was received.

• uint32 parity_shreds_received_mask = 4

  Bitmap of parity shreds of the FEC set received (vs recovered). Bit j set if the parity shred with parity index j was received.

• uint32 repair_shreds_received_mask = 5

  Bitmap of data shreds of the FEC set received via repair. Bit j set if the data shred with data index j arrived via repair.

• uint32 duplicate_shred_count = 6

  Number of duplicate shreds received for this FEC set; best-effort given upstream deduplication.

• uint64 first_shred_received_time = 7

  Timestamp when the first shred of this FEC set arrived at the shred tile.

• uint64 completed_time = 8

  Timestamp when the FEC set was complete (assembled).

• BlockReceivedFecSetsFinalShredSource final_shred_source = 9

  The source of the final shred that completed the FEC set.

The source of the final shred that completed the FEC set.

Used in: BlockReceivedFecSets

• BLOCK_RECEIVED_FEC_SETS_FINAL_SHRED_SOURCE_UNSPECIFIED = 0

• BLOCK_RECEIVED_FEC_SETS_FINAL_SHRED_SOURCE_TURBINE = 1

  Received via turbine.

• BLOCK_RECEIVED_FEC_SETS_FINAL_SHRED_SOURCE_REPAIR = 2

  Received via repair.

• BLOCK_RECEIVED_FEC_SETS_FINAL_SHRED_SOURCE_LEADER = 3

  Produced as our own leader shred.

Reported once when the validator process starts. A wide fingerprint of the host, operating system, kernel, hardware, network, build, and validator configuration at launch.

Used in: Event

• bytes kernel_release = 1

  Kernel release string, such as 6.1.0-1202605170043.el9.x86_64.

• bytes kernel_version = 2

  Full kernel build version string including build date and preemption model.

• repeated string mitigations = 3

  Processor vulnerabilities for which a kernel mitigation is active; mitigations in force split performance cohorts on otherwise identical hardware. Empty when every mitigation is disabled or the hardware is unaffected.

• bytes distro_id = 4

  Short distribution identifier such as ubuntu, rhel, debian, or centos.

• bytes distro_version_id = 5

  Distribution version number, such as 22.04 or 9.4.

• bytes distro_id_like = 6

  Family of distributions this one derives from, such as debian or rhel.

• BootLibcKind libc_kind = 7

  Which system C library the validator is running against.

• bytes libc_version = 8

  Version of the system C runtime library, such as 2.34.

• BootBuildMachineTarget build_machine_target = 9

  The named hardware target the binary was compiled for, which fixes the minimum processor it can run on. Distinct from the live processor it is currently running on.

• bytes build_extras = 10

  The list of optional build features requested when the binary was compiled, such as sanitizers or coverage. Empty for a normal production build.

• bool build_git_dirty = 11

  Whether tracked files in the source tree had uncommitted changes when the binary was built, meaning the commit hash alone does not fully describe the code. Untracked files do not count.

• BootCompiler compiler = 12

  Which compiler family produced the binary.

• bytes compiler_version = 13

  The exact version of the compiler that produced the binary.

• uint64 build_timestamp = 14

  When the binary was compiled; distinguishes rebuilds of the same commit, which build_git_dirty makes common on development builds.

• repeated string build_features = 15

  Instruction set extensions the binary was compiled to use, such as avx512 or gfni; fixes the minimum processor the binary can run on and which accelerated code paths are compiled in.

• BootCpuArch cpu_arch = 16

  Processor architecture of the host.

• BootCpuVendor cpu_vendor = 17

  The maker of the processor.

• bytes cpu_model_name = 18

  The full marketing name of the processor.

• uint32 cpu_family = 19

  The processor family number identifying the broad generation of the chip.

• uint32 cpu_model_id = 20

  The numeric model identifier within the family, distinguishing specific chip designs.

• uint32 cpu_stepping = 21

  The silicon revision number of the processor, indicating minor hardware fixes within a model.

• uint64 cpu_microcode_version = 22

  The currently loaded microcode firmware revision of the processor, important because microcode updates change performance and security behavior.

• uint32 cpu_logical_count = 23

  The total number of logical processors the operating system sees, counting each hardware thread separately.

• uint32 cpu_physical_core_count = 24

  The number of physical cores across all processor sockets, ignoring hardware threads.

• uint32 cpu_socket_count = 25

  The number of physical processor packages installed in the machine.

• bool smt_active = 26

  Whether simultaneous multithreading (hyperthreading) is currently enabled on the host.

• BootCpufreqGovernor cpufreq_governor = 27

  The active frequency-scaling policy, which determines how aggressively the chip clocks up.

• BootCpufreqDriver cpufreq_driver = 28

  The kernel driver controlling processor frequency scaling.

• BootCpuEnergyPerfPreference cpu_energy_perf_preference = 29

  Energy-performance preference in force on the frequency driver; a balance profile under governor performance silently caps sustained clocks.

• BootCpuIdleDriver cpu_idle_driver = 30

  The kernel driver managing processor idle low-power states.

• bytes cpu_max_enabled_cstate = 31

  Name of the deepest processor idle state currently enabled; deeper states add wake-up latency on pinned cores.

• uint64 host_memory_bytes = 32

  Total usable physical memory detected by the kernel at boot, in bytes.

• uint64 host_memory_available_bytes = 33

  Estimate of memory available for starting new applications without swapping at boot, in bytes.

• repeated uint32 numa_cpu_to_node = 34

  For each logical processor, the memory locality domain it belongs to; joins tile placements against the locality of network and storage devices to find cross-domain pinning.

• repeated uint32 isolated_cpus = 35

  Logical processors isolated from the kernel scheduler at boot by the isolcpus= kernel parameter. Isolation by the validator's cpuset partition is not listed here; see cpuset_partition.

• repeated BootDmiDimms dmi_dimms = 36

  Per-module memory inventory: mismatched speeds clock the whole bus down, and a module differing after a swap explains a machine that got slower after maintenance.

• repeated BootNicDevices nic_devices = 37

  Inventory of physical network interfaces, each with its identity, driver, hardware location, link characteristics, queue configuration, and offload settings.

• repeated bytes nic_bond_slaves = 38

  Names of the physical member interfaces that make up the validator's bonded device.

• BootBondMode bond_mode = 39

  Bonding mode of the validator's bonded device, if bonded; kernel-bypass support and hashing behavior differ by mode.

• uint32 bound_nic_idx = 40

  Index into nic_devices of the interface bound for the kernel-bypass path, the bond master entry when bonded; 255 when the bound interface is not in the inventory.

• uint32 net_bpf_jit_enable = 41

  Whether the kernel just-in-time compiler for packet programs is enabled, which is needed for efficient kernel-bypass networking.

• bytes dmi_sys_vendor = 42

  System manufacturer of the physical machine, or the virtualization vendor when virtualized.

• bytes dmi_product_name = 43

  Model or product name of the system, or a cloud instance product string.

• bytes dmi_bios_version = 44

  Version string of the installed system firmware.

• bytes dmi_bios_date = 45

  Release date of the installed system firmware.

• bytes dmi_board_vendor = 46

  Manufacturer of the motherboard.

• bytes dmi_board_name = 47

  Model or part name of the motherboard.

• BootDmiChassisType dmi_chassis_type = 48

  Physical chassis form factor of the host.

• BootIommuMode iommu_mode = 49

  Input-output memory management unit state, which gates kernel-bypass zero-copy behavior and per-packet translation cost.

• BootHypervisorVendor hypervisor_vendor = 50

  Identity of the virtualization platform when virtualized, or none for bare metal.

• BootContainerType container_type = 51

  Whether the validator runs inside a container and which runtime, useful for distinguishing bare-metal from containerized deployments.

• bool kubernetes_pod = 52

  Whether the validator is running inside a managed orchestration pod.

• uint64 cgroup_memory_limit_bytes = 53

  Hard memory limit imposed by the control group, 0 when unlimited; the ceiling the kernel kills at.

• uint64 cgroup_memory_high_bytes = 54

  Memory throttle threshold imposed by the control group, 0 when unset; exceeding it forces reclaim stalls long before the hard limit kills.

• uint64 cgroup_swap_limit_bytes = 55

  Swap limit imposed by the control group, 0 when swap is denied to the process even though the host has swap, UInt64 max when unlimited or no limit file exists.

• uint32 cgroup_cpu_quota_millicores = 56

  Processor quota imposed by the control group in millicores, 0 when unlimited; a quota below the tile count strangles the validator.

• repeated BootBlockDevices block_devices = 57

  Inventory of storage devices, each with its identity, capacity, media type, transport, and configured input/output scheduler.

• repeated BootNvmeDevices nvme_devices = 58

  Per non-volatile express device information.

• repeated BootMdraidArrays mdraid_arrays = 59

  Per-array software storage summary.

• repeated BootFilesystems filesystems = 60

  Filesystems the validator's directories live on, one entry per distinct mount; the directory index fields below point into this array.

• uint32 accounts_fs_idx = 61

  Index into filesystems of the mount holding the accounts database; the database grows until write failures stall replay. 255 when unset or unresolved.

• uint32 snapshots_fs_idx = 62

  Index into filesystems of the mount holding the snapshots directory; download plus unpack needs roughly twice the snapshot size, and running out mid-download is a leading boot failure. 255 when unset or unresolved.

• uint32 log_fs_idx = 63

  Index into filesystems of the mount holding the log file, usually the root partition rather than the data disks. 255 when unset or unresolved.

• uint32 shredb_fs_idx = 64

  Index into filesystems of the mount holding the shred database. 255 when unset or unresolved.

• uint32 guidb_fs_idx = 65

  Index into filesystems of the mount holding the GUI database. 255 when unset or unresolved.

• bytes resolved_config_json = 66

  The full resolved validator configuration serialized as text, capturing every effective setting after defaults, overrides, and system-derived values are merged. Filesystem paths, the user and host names, bind, listen, and advertised addresses, external service URLs, and gossip entrypoints are redacted.

• bytes user_config_json = 67

  The operator's own configuration file parsed and serialized as text: only the settings they explicitly override, before defaults are merged. Values whose keys suggest paths, addresses, hosts, users, servers, or secrets are redacted.

• bytes topology_json = 68

  The full runtime topology serialized as text, capturing the complete wiring of the validator: a tiles list with each tile's kind, core assignment or floating flag, consumed and produced link lists, event link, and memory-object count; a links list, referenced from the tile link lists by position, with each link's kind, depth, message size and burst; and a workspaces list with each workspace's locality domain, page size, page count and footprint. This is the authoritative wiring fingerprint (memory-object assignments are summarized as a count); the scalar fields are derived summaries. Tile locality follows from the core assignment joined against numa_cpu_to_node. Newer builds add per tile core_shared (another concurrently running pinned tile is on the same physical core) and sibling_cpu (-1 when none).

• uint32 tile_count = 69

  Total number of tiles in the running topology.

• uint64 memory_total = 70

  Total memory the validator locks at boot: workspaces, tile stacks, and private pages.

• uint64 memory_gigantic_pages = 71

  Gigantic pages the topology requires across all memory locality domains.

• uint64 memory_huge_pages = 72

  Huge pages the topology reserves in the hugetlbfs across all memory locality domains. Tile stack pages are reserved on every domain, since stack placement is only decided when a tile starts, so they are counted once per domain.

• uint64 memory_normal_pages = 73

  Normal pages the topology requires.

• uint64 process_start_time = 74

  Wall-clock time at which the validator process itself was started.

• uint32 feature_set_id = 75

  A numeric identifier summarizing the exact set of protocol features this build understands, used to detect when nodes disagree on consensus rules.

• repeated uint32 l3_cpu_to_domain = 76

  For each logical processor, the last-level cache domain it shares (one per AMD CCD or CCX, usually one per socket on Intel), numbered from 0 in first-seen order; tiles that exchange data cheaply sit in the same domain. 65535 for an offline processor. Empty when the kernel does not expose level-3 cache topology.

• repeated string cpu_features = 77

  Instruction set extensions this processor supports, named as in build_features; one present here but missing from build_features means the binary was built for an older processor and runs slower code paths.

• repeated uint32 cpu_to_core = 78

  For each logical processor, the physical core it runs on (keyed by package and core id), numbered from 0 in first-seen order; processors sharing a value are hyperthread siblings, so tiles on them compete for one core. 65535 for an offline processor or an unreadable core id.

• repeated uint32 launch_cpus = 79

  Logical processors in the affinity the validator inherited from its launcher (taskset, systemd CPUAffinity, or a cgroup cpuset). Tiles without a core assignment run inside it; auto layout itself ignores it. Empty when it could not be read.

• BootCpusetPartition cpuset_partition = 80

  Type of the validator's cpuset partition (the cgroup named after the instance that the cpuset configure stage creates), which isolates pinned tiles from other tasks at run time.

• repeated uint32 cpuset_partition_cpus = 81

  Logical processors effectively assigned to the validator's cpuset partition. Empty when there is none.

One block storage device.

Used in: Boot

• bytes name = 1

  Kernel name of the device.

• bytes model = 2

  Model string of the device.

• uint64 capacity_bytes = 3

  Capacity of the device in bytes.

• bool rotational = 4

  Whether the device is a spinning disk rather than solid-state.

• string transport = 5

  Transport type such as the non-volatile express bus, serial bus, attached storage, or virtual.

• string scheduler = 6

  Active input/output scheduler for the device.

Bonding mode of the validator's bonded device, if bonded; kernel-bypass support and hashing behavior differ by mode.

Used in: Boot

• BOOT_BOND_MODE_UNSPECIFIED = 0

• BOOT_BOND_MODE_NONE = 1

  Not bonded.

• BOOT_BOND_MODE_ACTIVE_BACKUP = 2

  Failover bonding.

• BOOT_BOND_MODE_LACP = 3

  Link aggregation (802.3ad).

• BOOT_BOND_MODE_BALANCE_XOR = 4

  Hash-balanced bonding.

• BOOT_BOND_MODE_OTHER = 5

  Another mode.

The named hardware target the binary was compiled for, which fixes the minimum processor it can run on. Distinct from the live processor it is currently running on.

Used in: Boot

• BOOT_BUILD_MACHINE_TARGET_UNSPECIFIED = 0

• BOOT_BUILD_MACHINE_TARGET_NATIVE = 1

  native

• BOOT_BUILD_MACHINE_TARGET_LINUX_GCC_X86_64 = 2

  linux_gcc_x86_64

• BOOT_BUILD_MACHINE_TARGET_LINUX_GCC_ZEN2 = 3

  linux_gcc_zen2

• BOOT_BUILD_MACHINE_TARGET_LINUX_GCC_ZEN3 = 4

  linux_gcc_zen3

• BOOT_BUILD_MACHINE_TARGET_LINUX_GCC_ZEN4 = 5

  linux_gcc_zen4

• BOOT_BUILD_MACHINE_TARGET_LINUX_GCC_ZEN5 = 6

  linux_gcc_zen5

• BOOT_BUILD_MACHINE_TARGET_LINUX_GCC_ICELAKE = 7

  linux_gcc_icelake

• BOOT_BUILD_MACHINE_TARGET_LINUX_CLANG_X86_64 = 8

  linux_clang_x86_64

• BOOT_BUILD_MACHINE_TARGET_LINUX_CLANG_HASWELL = 9

  linux_clang_haswell

• BOOT_BUILD_MACHINE_TARGET_LINUX_CLANG_ICELAKE = 10

  linux_clang_icelake

• BOOT_BUILD_MACHINE_TARGET_LINUX_CLANG_ZEN2 = 11

  linux_clang_zen2

• BOOT_BUILD_MACHINE_TARGET_LINUX_CLANG_ZEN3 = 12

  linux_clang_zen3

• BOOT_BUILD_MACHINE_TARGET_LINUX_CLANG_ZEN4 = 13

  linux_clang_zen4

• BOOT_BUILD_MACHINE_TARGET_LINUX_CLANG_ZEN5 = 14

  linux_clang_zen5

• BOOT_BUILD_MACHINE_TARGET_OTHER = 15

  other

Which compiler family produced the binary.

Used in: Boot

• BOOT_COMPILER_UNSPECIFIED = 0

• BOOT_COMPILER_GCC = 1

  Built with gcc.

• BOOT_COMPILER_CLANG = 2

  Built with clang.

Whether the validator runs inside a container and which runtime, useful for distinguishing bare-metal from containerized deployments.

Used in: Boot

• BOOT_CONTAINER_TYPE_UNSPECIFIED = 0

• BOOT_CONTAINER_TYPE_NONE = 1

  none

• BOOT_CONTAINER_TYPE_DOCKER = 2

  docker

• BOOT_CONTAINER_TYPE_PODMAN = 3

  podman

• BOOT_CONTAINER_TYPE_CONTAINERD = 4

  containerd

• BOOT_CONTAINER_TYPE_CRI_O = 5

  cri-o

• BOOT_CONTAINER_TYPE_LXC = 6

  lxc

• BOOT_CONTAINER_TYPE_SYSTEMD_NSPAWN = 7

  systemd-nspawn

• BOOT_CONTAINER_TYPE_UNKNOWN = 8

  Unlisted or undeterminable.

Processor architecture of the host.

Used in: Boot

• BOOT_CPU_ARCH_UNSPECIFIED = 0

• BOOT_CPU_ARCH_X86_64 = 1

  x86-64

• BOOT_CPU_ARCH_ARM = 2

  ARM

• BOOT_CPU_ARCH_UNKNOWN = 3

  Unlisted or undeterminable.

Energy-performance preference in force on the frequency driver; a balance profile under governor performance silently caps sustained clocks.

Used in: Boot

• BOOT_CPU_ENERGY_PERF_PREFERENCE_UNSPECIFIED = 0

• BOOT_CPU_ENERGY_PERF_PREFERENCE_PERFORMANCE = 1

  Maximum performance bias.

• BOOT_CPU_ENERGY_PERF_PREFERENCE_BALANCE_PERFORMANCE = 2

  Default bias favoring performance.

• BOOT_CPU_ENERGY_PERF_PREFERENCE_BALANCE_POWER = 3

  Bias favoring power saving.

• BOOT_CPU_ENERGY_PERF_PREFERENCE_POWER = 4

  Maximum power saving.

• BOOT_CPU_ENERGY_PERF_PREFERENCE_DEFAULT = 5

  Driver default.

• BOOT_CPU_ENERGY_PERF_PREFERENCE_UNKNOWN = 6

  Not exposed by the driver.

The kernel driver managing processor idle low-power states.

Used in: Boot

• BOOT_CPU_IDLE_DRIVER_UNSPECIFIED = 0

• BOOT_CPU_IDLE_DRIVER_INTEL_IDLE = 1

  intel_idle

• BOOT_CPU_IDLE_DRIVER_ACPI_IDLE = 2

  acpi_idle

• BOOT_CPU_IDLE_DRIVER_NONE = 3

  none

• BOOT_CPU_IDLE_DRIVER_UNKNOWN = 4

  unknown

The maker of the processor.

Used in: Boot

• BOOT_CPU_VENDOR_UNSPECIFIED = 0

• BOOT_CPU_VENDOR_INTEL = 1

  Intel

• BOOT_CPU_VENDOR_AMD = 2

  AMD

• BOOT_CPU_VENDOR_UNKNOWN = 3

  Unlisted or undeterminable.

The kernel driver controlling processor frequency scaling.

Used in: Boot

• BOOT_CPUFREQ_DRIVER_UNSPECIFIED = 0

• BOOT_CPUFREQ_DRIVER_INTEL_PSTATE = 1

  intel_pstate

• BOOT_CPUFREQ_DRIVER_INTEL_CPUFREQ = 2

  intel_cpufreq

• BOOT_CPUFREQ_DRIVER_ACPI_CPUFREQ = 3

  acpi-cpufreq

• BOOT_CPUFREQ_DRIVER_AMD_PSTATE = 4

  amd-pstate

• BOOT_CPUFREQ_DRIVER_AMD_PSTATE_EPP = 5

  amd-pstate-epp

• BOOT_CPUFREQ_DRIVER_CPPC_CPUFREQ = 6

  cppc_cpufreq

• BOOT_CPUFREQ_DRIVER_UNKNOWN = 7

  unknown

The active frequency-scaling policy, which determines how aggressively the chip clocks up.

Used in: Boot

• BOOT_CPUFREQ_GOVERNOR_UNSPECIFIED = 0

• BOOT_CPUFREQ_GOVERNOR_PERFORMANCE = 1

  performance

• BOOT_CPUFREQ_GOVERNOR_POWERSAVE = 2

  powersave

• BOOT_CPUFREQ_GOVERNOR_ONDEMAND = 3

  ondemand

• BOOT_CPUFREQ_GOVERNOR_CONSERVATIVE = 4

  conservative

• BOOT_CPUFREQ_GOVERNOR_SCHEDUTIL = 5

  schedutil

• BOOT_CPUFREQ_GOVERNOR_USERSPACE = 6

  userspace

• BOOT_CPUFREQ_GOVERNOR_UNKNOWN = 7

  unknown

Type of the validator's cpuset partition (the cgroup named after the instance that the cpuset configure stage creates), which isolates pinned tiles from other tasks at run time.

Used in: Boot

• BOOT_CPUSET_PARTITION_UNSPECIFIED = 0

• BOOT_CPUSET_PARTITION_NONE = 1

  No such cgroup, or no cpuset controller.

• BOOT_CPUSET_PARTITION_MEMBER = 2

  The cgroup exists but is not a partition, so it does not isolate.

• BOOT_CPUSET_PARTITION_ROOT = 3

  A partition with its own scheduler domain: other tasks are kept off its processors.

• BOOT_CPUSET_PARTITION_ISOLATED = 4

  A partition without scheduler domains or load balancing: other tasks are kept off its processors.

• BOOT_CPUSET_PARTITION_INVALID = 5

  The kernel rejected the partition, so it does not isolate.

• BOOT_CPUSET_PARTITION_UNKNOWN = 6

  Unlisted or unreadable.

Physical chassis form factor of the host.

Used in: Boot

• BOOT_DMI_CHASSIS_TYPE_UNSPECIFIED = 0

• BOOT_DMI_CHASSIS_TYPE_UNKNOWN = 1

  Unlisted or undeterminable.

• BOOT_DMI_CHASSIS_TYPE_DESKTOP = 2

  desktop

• BOOT_DMI_CHASSIS_TYPE_LAPTOP = 3

  laptop

• BOOT_DMI_CHASSIS_TYPE_NOTEBOOK = 4

  notebook

• BOOT_DMI_CHASSIS_TYPE_TOWER = 5

  tower

• BOOT_DMI_CHASSIS_TYPE_RACK_MOUNT = 6

  rack_mount

• BOOT_DMI_CHASSIS_TYPE_BLADE = 7

  blade

• BOOT_DMI_CHASSIS_TYPE_BLADE_ENCLOSURE = 8

  blade_enclosure

• BOOT_DMI_CHASSIS_TYPE_MINI_PC = 9

  mini_pc

• BOOT_DMI_CHASSIS_TYPE_STICK_PC = 10

  stick_pc

• BOOT_DMI_CHASSIS_TYPE_EMBEDDED = 11

  embedded

• BOOT_DMI_CHASSIS_TYPE_SEALED_CASE_PC = 12

  sealed_case_pc

• BOOT_DMI_CHASSIS_TYPE_CONVERTIBLE = 13

  convertible

• BOOT_DMI_CHASSIS_TYPE_DETACHABLE = 14

  detachable

• BOOT_DMI_CHASSIS_TYPE_VIRTUAL = 15

  virtual

• BOOT_DMI_CHASSIS_TYPE_CLOUD = 16

  cloud

One populated memory module.

Used in: Boot

• uint64 size_bytes = 1

  Module capacity in bytes.

• bytes mem_type = 2

  Memory technology, such as DDR4 or DDR5.

• uint64 speed_mts = 3

  Configured operating speed in mega-transfers per second.

• uint64 rated_speed_mts = 4

  Maximum rated speed in mega-transfers per second.

• bytes manufacturer = 5

  Module manufacturer name.

• bytes part_number = 6

  Module part number: the exact vendor SKU including speed grade and revision.

One mounted filesystem.

Used in: Boot

• uint32 device_idx = 1

  Index into block_devices of the backing device; 255 when not a local block device.

• bytes fs_type = 2

  Filesystem type, such as ext4, xfs, or tmpfs.

• bytes mount_options = 3

  Mount options in effect. Option values that can carry paths, addresses, or usernames are redacted.

• uint64 capacity_bytes = 4

  Total capacity in bytes.

• uint64 free_bytes = 5

  Free space in bytes at boot.

Identity of the virtualization platform when virtualized, or none for bare metal.

Used in: Boot

• BOOT_HYPERVISOR_VENDOR_UNSPECIFIED = 0

• BOOT_HYPERVISOR_VENDOR_NONE = 1

  none

• BOOT_HYPERVISOR_VENDOR_KVM = 2

  kvm

• BOOT_HYPERVISOR_VENDOR_QEMU = 3

  qemu

• BOOT_HYPERVISOR_VENDOR_VMWARE = 4

  vmware

• BOOT_HYPERVISOR_VENDOR_MICROSOFT_HYPERV = 5

  microsoft_hyperv

• BOOT_HYPERVISOR_VENDOR_XEN = 6

  xen

• BOOT_HYPERVISOR_VENDOR_AMAZON_NITRO = 7

  amazon_nitro

• BOOT_HYPERVISOR_VENDOR_KVM_GCE = 8

  kvm_gce

• BOOT_HYPERVISOR_VENDOR_BHYVE = 9

  bhyve

• BOOT_HYPERVISOR_VENDOR_PARALLELS = 10

  parallels

• BOOT_HYPERVISOR_VENDOR_VIRTUALBOX = 11

  virtualbox

• BOOT_HYPERVISOR_VENDOR_BOCHS = 12

  bochs

• BOOT_HYPERVISOR_VENDOR_UNKNOWN = 13

  unknown

Input-output memory management unit state, which gates kernel-bypass zero-copy behavior and per-packet translation cost.

Used in: Boot

• BOOT_IOMMU_MODE_UNSPECIFIED = 0

• BOOT_IOMMU_MODE_OFF = 1

  No IOMMU active.

• BOOT_IOMMU_MODE_PASSTHROUGH = 2

  Active in passthrough; no per-packet translation.

• BOOT_IOMMU_MODE_TRANSLATED = 3

  Active with translation; adds per-packet cost.

• BOOT_IOMMU_MODE_UNKNOWN = 4

  Not determinable.

Which system C library the validator is running against.

Used in: Boot

• BOOT_LIBC_KIND_UNSPECIFIED = 0

• BOOT_LIBC_KIND_GLIBC = 1

  glibc

• BOOT_LIBC_KIND_MUSL = 2

  musl

• BOOT_LIBC_KIND_UNKNOWN = 3

  unknown

One software storage array.

Used in: Boot

• bytes name = 1

  Array name.

• string level = 2

  Redundancy level of the array.

• uint32 device_count = 3

  Number of devices in the array.

• bool degraded = 4

  Whether the array is degraded.

One physical network interface and its hardware and link properties.

Used in: Boot

• bytes name = 1

  Interface name.

• bytes driver = 2

  Kernel device driver module backing the interface.

• bytes driver_version = 3

  Version string reported by the interface driver.

• bytes firmware_version = 4

  Firmware version running on the interface hardware.

• uint32 pcie_current_link_width = 5

  Negotiated PCIe link width; less than the maximum means the card trained down and lost bandwidth.

• uint32 pcie_max_link_width = 6

  Maximum PCIe link width the device supports.

• bytes pcie_current_link_speed = 7

  Negotiated PCIe link speed, such as 16.0 GT/s.

• bytes pcie_max_link_speed = 8

  Maximum PCIe link speed the device supports.

• bytes bus_info = 9

  Hardware bus location of the card, typically its peripheral bus address.

• uint32 pci_device_id = 10

  Peripheral bus device identifier of the card.

• uint32 pci_vendor_id = 11

  Peripheral bus vendor identifier of the card.

• uint32 pci_subsystem_vendor_id = 12

  Peripheral bus subsystem vendor identifier of the card.

• uint32 pci_subsystem_device_id = 13

  Peripheral bus subsystem device identifier of the card.

• uint64 numa_node = 14

  Memory locality domain the card is attached to; all-ones when not applicable.

• uint64 mtu = 15

  Largest packet size the interface will send without fragmentation.

• uint64 link_speed_mbps = 16

  Negotiated link speed in megabits per second.

• bool carrier = 17

  Whether the interface currently detects a physical link.

• bool promiscuous = 18

  Whether the interface accepts all packets on the wire rather than only those addressed to it.

• uint32 channels_current = 19

  Hardware queue channels currently configured.

• uint32 channels_max = 20

  Maximum hardware queue channels the device supports.

• uint64 rx_ring_size = 21

  Number of descriptor slots in the hardware receive ring buffer.

• uint64 tx_ring_size = 22

  Number of descriptor slots in the hardware transmit ring buffer.

• uint64 rx_ring_max = 23

  Maximum receive ring buffer size the hardware supports.

• uint64 tx_ring_max = 24

  Maximum transmit ring buffer size the hardware supports.

• repeated string offloads = 25

  Kernel network device features currently enabled on the interface, under their kernel names, such as rx-checksum or rx-gro; rx-lro appearing here is harmful to latency-sensitive traffic.

• bool rss_flow_hash_udp4 = 26

  Whether receive-side hashing over UDP ports was successfully enabled, required to spread flows across queues.

• uint64 coalesce_rx_usecs = 27

  Receive interrupt coalescing delay in microseconds.

• bool coalesce_adaptive_rx = 28

  Whether receive interrupt coalescing is tuned dynamically based on load.

• string rss_hash_func = 29

  Hashing function the card uses to distribute incoming packets across queues.

• uint64 ntuple_rule_count = 30

  Number of active hardware flow-steering rules installed on the card.

• bool is_bond_master = 31

  Whether the interface is a bonded aggregate of multiple physical members.

One non-volatile express storage device.

Used in: Boot

• uint32 device_idx = 1

  Index of this drive in block_devices, which carries its model and identity.

• bytes firmware_rev = 2

  Firmware revision of the device.

• uint32 critical_warning = 3

  Drive critical warning flags from the health log; any nonzero bit means the drive is degraded.

• uint32 available_spare_pct = 4

  Remaining spare capacity percentage; below threshold predicts imminent read-only fallback.

• uint32 percentage_used = 5

  Endurance used percentage; values near or past 100 mark worn media.

• uint64 media_errors = 6

  Media and data integrity error count; nonzero flags drives silently retrying reads.

• uint32 numa_node = 7

  Memory locality domain of the drive. 255 when not applicable.

• uint64 namespace_size_bytes = 8

  Size of the device namespace in bytes.

• bool has_health = 9

  Whether the health log was read. When false the warning, spare, used and error fields are unknown, not healthy.

Combined event type

Used in: StreamEventsRequest

• oneof event

  • Txn txn = 1

  • Shred shred = 2

  • SignedVote signed_vote = 3

  • SlotConfirmed slot_confirmed = 4

  • AccdbCompactionCompleted accdb_compaction_completed = 5

  • AccdbPartitionAdded accdb_partition_added = 6

  • BlockEquivocated block_equivocated = 7

  • RuntimeTxn runtime_txn = 8

  • BlockCompleted block_completed = 9

  • Boot boot = 10

  • SnapshotCreated snapshot_created = 11

  • AdminCommand admin_command = 12

  • RuntimeBlock runtime_block = 13

  • RuntimeReward runtime_reward = 14

  • RuntimeStakeDelegation runtime_stake_delegation = 15

  • RuntimeRooted runtime_rooted = 16

  • RuntimeEpoch runtime_epoch = 17

  • RuntimeVoteAccount runtime_vote_account = 18

  • AlpenglowVote alpenglow_vote = 19

  • AlpenglowCert alpenglow_cert = 20

  • BlockReceived block_received = 21

  • MetricsNet metrics_net = 22

  • MetricsMlx5 metrics_mlx5 = 23

  • MetricsSock metrics_sock = 24

  • MetricsQuic metrics_quic = 25

  • MetricsBundle metrics_bundle = 26

  • MetricsVerify metrics_verify = 27

  • MetricsDedup metrics_dedup = 28

  • MetricsResolv metrics_resolv = 29

  • MetricsPack metrics_pack = 30

  • MetricsExecle metrics_execle = 31

  • MetricsShred metrics_shred = 32

  • MetricsAccdb metrics_accdb = 33

  • MetricsReplay metrics_replay = 34

  • MetricsRotor metrics_rotor = 35

  • MetricsRserve metrics_rserve = 36

  • MetricsGossip metrics_gossip = 37

  • MetricsGossvf metrics_gossvf = 38

  • MetricsSign metrics_sign = 39

  • MetricsNetlnk metrics_netlnk = 40

  • MetricsSnapct metrics_snapct = 41

  • MetricsSnapld metrics_snapld = 42

  • MetricsSnapdc metrics_snapdc = 43

  • MetricsSnapin metrics_snapin = 44

  • MetricsMetric metrics_metric = 45

  • MetricsRpc metrics_rpc = 46

  • MetricsDiag metrics_diag = 47

  • MetricsGenesi metrics_genesi = 48

  • MetricsAdmin metrics_admin = 49

  • MetricsWaker metrics_waker = 50

  • MetricsMwaitx metrics_mwaitx = 51

  • MetricsIpecho metrics_ipecho = 52

  • MetricsExecrp metrics_execrp = 53

  • MetricsVotor metrics_votor = 54

  • MetricsGui metrics_gui = 55

  • MetricsEvent metrics_event = 56

  • MetricsSnapmk metrics_snapmk = 57

  • MetricsSnapzp metrics_snapzp = 58

  • MetricsSnaprd metrics_snaprd = 59

  • MetricsSnapsv metrics_snapsv = 60

  • MetricsLink metrics_link = 61

  • MetricsMotor metrics_motor = 62

  • RepairRequest repair_request = 63

  • MetricsIavf metrics_iavf = 64

  • MetricsFailov metrics_failov = 65

  • MetricsRepair metrics_repair = 66

Metrics of one accdb tile instance, one row per sweep

Used in: Event

• uint64 sample_id = 1

  Identifier shared by every row of one sweep

• MetricsSampleReason sample_reason = 2

  Why a metrics sweep was taken

• uint64 sample_slot = 3

  Slot that triggered the sweep, 0 for periodic sweeps

• MetricsSnapctLoadState sample_snapct_state = 4

  Snapshot load state

• bool sample_caught_up = 5

  Whether replay had caught up to the cluster tip when the sweep was taken (replay IsCaughtUp); set once per run, never cleared

• uint64 sample_tile_cnt = 6

  Tile instances in the sweep, to detect partial sweeps

• uint64 kind_id = 7

  Index of this tile instance among tiles of its kind

• uint64 pid = 8

  Process ID of the tile

• uint64 tid = 9

  Thread ID of the tile. Same as Pid in production, but might differ in development

• uint64 last_cpu_index = 10

  CPU the tile last ran on

• uint64 context_switch_involuntary = 11

  counter: cumulative since tile start, query deltas. Involuntary context switches

• uint64 context_switch_voluntary = 12

  counter: cumulative since tile start, query deltas. Voluntary context switches

• uint64 page_fault_major = 13

  counter: cumulative since tile start, query deltas. Major page faults

• uint64 page_fault_minor = 14

  counter: cumulative since tile start, query deltas. Minor page faults

• MetricsAccdbState state = 15

  Tile lifecycle state: 0=booting, 1=running, 2=shutdown

• uint64 heartbeat_time = 16

  Last wall-clock time the tile heartbeated

• bool is_backpressured = 17

  Whether the tile is currently backpressured

• uint64 backpressure = 18

  counter: cumulative since tile start, query deltas. Times the tile waited for one or more consumers to catch up to resume publishing

• optional MetricsAccdbRegimeDurationNanos regime_duration_nanos = 19

  Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

• optional MetricsAccdbThreadDurationNanos thread_duration_nanos = 20

  Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

• optional MetricsAccdbParkAttempted park_attempted = 21

  Times the tile tried to park while idle (efficient mode), by result

• uint64 device_irq = 22

  counter: cumulative since tile start, query deltas. Device IRQs on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 tlb_shootdown = 23

  counter: cumulative since tile start, query deltas. TLB shootdowns on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 timer_irq = 24

  counter: cumulative since tile start, query deltas. Local timer interrupts (LOC) on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 account_used = 25

  Account versions in the index; every unrooted fork version counts

• uint64 account_capacity = 26

  Account versions the index can hold

• uint64 account_relocated = 27

  Accounts moved in the account database during compaction

• uint64 disk_allocated_bytes = 28

  Allocated size of the account database file

• uint64 disk_consumed_bytes = 29

  gauge: current value, do not sum over time. Bytes of the account database file written at least once, excluding never-written partition tail space

• uint64 disk_used_bytes = 30

  Bytes of the account database file holding live data

• bool is_compacting = 31

  Whether a compaction is currently in progress

• uint64 compaction_requested = 32

  Compactions requested on the account database

• uint64 compaction_completed = 33

  Compactions fully completed on the account database, less than or equal to the requested amount

• uint64 account_relocated_bytes = 34

  Bytes moved in the account database during compaction

• optional MetricsAccdbAccountPreevicted account_preevicted = 35

  Dirty accounts written back and evicted by the background preevict pass, by size class; clean lines reclaimed are not counted

• uint64 disk_read_bytes = 36

  Bytes read from the account database file by compaction and writeback

• uint64 disk_written_bytes = 37

  Bytes written to the account database file by compaction and writeback

• uint64 writeback_written = 38

  Write syscalls that wrote evicted cache lines back to the account database file

• uint64 compaction_written = 39

  Writes that relocated a batch of records during compaction

• uint64 account_version_removed = 40

  Account versions removed from the account database index

• optional MetricsAccdbCacheClassUsed cache_class_used = 41

  Cache lines in use, by size class

• optional MetricsAccdbCacheClassCapacity cache_class_capacity = 42

  Cache line capacity, by size class

• optional MetricsAccdbCacheClassReserved cache_class_reserved = 43

  gauge: current value, do not sum over time. Cache lines reserved by in-flight acquires, by size class; 0 when reservation tracking is disabled for the class

• optional MetricsAccdbIsCacheClassReservationTracked is_cache_class_reservation_tracked = 44

  Whether cache line reservations are tracked for each size class; untracked classes always have room for every joiner and read 0 in CacheClassReserved

• optional MetricsAccdbCacheClassFreeTarget cache_class_free_target = 45

  Free cache lines the background preevict pass tries to restore, by size class

• optional MetricsAccdbCacheClassFreeLowWater cache_class_free_low_water = 46

  Free cache line count below which the background preevict pass starts, by size class

• uint64 progcache_preevicted_bytes = 47

  Bytes reclaimed from the program cache by the background preevict pass

• optional MetricsAccdbProgcachePreevicted progcache_preevicted = 48

  Program cache slots reclaimed by the background preevict pass, by size class

Dirty accounts written back and evicted by the background preevict pass, by size class; clean lines reclaimed are not counted

Used in: MetricsAccdb

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

Cache line capacity, by size class

Used in: MetricsAccdb

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

Free cache line count below which the background preevict pass starts, by size class

Used in: MetricsAccdb

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

Free cache lines the background preevict pass tries to restore, by size class

Used in: MetricsAccdb

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

gauge: current value, do not sum over time. Cache lines reserved by in-flight acquires, by size class; 0 when reservation tracking is disabled for the class

Used in: MetricsAccdb

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

Cache lines in use, by size class

Used in: MetricsAccdb

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

Whether cache line reservations are tracked for each size class; untracked classes always have room for every joiner and read 0 in CacheClassReserved

Used in: MetricsAccdb

• bool le128_b = 1

  0-128 B

• bool le512_b = 2

  129-512 B

• bool le2_kib = 3

  513 B-2 KiB

• bool le8_kib = 4

  2-8 KiB

• bool le32_kib = 5

  8-32 KiB

• bool le128_kib = 6

  32-128 KiB

• bool le1_mib = 7

  128 KiB-1 MiB

• bool le10_mib = 8

  1-10 MiB

Times the tile tried to park while idle (efficient mode), by result

Used in: MetricsAccdb

• uint64 ring = 1

  Woken by a doorbell ring

• uint64 deadline = 2

  Deadline or park cap lapsed

• uint64 pending = 3

  Pre-park recheck found work, did not park

Program cache slots reclaimed by the background preevict pass, by size class

Used in: MetricsAccdb

• uint64 le128_kib = 1

  0-128 KiB

• uint64 le512_kib = 2

  128-512 KiB

• uint64 le1_mib = 3

  512 KiB-1 MiB

• uint64 le2_mib = 4

  1-2 MiB

• uint64 le4_mib = 5

  2-4 MiB

• uint64 le11_mib = 6

  4-11 MiB

Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

Used in: MetricsAccdb

• uint64 caught_up_housekeeping = 1

  Caught up + Housekeeping

• uint64 processing_housekeeping = 2

  Processing + Housekeeping

• uint64 backpressure_housekeeping = 3

  Backpressure + Housekeeping

• uint64 caught_up_prefrag = 4

  Caught up + Prefrag

• uint64 processing_prefrag = 5

  Processing + Prefrag

• uint64 backpressure_prefrag = 6

  Backpressure + Prefrag

• uint64 caught_up_postfrag = 7

  Caught up + Postfrag

• uint64 processing_postfrag = 8

  Processing + Postfrag

• uint64 caught_up_sleeping = 9

  Caught up + Sleeping

• uint64 backpressure_sleeping = 10

  Backpressure + Sleeping

Tile lifecycle state: 0=booting, 1=running, 2=shutdown

Used in: MetricsAccdb

• METRICS_ACCDB_STATE_UNSPECIFIED = 0

• METRICS_ACCDB_STATE_BOOTING = 1

  Booting

• METRICS_ACCDB_STATE_RUNNING = 2

  Running

• METRICS_ACCDB_STATE_SHUTDOWN = 3

  Shutdown

Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

Used in: MetricsAccdb

• uint64 wait = 1

  Wait (task was runnable but not scheduled)

• uint64 idle = 2

  Idle (task was not runnable)

• uint64 user = 3

  User (task was scheduled and executing in user mode)

• uint64 system = 4

  System (task was scheduled and executing in kernel mode)

• uint64 interrupt = 5

  Interrupt (CPU time stolen by hardirq/softirq handlers or a hypervisor; fixed tiles only)

Metrics of one admin tile instance, one row per sweep

Used in: Event

• uint64 sample_id = 1

  Identifier shared by every row of one sweep

• MetricsSampleReason sample_reason = 2

  Why a metrics sweep was taken

• uint64 sample_slot = 3

  Slot that triggered the sweep, 0 for periodic sweeps

• MetricsSnapctLoadState sample_snapct_state = 4

  Snapshot load state

• bool sample_caught_up = 5

  Whether replay had caught up to the cluster tip when the sweep was taken (replay IsCaughtUp); set once per run, never cleared

• uint64 sample_tile_cnt = 6

  Tile instances in the sweep, to detect partial sweeps

• uint64 kind_id = 7

  Index of this tile instance among tiles of its kind

• uint64 pid = 8

  Process ID of the tile

• uint64 tid = 9

  Thread ID of the tile. Same as Pid in production, but might differ in development

• uint64 last_cpu_index = 10

  CPU the tile last ran on

• uint64 context_switch_involuntary = 11

  counter: cumulative since tile start, query deltas. Involuntary context switches

• uint64 context_switch_voluntary = 12

  counter: cumulative since tile start, query deltas. Voluntary context switches

• uint64 page_fault_major = 13

  counter: cumulative since tile start, query deltas. Major page faults

• uint64 page_fault_minor = 14

  counter: cumulative since tile start, query deltas. Minor page faults

• MetricsAdminState state = 15

  Tile lifecycle state: 0=booting, 1=running, 2=shutdown

• uint64 heartbeat_time = 16

  Last wall-clock time the tile heartbeated

• bool is_backpressured = 17

  Whether the tile is currently backpressured

• uint64 backpressure = 18

  counter: cumulative since tile start, query deltas. Times the tile waited for one or more consumers to catch up to resume publishing

• optional MetricsAdminRegimeDurationNanos regime_duration_nanos = 19

  Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

• optional MetricsAdminThreadDurationNanos thread_duration_nanos = 20

  Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

• optional MetricsAdminParkAttempted park_attempted = 21

  Times the tile tried to park while idle (efficient mode), by result

• uint64 device_irq = 22

  counter: cumulative since tile start, query deltas. Device IRQs on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 tlb_shootdown = 23

  counter: cumulative since tile start, query deltas. TLB shootdowns on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 timer_irq = 24

  counter: cumulative since tile start, query deltas. Local timer interrupts (LOC) on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

Times the tile tried to park while idle (efficient mode), by result

Used in: MetricsAdmin

• uint64 ring = 1

  Woken by a doorbell ring

• uint64 deadline = 2

  Deadline or park cap lapsed

• uint64 pending = 3

  Pre-park recheck found work, did not park

Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

Used in: MetricsAdmin

• uint64 caught_up_housekeeping = 1

  Caught up + Housekeeping

• uint64 processing_housekeeping = 2

  Processing + Housekeeping

• uint64 backpressure_housekeeping = 3

  Backpressure + Housekeeping

• uint64 caught_up_prefrag = 4

  Caught up + Prefrag

• uint64 processing_prefrag = 5

  Processing + Prefrag

• uint64 backpressure_prefrag = 6

  Backpressure + Prefrag

• uint64 caught_up_postfrag = 7

  Caught up + Postfrag

• uint64 processing_postfrag = 8

  Processing + Postfrag

• uint64 caught_up_sleeping = 9

  Caught up + Sleeping

• uint64 backpressure_sleeping = 10

  Backpressure + Sleeping

Tile lifecycle state: 0=booting, 1=running, 2=shutdown

Used in: MetricsAdmin

• METRICS_ADMIN_STATE_UNSPECIFIED = 0

• METRICS_ADMIN_STATE_BOOTING = 1

  Booting

• METRICS_ADMIN_STATE_RUNNING = 2

  Running

• METRICS_ADMIN_STATE_SHUTDOWN = 3

  Shutdown

Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

Used in: MetricsAdmin

• uint64 wait = 1

  Wait (task was runnable but not scheduled)

• uint64 idle = 2

  Idle (task was not runnable)

• uint64 user = 3

  User (task was scheduled and executing in user mode)

• uint64 system = 4

  System (task was scheduled and executing in kernel mode)

• uint64 interrupt = 5

  Interrupt (CPU time stolen by hardirq/softirq handlers or a hypervisor; fixed tiles only)

Metrics of one bundle tile instance, one row per sweep

Used in: Event

• uint64 sample_id = 1

  Identifier shared by every row of one sweep

• MetricsSampleReason sample_reason = 2

  Why a metrics sweep was taken

• uint64 sample_slot = 3

  Slot that triggered the sweep, 0 for periodic sweeps

• MetricsSnapctLoadState sample_snapct_state = 4

  Snapshot load state

• bool sample_caught_up = 5

  Whether replay had caught up to the cluster tip when the sweep was taken (replay IsCaughtUp); set once per run, never cleared

• uint64 sample_tile_cnt = 6

  Tile instances in the sweep, to detect partial sweeps

• uint64 kind_id = 7

  Index of this tile instance among tiles of its kind

• uint64 pid = 8

  Process ID of the tile

• uint64 tid = 9

  Thread ID of the tile. Same as Pid in production, but might differ in development

• uint64 last_cpu_index = 10

  CPU the tile last ran on

• uint64 context_switch_involuntary = 11

  counter: cumulative since tile start, query deltas. Involuntary context switches

• uint64 context_switch_voluntary = 12

  counter: cumulative since tile start, query deltas. Voluntary context switches

• uint64 page_fault_major = 13

  counter: cumulative since tile start, query deltas. Major page faults

• uint64 page_fault_minor = 14

  counter: cumulative since tile start, query deltas. Minor page faults

• MetricsBundleState state = 15

  Tile lifecycle state: 0=booting, 1=running, 2=shutdown

• uint64 heartbeat_time = 16

  Last wall-clock time the tile heartbeated

• bool is_backpressured = 17

  Whether the tile is currently backpressured

• uint64 backpressure = 18

  counter: cumulative since tile start, query deltas. Times the tile waited for one or more consumers to catch up to resume publishing

• optional MetricsBundleRegimeDurationNanos regime_duration_nanos = 19

  Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

• optional MetricsBundleThreadDurationNanos thread_duration_nanos = 20

  Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

• optional MetricsBundleParkAttempted park_attempted = 21

  Times the tile tried to park while idle (efficient mode), by result

• uint64 device_irq = 22

  counter: cumulative since tile start, query deltas. Device IRQs on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 tlb_shootdown = 23

  counter: cumulative since tile start, query deltas. TLB shootdowns on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 timer_irq = 24

  counter: cumulative since tile start, query deltas. Local timer interrupts (LOC) on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 txn_rx = 25

  Transactions received, including transactions within bundles

• uint64 standalone_txn_rx = 26

  Transactions received outside of a bundle

• uint64 protobuf_rx_bytes = 27

  Bytes from received gRPC protobuf payloads

• uint64 bundle_rx = 28

  Bundles received

• optional MetricsBundleClientFailed client_failed = 29

  Bundle client failures, by cause

• uint64 heap_capacity_bytes = 30

  Workspace heap capacity

• uint64 heap_free_bytes = 31

  Approximate free space in workspace

• uint64 ping_acked = 32

  HTTP/2 PINGs acknowledged by server

• MetricsBundleConnState conn_state = 33

  Block engine connection state; Sleeping means closed on purpose because the next leader slot is far away: 0=disconnected, 1=connecting, 2=connected, 3=sleeping

• uint64 last_rtt_nanos = 34

  Latest block engine HTTP/2 PING round trip, 0 if none since connect

• uint64 rtt_smoothed_nanos = 35

  Smoothed block engine HTTP/2 PING round trip (RFC 9002), 0 if none since connect

• uint64 rtt_deviation_nanos = 36

  Mean deviation of block engine HTTP/2 PING round trips (RFC 9002 rttvar), 0 if none since connect

• optional MetricsBundleMessageRxDelayNanos message_rx_delay_nanos = 37

  Local wall clock minus server timestamp per block engine message; includes clock skew, negative clamped to 0

• uint64 txn_pending = 38

  Transactions buffered and waiting to be published

• uint64 txn_buffer_full_dropped = 39

  Transactions from the block engine dropped because the verify tiles were too slow to keep up

Bundle client failures, by cause

Used in: MetricsBundle

• uint64 decode = 1

  Protobuf decode or encode failed

• uint64 transport = 2

  gRPC transport failed

• uint64 no_fee_info = 3

  Bundle dropped due to missing fee info

Block engine connection state; Sleeping means closed on purpose because the next leader slot is far away: 0=disconnected, 1=connecting, 2=connected, 3=sleeping

Used in: MetricsBundle

• METRICS_BUNDLE_CONN_STATE_UNSPECIFIED = 0

• METRICS_BUNDLE_CONN_STATE_DISCONNECTED = 1

  Disconnected

• METRICS_BUNDLE_CONN_STATE_CONNECTING = 2

  Connecting

• METRICS_BUNDLE_CONN_STATE_CONNECTED = 3

  Connected

• METRICS_BUNDLE_CONN_STATE_SLEEPING = 4

  Sleeping

Local wall clock minus server timestamp per block engine message; includes clock skew, negative clamped to 0

Used in: MetricsBundle

• uint64 b0 = 1

  [0, 100000) nanos

• uint64 b1 = 2

  [100000, 193070) nanos

• uint64 b2 = 3

  [193070, 372760) nanos

• uint64 b3 = 4

  [372760, 719687) nanos

• uint64 b4 = 5

  [719687, 1389498) nanos

• uint64 b5 = 6

  [1389498, 2682700) nanos

• uint64 b6 = 7

  [2682700, 5179482) nanos

• uint64 b7 = 8

  [5179482, 10000012) nanos

• uint64 b8 = 9

  [10000012, 19306997) nanos

• uint64 b9 = 10

  [19306997, 37275969) nanos

• uint64 b10 = 11

  [37275969, 71968616) nanos

• uint64 b11 = 12

  [71968616, 138949620) nanos

• uint64 b12 = 13

  [138949620, 268269670) nanos

• uint64 b13 = 14

  [268269670, 517947555) nanos

• uint64 b14 = 15

  [517947555, 1000000000) nanos

• uint64 b15 = 16

  [1000000000, inf) nanos

• uint64 sum = 17

  Sum of samples (nanos)

Times the tile tried to park while idle (efficient mode), by result

Used in: MetricsBundle

• uint64 ring = 1

  Woken by a doorbell ring

• uint64 deadline = 2

  Deadline or park cap lapsed

• uint64 pending = 3

  Pre-park recheck found work, did not park

Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

Used in: MetricsBundle

• uint64 caught_up_housekeeping = 1

  Caught up + Housekeeping

• uint64 processing_housekeeping = 2

  Processing + Housekeeping

• uint64 backpressure_housekeeping = 3

  Backpressure + Housekeeping

• uint64 caught_up_prefrag = 4

  Caught up + Prefrag

• uint64 processing_prefrag = 5

  Processing + Prefrag

• uint64 backpressure_prefrag = 6

  Backpressure + Prefrag

• uint64 caught_up_postfrag = 7

  Caught up + Postfrag

• uint64 processing_postfrag = 8

  Processing + Postfrag

• uint64 caught_up_sleeping = 9

  Caught up + Sleeping

• uint64 backpressure_sleeping = 10

  Backpressure + Sleeping

Tile lifecycle state: 0=booting, 1=running, 2=shutdown

Used in: MetricsBundle

• METRICS_BUNDLE_STATE_UNSPECIFIED = 0

• METRICS_BUNDLE_STATE_BOOTING = 1

  Booting

• METRICS_BUNDLE_STATE_RUNNING = 2

  Running

• METRICS_BUNDLE_STATE_SHUTDOWN = 3

  Shutdown

Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

Used in: MetricsBundle

• uint64 wait = 1

  Wait (task was runnable but not scheduled)

• uint64 idle = 2

  Idle (task was not runnable)

• uint64 user = 3

  User (task was scheduled and executing in user mode)

• uint64 system = 4

  System (task was scheduled and executing in kernel mode)

• uint64 interrupt = 5

  Interrupt (CPU time stolen by hardirq/softirq handlers or a hypervisor; fixed tiles only)

Metrics of one dedup tile instance, one row per sweep

Used in: Event

• uint64 sample_id = 1

  Identifier shared by every row of one sweep

• MetricsSampleReason sample_reason = 2

  Why a metrics sweep was taken

• uint64 sample_slot = 3

  Slot that triggered the sweep, 0 for periodic sweeps

• MetricsSnapctLoadState sample_snapct_state = 4

  Snapshot load state

• bool sample_caught_up = 5

  Whether replay had caught up to the cluster tip when the sweep was taken (replay IsCaughtUp); set once per run, never cleared

• uint64 sample_tile_cnt = 6

  Tile instances in the sweep, to detect partial sweeps

• uint64 kind_id = 7

  Index of this tile instance among tiles of its kind

• uint64 pid = 8

  Process ID of the tile

• uint64 tid = 9

  Thread ID of the tile. Same as Pid in production, but might differ in development

• uint64 last_cpu_index = 10

  CPU the tile last ran on

• uint64 context_switch_involuntary = 11

  counter: cumulative since tile start, query deltas. Involuntary context switches

• uint64 context_switch_voluntary = 12

  counter: cumulative since tile start, query deltas. Voluntary context switches

• uint64 page_fault_major = 13

  counter: cumulative since tile start, query deltas. Major page faults

• uint64 page_fault_minor = 14

  counter: cumulative since tile start, query deltas. Minor page faults

• MetricsDedupState state = 15

  Tile lifecycle state: 0=booting, 1=running, 2=shutdown

• uint64 heartbeat_time = 16

  Last wall-clock time the tile heartbeated

• bool is_backpressured = 17

  Whether the tile is currently backpressured

• uint64 backpressure = 18

  counter: cumulative since tile start, query deltas. Times the tile waited for one or more consumers to catch up to resume publishing

• optional MetricsDedupRegimeDurationNanos regime_duration_nanos = 19

  Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

• optional MetricsDedupThreadDurationNanos thread_duration_nanos = 20

  Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

• optional MetricsDedupParkAttempted park_attempted = 21

  Times the tile tried to park while idle (efficient mode), by result

• uint64 device_irq = 22

  counter: cumulative since tile start, query deltas. Device IRQs on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 tlb_shootdown = 23

  counter: cumulative since tile start, query deltas. TLB shootdowns on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 timer_irq = 24

  counter: cumulative since tile start, query deltas. Local timer interrupts (LOC) on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• optional MetricsDedupTxnProcessed txn_processed = 25

  Transactions processed, by result

• uint64 vote_gossip_rx = 26

  Gossip vote transactions from pohh (Frankendancer only)

Times the tile tried to park while idle (efficient mode), by result

Used in: MetricsDedup

• uint64 ring = 1

  Woken by a doorbell ring

• uint64 deadline = 2

  Deadline or park cap lapsed

• uint64 pending = 3

  Pre-park recheck found work, did not park

Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

Used in: MetricsDedup

• uint64 caught_up_housekeeping = 1

  Caught up + Housekeeping

• uint64 processing_housekeeping = 2

  Processing + Housekeeping

• uint64 backpressure_housekeeping = 3

  Backpressure + Housekeeping

• uint64 caught_up_prefrag = 4

  Caught up + Prefrag

• uint64 processing_prefrag = 5

  Processing + Prefrag

• uint64 backpressure_prefrag = 6

  Backpressure + Prefrag

• uint64 caught_up_postfrag = 7

  Caught up + Postfrag

• uint64 processing_postfrag = 8

  Processing + Postfrag

• uint64 caught_up_sleeping = 9

  Caught up + Sleeping

• uint64 backpressure_sleeping = 10

  Backpressure + Sleeping

Tile lifecycle state: 0=booting, 1=running, 2=shutdown

Used in: MetricsDedup

• METRICS_DEDUP_STATE_UNSPECIFIED = 0

• METRICS_DEDUP_STATE_BOOTING = 1

  Booting

• METRICS_DEDUP_STATE_RUNNING = 2

  Running

• METRICS_DEDUP_STATE_SHUTDOWN = 3

  Shutdown

Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

Used in: MetricsDedup

• uint64 wait = 1

  Wait (task was runnable but not scheduled)

• uint64 idle = 2

  Idle (task was not runnable)

• uint64 user = 3

  User (task was scheduled and executing in user mode)

• uint64 system = 4

  System (task was scheduled and executing in kernel mode)

• uint64 interrupt = 5

  Interrupt (CPU time stolen by hardirq/softirq handlers or a hypervisor; fixed tiles only)

Transactions processed, by result

Used in: MetricsDedup

• uint64 success = 1

  Transaction was not a duplicate

• uint64 bundle_peer_failed = 2

  Another transaction in the bundle failed

• uint64 duplicate = 3

  Transaction was a duplicate

Metrics of one diag tile instance, one row per sweep

Used in: Event

• uint64 sample_id = 1

  Identifier shared by every row of one sweep

• MetricsSampleReason sample_reason = 2

  Why a metrics sweep was taken

• uint64 sample_slot = 3

  Slot that triggered the sweep, 0 for periodic sweeps

• MetricsSnapctLoadState sample_snapct_state = 4

  Snapshot load state

• bool sample_caught_up = 5

  Whether replay had caught up to the cluster tip when the sweep was taken (replay IsCaughtUp); set once per run, never cleared

• uint64 sample_tile_cnt = 6

  Tile instances in the sweep, to detect partial sweeps

• uint64 kind_id = 7

  Index of this tile instance among tiles of its kind

• uint64 pid = 8

  Process ID of the tile

• uint64 tid = 9

  Thread ID of the tile. Same as Pid in production, but might differ in development

• uint64 last_cpu_index = 10

  CPU the tile last ran on

• uint64 context_switch_involuntary = 11

  counter: cumulative since tile start, query deltas. Involuntary context switches

• uint64 context_switch_voluntary = 12

  counter: cumulative since tile start, query deltas. Voluntary context switches

• uint64 page_fault_major = 13

  counter: cumulative since tile start, query deltas. Major page faults

• uint64 page_fault_minor = 14

  counter: cumulative since tile start, query deltas. Minor page faults

• MetricsDiagState state = 15

  Tile lifecycle state: 0=booting, 1=running, 2=shutdown

• uint64 heartbeat_time = 16

  Last wall-clock time the tile heartbeated

• bool is_backpressured = 17

  Whether the tile is currently backpressured

• uint64 backpressure = 18

  counter: cumulative since tile start, query deltas. Times the tile waited for one or more consumers to catch up to resume publishing

• optional MetricsDiagRegimeDurationNanos regime_duration_nanos = 19

  Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

• optional MetricsDiagThreadDurationNanos thread_duration_nanos = 20

  Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

• optional MetricsDiagParkAttempted park_attempted = 21

  Times the tile tried to park while idle (efficient mode), by result

• uint64 device_irq = 22

  counter: cumulative since tile start, query deltas. Device IRQs on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 tlb_shootdown = 23

  counter: cumulative since tile start, query deltas. TLB shootdowns on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 timer_irq = 24

  counter: cumulative since tile start, query deltas. Local timer interrupts (LOC) on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• MetricsDiagBundleState bundle_state = 25

  Bundle subsystem state: 0=disconnected (All bundle tiles disconnected), 1=connecting (At least one bundle tile connecting, none connected or sleeping), 2=connected (At least one bundle tile connected), 3=sleeping (At least one bundle tile sleeping, none connected), 4=disabled (No bundle tiles configured)

• MetricsDiagVoteState vote_state = 26

  Vote subsystem state: 0=disabled (Non-voting or no votor tile), 1=not_started (Votor tile not running or no votes cast yet), 2=delinquent (Vote distance exceeds threshold or vote stalled), 3=voting (Voting normally), 4=inadmissible (Voting, but the vote account fails the validator admission ticket filter)

• MetricsDiagReplayState replay_state = 27

  Replay subsystem state: 0=disabled (No replay tile), 1=not_started (Replay tile not running or slots are zero), 2=behind (Replay lagging behind turbine or reset slot stalled), 3=running (Replay keeping up)

• MetricsDiagTurbineState turbine_state = 28

  Turbine subsystem state: 0=disabled (No shred or replay tiles), 1=not_started (Tiles not all running or turbine slot is zero), 2=stalled (Turbine slot not advancing), 3=repair_outpacing (Repair byte throughput exceeds turbine), 4=running (Turbine receiving normally)

• MetricsDiagBuilderState builder_state = 29

  External block builder subsystem state: 0=disabled (No block builder configured), 1=disconnected (Block builder disconnected), 2=connecting (Block builder connection in progress), 3=unhealthy (Connected, but the block builder is not in a usable state), 4=connected (Block builder connected and healthy)

• uint64 system_device_irq = 30

  counter: cumulative since tile start, query deltas. Device IRQs across all CPUs

• uint64 device_irq_on_tile_cpu = 31

  counter: cumulative since tile start, query deltas. Device IRQs on CPUs dedicated to pinned tiles; subset of SystemDeviceIrq

• optional MetricsDiagSystemSoftirq system_softirq = 32

  counter: cumulative since tile start, query deltas. Soft-IRQs across all CPUs, by softirq type

• optional MetricsDiagSoftirqOnTileCpu softirq_on_tile_cpu = 33

  counter: cumulative since tile start, query deltas. Soft-IRQs on CPUs dedicated to pinned tiles, by softirq type; subset of SystemSoftirq

• uint64 cpu_package_millicelsius = 34

  Hottest CPU package temperature (k10temp Tctl or coretemp Package), 0 if no sensor

• uint64 nic_millicelsius = 35

  Hottest NIC ASIC temperature (mlx5 or ice), 0 if no sensor

• uint64 nvme_millicelsius = 36

  Hottest NVMe composite temperature, 0 if no sensor or the kernel lacks CONFIG_NVME_HWMON

• uint64 cpu_power_microwatts = 37

  CPU package power from the powercap (RAPL) energy counters, averaged over 5 s, 0 if unavailable

• uint64 system_power_microwatts = 38

  Whole-system power draw from the ACPI power meter, averaged over its interval, 0 if no meter

• uint64 memory_ecc_corrected = 39

  counter: cumulative since tile start, query deltas. Corrected memory ECC errors across all memory controllers since boot (EDAC), 0 if firmware handles errors instead

• uint64 memory_ecc_uncorrected = 40

  counter: cumulative since tile start, query deltas. Uncorrected memory ECC errors across all memory controllers since boot (EDAC), 0 if firmware handles errors instead

• optional MetricsDiagSystemLoadCenti system_load_centi = 41

  Load average over each window, times 100 (/proc/loadavg has two decimals)

• uint64 thread_runnable_count = 42

  Runnable threads on the host (/proc/loadavg)

• optional MetricsDiagSystemCpuDurationNanos system_cpu_duration_nanos = 43

  CPU time summed over all CPUs since the diag tile started, by state (/proc/stat), 10 ms resolution

• uint64 memory_available_bytes = 44

  Host memory available without swapping (/proc/meminfo available)

• uint64 memory_free_bytes = 45

  Host memory not in use at all (/proc/meminfo free)

• uint64 swap_in_bytes = 46

  counter: cumulative since tile start, query deltas. Bytes swapped in from disk since boot (pswpin)

• uint64 swap_out_bytes = 47

  counter: cumulative since tile start, query deltas. Bytes swapped out to disk since boot (pswpout)

• uint64 system_page_fault_major = 48

  counter: cumulative since tile start, query deltas. Major page faults across the host since boot (pgmajfault)

• uint64 oom_killed = 49

  Processes killed by the kernel OOM killer since boot (oom_kill)

• uint64 cpu_pressure_duration_nanos = 50

  Time at least one task stalled waiting for CPU since boot (PSI some), 0 if the kernel lacks PSI

• uint64 memory_pressure_duration_nanos = 51

  Time at least one task stalled on memory reclaim or swap since boot (PSI some), 0 if the kernel lacks PSI

• uint64 memory_pressure_full_duration_nanos = 52

  Time all non-idle tasks stalled on memory together since boot (PSI full), a subset of MemoryPressureDurationNanos

• uint64 io_pressure_duration_nanos = 53

  Time at least one task stalled on IO since boot (PSI some), 0 if the kernel lacks PSI

• uint64 io_pressure_full_duration_nanos = 54

  Time all non-idle tasks stalled on IO together since boot (PSI full), a subset of IoPressureDurationNanos

• uint64 accounts_disk_read_bytes = 55

  Bytes read from the accounts disk since boot (/sys/block stat sectors read), 0 if not on a block device

• uint64 accounts_disk_written_bytes = 56

  Bytes written to the accounts disk since boot (/sys/block stat sectors written), 0 if not on a block device

• uint64 accounts_disk_written = 57

  Write requests the accounts disk completed since boot (/sys/block stat writes completed), 0 if not on a block device

• uint64 accounts_disk_write_duration_nanos = 58

  Time write requests to the accounts disk spent from submission to completion since the diag tile started, summed over requests (/sys/block stat write ticks), 0 if not on a block device

• uint64 accounts_disk_busy_duration_nanos = 59

  Time the accounts disk had at least one request in flight since the diag tile started (/sys/block stat io_ticks), 0 if not on a block device

• uint64 accounts_disk_request_in_flight_integral_nanos = 60

  Integral of requests in flight at the accounts disk over time since the diag tile started (request-nanoseconds, /sys/block stat time_in_queue); divide by elapsed time for the average queue depth, 0 if not on a block device

• uint64 accounts_disk_request_in_flight = 61

  Requests the accounts disk had in flight at the last sample (/sys/block stat in_flight), 0 if not on a block device

External block builder subsystem state: 0=disabled (No block builder configured), 1=disconnected (Block builder disconnected), 2=connecting (Block builder connection in progress), 3=unhealthy (Connected, but the block builder is not in a usable state), 4=connected (Block builder connected and healthy)

Used in: MetricsDiag

• METRICS_DIAG_BUILDER_STATE_UNSPECIFIED = 0

• METRICS_DIAG_BUILDER_STATE_DISABLED = 1

  No block builder configured

• METRICS_DIAG_BUILDER_STATE_DISCONNECTED = 2

  Block builder disconnected

• METRICS_DIAG_BUILDER_STATE_CONNECTING = 3

  Block builder connection in progress

• METRICS_DIAG_BUILDER_STATE_UNHEALTHY = 4

  Connected, but the block builder is not in a usable state

• METRICS_DIAG_BUILDER_STATE_CONNECTED = 5

  Block builder connected and healthy

Bundle subsystem state: 0=disconnected (All bundle tiles disconnected), 1=connecting (At least one bundle tile connecting, none connected or sleeping), 2=connected (At least one bundle tile connected), 3=sleeping (At least one bundle tile sleeping, none connected), 4=disabled (No bundle tiles configured)

Used in: MetricsDiag

• METRICS_DIAG_BUNDLE_STATE_UNSPECIFIED = 0

• METRICS_DIAG_BUNDLE_STATE_DISCONNECTED = 1

  All bundle tiles disconnected

• METRICS_DIAG_BUNDLE_STATE_CONNECTING = 2

  At least one bundle tile connecting, none connected or sleeping

• METRICS_DIAG_BUNDLE_STATE_CONNECTED = 3

  At least one bundle tile connected

• METRICS_DIAG_BUNDLE_STATE_SLEEPING = 4

  At least one bundle tile sleeping, none connected

• METRICS_DIAG_BUNDLE_STATE_DISABLED = 5

  No bundle tiles configured

Times the tile tried to park while idle (efficient mode), by result

Used in: MetricsDiag

• uint64 ring = 1

  Woken by a doorbell ring

• uint64 deadline = 2

  Deadline or park cap lapsed

• uint64 pending = 3

  Pre-park recheck found work, did not park

Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

Used in: MetricsDiag

• uint64 caught_up_housekeeping = 1

  Caught up + Housekeeping

• uint64 processing_housekeeping = 2

  Processing + Housekeeping

• uint64 backpressure_housekeeping = 3

  Backpressure + Housekeeping

• uint64 caught_up_prefrag = 4

  Caught up + Prefrag

• uint64 processing_prefrag = 5

  Processing + Prefrag

• uint64 backpressure_prefrag = 6

  Backpressure + Prefrag

• uint64 caught_up_postfrag = 7

  Caught up + Postfrag

• uint64 processing_postfrag = 8

  Processing + Postfrag

• uint64 caught_up_sleeping = 9

  Caught up + Sleeping

• uint64 backpressure_sleeping = 10

  Backpressure + Sleeping

Replay subsystem state: 0=disabled (No replay tile), 1=not_started (Replay tile not running or slots are zero), 2=behind (Replay lagging behind turbine or reset slot stalled), 3=running (Replay keeping up)

Used in: MetricsDiag

• METRICS_DIAG_REPLAY_STATE_UNSPECIFIED = 0

• METRICS_DIAG_REPLAY_STATE_DISABLED = 1

  No replay tile

• METRICS_DIAG_REPLAY_STATE_NOT_STARTED = 2

  Replay tile not running or slots are zero

• METRICS_DIAG_REPLAY_STATE_BEHIND = 3

  Replay lagging behind turbine or reset slot stalled

• METRICS_DIAG_REPLAY_STATE_RUNNING = 4

  Replay keeping up

counter: cumulative since tile start, query deltas. Soft-IRQs on CPUs dedicated to pinned tiles, by softirq type; subset of SystemSoftirq

Used in: MetricsDiag

• uint64 net = 1

  NET_TX, NET_RX

• uint64 disk = 2

  BLOCK

• uint64 other = 3

  e.g. TIMER, HRTIMER, IRQ_POLL, TASKLET, SCHED, RCU, ...

Tile lifecycle state: 0=booting, 1=running, 2=shutdown

Used in: MetricsDiag

• METRICS_DIAG_STATE_UNSPECIFIED = 0

• METRICS_DIAG_STATE_BOOTING = 1

  Booting

• METRICS_DIAG_STATE_RUNNING = 2

  Running

• METRICS_DIAG_STATE_SHUTDOWN = 3

  Shutdown

CPU time summed over all CPUs since the diag tile started, by state (/proc/stat), 10 ms resolution

Used in: MetricsDiag

• uint64 user = 1

  User (including nice)

• uint64 system = 2

  System

• uint64 idle = 3

  Idle

• uint64 io_wait = 4

  Idle waiting on IO

• uint64 interrupt = 5

  Hardirq and softirq handlers

• uint64 steal = 6

  Stolen by the hypervisor

Load average over each window, times 100 (/proc/loadavg has two decimals)

Used in: MetricsDiag

• uint64 minute1 = 1

  1 minute

• uint64 minute5 = 2

  5 minutes

• uint64 minute15 = 3

  15 minutes

counter: cumulative since tile start, query deltas. Soft-IRQs across all CPUs, by softirq type

Used in: MetricsDiag

• uint64 net = 1

  NET_TX, NET_RX

• uint64 disk = 2

  BLOCK

• uint64 other = 3

  e.g. TIMER, HRTIMER, IRQ_POLL, TASKLET, SCHED, RCU, ...

Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

Used in: MetricsDiag

• uint64 wait = 1

  Wait (task was runnable but not scheduled)

• uint64 idle = 2

  Idle (task was not runnable)

• uint64 user = 3

  User (task was scheduled and executing in user mode)

• uint64 system = 4

  System (task was scheduled and executing in kernel mode)

• uint64 interrupt = 5

  Interrupt (CPU time stolen by hardirq/softirq handlers or a hypervisor; fixed tiles only)

Turbine subsystem state: 0=disabled (No shred or replay tiles), 1=not_started (Tiles not all running or turbine slot is zero), 2=stalled (Turbine slot not advancing), 3=repair_outpacing (Repair byte throughput exceeds turbine), 4=running (Turbine receiving normally)

Used in: MetricsDiag

• METRICS_DIAG_TURBINE_STATE_UNSPECIFIED = 0

• METRICS_DIAG_TURBINE_STATE_DISABLED = 1

  No shred or replay tiles

• METRICS_DIAG_TURBINE_STATE_NOT_STARTED = 2

  Tiles not all running or turbine slot is zero

• METRICS_DIAG_TURBINE_STATE_STALLED = 3

  Turbine slot not advancing

• METRICS_DIAG_TURBINE_STATE_REPAIR_OUTPACING = 4

  Repair byte throughput exceeds turbine

• METRICS_DIAG_TURBINE_STATE_RUNNING = 5

  Turbine receiving normally

Vote subsystem state: 0=disabled (Non-voting or no votor tile), 1=not_started (Votor tile not running or no votes cast yet), 2=delinquent (Vote distance exceeds threshold or vote stalled), 3=voting (Voting normally), 4=inadmissible (Voting, but the vote account fails the validator admission ticket filter)

Used in: MetricsDiag

• METRICS_DIAG_VOTE_STATE_UNSPECIFIED = 0

• METRICS_DIAG_VOTE_STATE_DISABLED = 1

  Non-voting or no votor tile

• METRICS_DIAG_VOTE_STATE_NOT_STARTED = 2

  Votor tile not running or no votes cast yet

• METRICS_DIAG_VOTE_STATE_DELINQUENT = 3

  Vote distance exceeds threshold or vote stalled

• METRICS_DIAG_VOTE_STATE_VOTING = 4

  Voting normally

• METRICS_DIAG_VOTE_STATE_INADMISSIBLE = 5

  Voting, but the vote account fails the validator admission ticket filter

Metrics of one event tile instance, one row per sweep

Used in: Event

• uint64 sample_id = 1

  Identifier shared by every row of one sweep

• MetricsSampleReason sample_reason = 2

  Why a metrics sweep was taken

• uint64 sample_slot = 3

  Slot that triggered the sweep, 0 for periodic sweeps

• MetricsSnapctLoadState sample_snapct_state = 4

  Snapshot load state

• bool sample_caught_up = 5

  Whether replay had caught up to the cluster tip when the sweep was taken (replay IsCaughtUp); set once per run, never cleared

• uint64 sample_tile_cnt = 6

  Tile instances in the sweep, to detect partial sweeps

• uint64 kind_id = 7

  Index of this tile instance among tiles of its kind

• uint64 pid = 8

  Process ID of the tile

• uint64 tid = 9

  Thread ID of the tile. Same as Pid in production, but might differ in development

• uint64 last_cpu_index = 10

  CPU the tile last ran on

• uint64 context_switch_involuntary = 11

  counter: cumulative since tile start, query deltas. Involuntary context switches

• uint64 context_switch_voluntary = 12

  counter: cumulative since tile start, query deltas. Voluntary context switches

• uint64 page_fault_major = 13

  counter: cumulative since tile start, query deltas. Major page faults

• uint64 page_fault_minor = 14

  counter: cumulative since tile start, query deltas. Minor page faults

• MetricsEventState state = 15

  Tile lifecycle state: 0=booting, 1=running, 2=shutdown

• uint64 heartbeat_time = 16

  Last wall-clock time the tile heartbeated

• bool is_backpressured = 17

  Whether the tile is currently backpressured

• uint64 backpressure = 18

  counter: cumulative since tile start, query deltas. Times the tile waited for one or more consumers to catch up to resume publishing

• optional MetricsEventRegimeDurationNanos regime_duration_nanos = 19

  Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

• optional MetricsEventThreadDurationNanos thread_duration_nanos = 20

  Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

• optional MetricsEventParkAttempted park_attempted = 21

  Times the tile tried to park while idle (efficient mode), by result

• uint64 device_irq = 22

  counter: cumulative since tile start, query deltas. Device IRQs on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 tlb_shootdown = 23

  counter: cumulative since tile start, query deltas. TLB shootdowns on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 timer_irq = 24

  counter: cumulative since tile start, query deltas. Local timer interrupts (LOC) on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• MetricsEventConnState conn_state = 25

  Telemetry server connection state: 0=disconnected, 1=connecting, 2=authenticating, 3=connected

• uint64 queue_used = 26

  Events in the queue, sent-but-unacknowledged plus unsent

• uint64 queue_unsent_count = 27

  Events in the event queue not yet sent to the event service

• uint64 queue_evicted = 28

  Oldest events overwritten because the queue was full

• uint64 queue_used_bytes = 29

  Bytes used in the event queue

• uint64 queue_capacity_bytes = 30

  Event queue capacity

• uint64 event_tx = 31

  Events written to the stream, including resends after reconnect

• uint64 ack_rx = 32

  Acknowledgements received; one ack may retire many events

• uint64 last_acked_nonce = 33

  Nonce of the most recently acknowledged event, 0 if none

• uint64 stream_tx_bytes = 34

  Bytes sent to the event service

• uint64 stream_rx_bytes = 35

  Bytes received from the event service

• uint64 auth_failed = 36

  Authentication failures with the event service

• uint64 response_malformed_rejected = 37

  Malformed responses received from the event service

• uint64 conn_attempted = 38

  Connection attempts to the event service

• uint64 handshake_timed_out = 39

  Authentication handshakes that timed out

• uint64 credit_stalled = 40

  Reconnects forced because the event service stopped granting HTTP/2 flow-control credit while data was pending

Telemetry server connection state: 0=disconnected, 1=connecting, 2=authenticating, 3=connected

Used in: MetricsEvent

• METRICS_EVENT_CONN_STATE_UNSPECIFIED = 0

• METRICS_EVENT_CONN_STATE_DISCONNECTED = 1

  Disconnected

• METRICS_EVENT_CONN_STATE_CONNECTING = 2

  Connecting

• METRICS_EVENT_CONN_STATE_AUTHENTICATING = 3

  Authenticating

• METRICS_EVENT_CONN_STATE_CONNECTED = 4

  Connected

Times the tile tried to park while idle (efficient mode), by result

Used in: MetricsEvent

• uint64 ring = 1

  Woken by a doorbell ring

• uint64 deadline = 2

  Deadline or park cap lapsed

• uint64 pending = 3

  Pre-park recheck found work, did not park

Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

Used in: MetricsEvent

• uint64 caught_up_housekeeping = 1

  Caught up + Housekeeping

• uint64 processing_housekeeping = 2

  Processing + Housekeeping

• uint64 backpressure_housekeeping = 3

  Backpressure + Housekeeping

• uint64 caught_up_prefrag = 4

  Caught up + Prefrag

• uint64 processing_prefrag = 5

  Processing + Prefrag

• uint64 backpressure_prefrag = 6

  Backpressure + Prefrag

• uint64 caught_up_postfrag = 7

  Caught up + Postfrag

• uint64 processing_postfrag = 8

  Processing + Postfrag

• uint64 caught_up_sleeping = 9

  Caught up + Sleeping

• uint64 backpressure_sleeping = 10

  Backpressure + Sleeping

Tile lifecycle state: 0=booting, 1=running, 2=shutdown

Used in: MetricsEvent

• METRICS_EVENT_STATE_UNSPECIFIED = 0

• METRICS_EVENT_STATE_BOOTING = 1

  Booting

• METRICS_EVENT_STATE_RUNNING = 2

  Running

• METRICS_EVENT_STATE_SHUTDOWN = 3

  Shutdown

Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

Used in: MetricsEvent

• uint64 wait = 1

  Wait (task was runnable but not scheduled)

• uint64 idle = 2

  Idle (task was not runnable)

• uint64 user = 3

  User (task was scheduled and executing in user mode)

• uint64 system = 4

  System (task was scheduled and executing in kernel mode)

• uint64 interrupt = 5

  Interrupt (CPU time stolen by hardirq/softirq handlers or a hypervisor; fixed tiles only)

Metrics of one execle tile instance, one row per sweep

Used in: Event

• uint64 sample_id = 1

  Identifier shared by every row of one sweep

• MetricsSampleReason sample_reason = 2

  Why a metrics sweep was taken

• uint64 sample_slot = 3

  Slot that triggered the sweep, 0 for periodic sweeps

• MetricsSnapctLoadState sample_snapct_state = 4

  Snapshot load state

• bool sample_caught_up = 5

  Whether replay had caught up to the cluster tip when the sweep was taken (replay IsCaughtUp); set once per run, never cleared

• uint64 sample_tile_cnt = 6

  Tile instances in the sweep, to detect partial sweeps

• uint64 kind_id = 7

  Index of this tile instance among tiles of its kind

• uint64 pid = 8

  Process ID of the tile

• uint64 tid = 9

  Thread ID of the tile. Same as Pid in production, but might differ in development

• uint64 last_cpu_index = 10

  CPU the tile last ran on

• uint64 context_switch_involuntary = 11

  counter: cumulative since tile start, query deltas. Involuntary context switches

• uint64 context_switch_voluntary = 12

  counter: cumulative since tile start, query deltas. Voluntary context switches

• uint64 page_fault_major = 13

  counter: cumulative since tile start, query deltas. Major page faults

• uint64 page_fault_minor = 14

  counter: cumulative since tile start, query deltas. Minor page faults

• MetricsExecleState state = 15

  Tile lifecycle state: 0=booting, 1=running, 2=shutdown

• uint64 heartbeat_time = 16

  Last wall-clock time the tile heartbeated

• bool is_backpressured = 17

  Whether the tile is currently backpressured

• uint64 backpressure = 18

  counter: cumulative since tile start, query deltas. Times the tile waited for one or more consumers to catch up to resume publishing

• optional MetricsExecleRegimeDurationNanos regime_duration_nanos = 19

  Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

• optional MetricsExecleThreadDurationNanos thread_duration_nanos = 20

  Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

• optional MetricsExecleParkAttempted park_attempted = 21

  Times the tile tried to park while idle (efficient mode), by result

• uint64 device_irq = 22

  counter: cumulative since tile start, query deltas. Device IRQs on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 tlb_shootdown = 23

  counter: cumulative since tile start, query deltas. TLB shootdowns on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• uint64 timer_irq = 24

  counter: cumulative since tile start, query deltas. Local timer interrupts (LOC) on the tile's dedicated CPU, 0 unless it is the only live tile pinned there

• optional MetricsExecleTxnProcessed txn_processed = 25

  Transactions loaded and executed, by result

• optional MetricsExecleTxnProcessedByLanding txn_processed_by_landing = 26

  Transactions processed, by whether and how they landed in the block

• optional MetricsExecleTxnProcessedByVersion txn_processed_by_version = 27

  Transactions processed, by transaction version

• uint64 instruction_executed = 28

  Top-level instructions executed

• uint64 cpi_executed = 29

  Cross-program invocations executed

• uint64 account_lthash_skipped = 30

  Committed writable accounts left byte-identical by their transaction, so their in-band lthash update was skipped

• uint64 cu_consumed = 31

  Compute units consumed by executed transactions

• optional MetricsExecleTxnRegimeDurationNanos txn_regime_duration_nanos = 32

  Time per transaction, by phase; a phase counts only once the next phase starts, so dropped, fees-only and no-op transactions lose their trailing phases

• optional MetricsExecleVmRegimeDurationNanos vm_regime_duration_nanos = 33

  Time in top-level BPF invocations, by phase, with CPI setup and commit split out; nested programs, including native CPIs, count as Interpreter; subset of TxnRegime Execute

• uint64 progcache_looked_up = 34

  Program cache lookups; equals Hit + Miss + lookups of invalid program accounts

• uint64 progcache_miss = 35

  Program cache misses, each followed by an insert or a spill

• uint64 progcache_waited = 36

  Program cache lookups that waited on another tile's in-flight load of the same program

• uint64 progcache_insert_retried = 37

  Program cache inserts that found no free slot in their size class on the first try and retried after eviction

• uint64 progcache_inserted_bytes = 38

  Bytes inserted into the program cache

• uint64 progcache_spilled_bytes = 39

  Bytes loaded into program cache spill memory

• uint64 progcache_evicted_bytes = 40

  Bytes evicted from the program cache by insert eviction sweeps

• uint64 progcache_duration_nanos = 41

  Time in program cache lookups, including waits on peer loads and insert, eviction and ELF load on a miss; superset of ProgcacheLoadDurationNanos

• uint64 progcache_loaded = 42

  Program ELF loads and verifications for the program cache, including failed verifications and spill-backed loads

• uint64 progcache_load_duration_nanos = 43

  Time spent loading programs

• optional MetricsExecleProgcacheHit progcache_hit = 44

  Program cache hits, by size class

• optional MetricsExecleProgcacheInserted progcache_inserted = 45

  Programs inserted into the program cache, by size class

• optional MetricsExecleProgcacheEvicted progcache_evicted = 46

  Program cache slots reclaimed by an insert's eviction sweep, by size class (housekeeping preevicts are counted by the accdb tile)

• optional MetricsExecleProgcacheSpilled progcache_spilled = 47

  Programs loaded into spill memory because no cache slot could be freed, by size class

• optional MetricsExecleAccdbAccountReadonlyAcquired accdb_account_readonly_acquired = 48

  Readonly accounts acquired from the account database, by cache size class of the account's current data size

• optional MetricsExecleAccdbAccountWritableAcquired accdb_account_writable_acquired = 49

  Writable accounts acquired from the account database, by cache size class of the account's current data size

• optional MetricsExecleAccdbAccountEvicted accdb_account_evicted = 50

  Accounts evicted from the account database cache to make space, by cache size class

• optional MetricsExecleAccdbAccountNewCommitted accdb_account_new_committed = 51

  New account versions committed to the index, by destination cache size class

• optional MetricsExecleAccdbAccountOverwriteCommitted accdb_account_overwrite_committed = 52

  Account versions committed over an existing version of the same fork and generation, by destination cache size class

• optional MetricsExecleAccdbAccountCacheMissed accdb_account_cache_missed = 53

  Accounts not found in the account database cache and read from disk, by cache size class

• uint64 accdb_account_waited = 54

  Accounts that had to wait for another reader to finish loading them into the cache

• uint64 accdb_batch_acquired = 55

  Batch acquire calls made by this tile

• uint64 accdb_cache_reserve_retried = 56

  Spin retries while waiting to reserve cache lines for a transaction

• uint64 accdb_disk_read_bytes = 57

  Bytes read from the account database file

• uint64 accdb_disk_read = 58

  Reads from the account database file

• uint64 accdb_disk_written_bytes = 59

  Bytes written to the account database file

• uint64 accdb_disk_written = 60

  Writes to the account database file

• uint64 accdb_copied_bytes = 61

  Account data bytes copied in memory between cache lines, staging buffers and callers; disk reads excluded

• uint64 bank_switched = 62

  Cache invalidations due to transaction execution from a different block

• uint64 txncache_query_miss = 63

  Transaction cache queries by this tile that found a page not in memory

• uint64 txncache_insert_miss = 64

  Transaction cache inserts by this tile that found a page not in memory

• uint64 txncache_operation_stalled = 65

  Transaction cache queries and inserts by this tile that fell back to the exclusive lock, stalling every tile; pages they load are read while holding it

• optional MetricsExecleTxncacheQueryDurationNanos txncache_query_duration_nanos = 66

  Duration of one transaction cache query

• optional MetricsExecleTxncacheInsertDurationNanos txncache_insert_duration_nanos = 67

  Duration of one transaction cache insert

Accounts not found in the account database cache and read from disk, by cache size class

Used in: MetricsExecle

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

Accounts evicted from the account database cache to make space, by cache size class

Used in: MetricsExecle

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

New account versions committed to the index, by destination cache size class

Used in: MetricsExecle

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

Account versions committed over an existing version of the same fork and generation, by destination cache size class

Used in: MetricsExecle

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

Readonly accounts acquired from the account database, by cache size class of the account's current data size

Used in: MetricsExecle

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

Writable accounts acquired from the account database, by cache size class of the account's current data size

Used in: MetricsExecle

• uint64 le128_b = 1

  0-128 B

• uint64 le512_b = 2

  129-512 B

• uint64 le2_kib = 3

  513 B-2 KiB

• uint64 le8_kib = 4

  2-8 KiB

• uint64 le32_kib = 5

  8-32 KiB

• uint64 le128_kib = 6

  32-128 KiB

• uint64 le1_mib = 7

  128 KiB-1 MiB

• uint64 le10_mib = 8

  1-10 MiB

Times the tile tried to park while idle (efficient mode), by result

Used in: MetricsExecle

• uint64 ring = 1

  Woken by a doorbell ring

• uint64 deadline = 2

  Deadline or park cap lapsed

• uint64 pending = 3

  Pre-park recheck found work, did not park

Program cache slots reclaimed by an insert's eviction sweep, by size class (housekeeping preevicts are counted by the accdb tile)

Used in: MetricsExecle

• uint64 le128_kib = 1

  0-128 KiB

• uint64 le512_kib = 2

  128-512 KiB

• uint64 le1_mib = 3

  512 KiB-1 MiB

• uint64 le2_mib = 4

  1-2 MiB

• uint64 le4_mib = 5

  2-4 MiB

• uint64 le11_mib = 6

  4-11 MiB

Program cache hits, by size class

Used in: MetricsExecle

• uint64 le128_kib = 1

  0-128 KiB

• uint64 le512_kib = 2

  128-512 KiB

• uint64 le1_mib = 3

  512 KiB-1 MiB

• uint64 le2_mib = 4

  1-2 MiB

• uint64 le4_mib = 5

  2-4 MiB

• uint64 le11_mib = 6

  4-11 MiB

Programs inserted into the program cache, by size class

Used in: MetricsExecle

• uint64 le128_kib = 1

  0-128 KiB

• uint64 le512_kib = 2

  128-512 KiB

• uint64 le1_mib = 3

  512 KiB-1 MiB

• uint64 le2_mib = 4

  1-2 MiB

• uint64 le4_mib = 5

  2-4 MiB

• uint64 le11_mib = 6

  4-11 MiB

Programs loaded into spill memory because no cache slot could be freed, by size class

Used in: MetricsExecle

• uint64 le128_kib = 1

  0-128 KiB

• uint64 le512_kib = 2

  128-512 KiB

• uint64 le1_mib = 3

  512 KiB-1 MiB

• uint64 le2_mib = 4

  1-2 MiB

• uint64 le4_mib = 5

  2-4 MiB

• uint64 le11_mib = 6

  4-11 MiB

Tile wall time, by regime; regimes are exhaustive and groups Busy, Idle, Backpressure and Housekeeping partition it

Used in: MetricsExecle

• uint64 caught_up_housekeeping = 1

  Caught up + Housekeeping

• uint64 processing_housekeeping = 2

  Processing + Housekeeping

• uint64 backpressure_housekeeping = 3

  Backpressure + Housekeeping

• uint64 caught_up_prefrag = 4

  Caught up + Prefrag

• uint64 processing_prefrag = 5

  Processing + Prefrag

• uint64 backpressure_prefrag = 6

  Backpressure + Prefrag

• uint64 caught_up_postfrag = 7

  Caught up + Postfrag

• uint64 processing_postfrag = 8

  Processing + Postfrag

• uint64 caught_up_sleeping = 9

  Caught up + Sleeping

• uint64 backpressure_sleeping = 10

  Backpressure + Sleeping

Tile lifecycle state: 0=booting, 1=running, 2=shutdown

Used in: MetricsExecle

• METRICS_EXECLE_STATE_UNSPECIFIED = 0

• METRICS_EXECLE_STATE_BOOTING = 1

  Booting

• METRICS_EXECLE_STATE_RUNNING = 2

  Running

• METRICS_EXECLE_STATE_SHUTDOWN = 3

  Shutdown

Thread wall time since start, by scheduler state; Idle is the remainder, so parts sum to about the lifetime. User, System and Interrupt have 10 ms resolution; Interrupt is 0 unless it is the only live tile pinned to its CPU

Used in: MetricsExecle

• uint64 wait = 1

  Wait (task was runnable but not scheduled)

• uint64 idle = 2

  Idle (task was not runnable)

• uint64 user = 3

  User (task was scheduled and executing in user mode)

• uint64 system = 4

  System (task was scheduled and executing in kernel mode)

• uint64 interrupt = 5

  Interrupt (CPU time stolen by hardirq/softirq handlers or a hypervisor; fixed tiles only)

Transactions loaded and executed, by result

Used in: MetricsExecle

• uint64 success = 1

  Transaction executed successfully

• uint64 instruction_error = 2

  An error occurred while processing an instruction

• uint64 account_not_found = 3

  The transaction fee payer address was not found

• uint64 program_account_not_found = 4

  A program account referenced by the transaction was not found

• uint64 insufficient_funds_for_fee = 5

  The transaction fee payer did not have balance to pay the fee

• uint64 invalid_account_for_fee = 6

  The transaction fee payer account is not owned by the system program, or has data that is not a nonce

• uint64 already_processed = 7

  The transaction has already been processed in a recent block

• uint64 blockhash_not_found = 8

  The transaction references a blockhash that is not recent, or advances a nonce with the wrong value

• uint64 invalid_program_for_execution = 9

  A program account referenced by the transaction was no executable.

• uint64 address_lookup_table_not_found = 10

  The transaction references an ALUT account that does not exist or is inactive

• uint64 invalid_address_lookup_table_owner = 11

  The transaction references an ALUT account that is not owned by the ALUT program account

• uint64 invalid_address_lookup_table_data = 12

  The transaction references an ALUT account that contains data which is not a valid ALUT

• uint64 invalid_address_lookup_table_index = 13

  The transaction references an account offset from the ALUT which does not exist

• uint64 max_loaded_accounts_data_size_exceeded = 14

  The total account data size of the loaded accounts exceeds the consensus limit

• uint64 duplicate_instruction = 15

  A compute budget program instruction was invoked more than once

• uint64 invalid_loaded_accounts_data_size_limit = 16

  The compute budget program was invoked and set the loaded accounts data size to zero

• uint64 nonce_already_advanced = 17

  The transaction references a nonce account that is already advanced

• uint64 nonce_advance_failed = 18

  The transaction is a nonce transaction but the advance instruction was not valid or failed

• uint64 nonce_wrong_blockhash = 19

  The transaction is a nonce transaction but the blockhash is not the correct one

• uint64 unsupported_version = 20

  The transaction is a message version that is not supported by the current feature set

• uint64 sanitize_failure = 21

  The process for sanitizing the transaction failed

• uint64 account_in_use = 22

  The transaction conflicts with another transaction in the microblock.

• uint64 account_loaded_twice = 23

  The transaction references the same account twice

• uint64 signature_failure = 24

  The transaction had an invalid signature

• uint64 too_many_account_locks = 25

  The transaction references too many accounts.

• uint64 insufficient_funds_for_rent = 26

  The transaction would leave an account with a lower balance than the rent-exempt minimum

• uint64 unbalanced_transaction = 27

  The total referenced account lamports before and after the transaction was unbalanced

• uint64 bundle_peer = 28

  The transaction was part of a bundle and an earlier transaction in the bundle failed

Transactions processed, by whether and how they landed in the block

Used in: MetricsExecle

• uint64 success = 1

  Transaction landed and executed successfully

• uint64 fees_only = 2

  Transaction landed, but was fees only and did not execute

• uint64 failed = 3

  Transaction landed, but failed to execute

• uint64 dropped = 4

  Transaction did not land

Transactions processed, by transaction version

Used in: MetricsExecle

• uint64 legacy = 1

  Legacy transaction format

• uint64 v0 = 2

  Version 0 transaction format

• uint64 v1 = 3

  Version 1 transaction format

Time per transaction, by phase; a phase counts only once the next phase starts, so dropped, fees-only and no-op transactions lose their trailing phases

Used in: MetricsExecle

• uint64 load = 1

  Transaction checks and account loading

• uint64 execute = 2

  Transaction execution, including VM setup

• uint64 commit = 3

  Transaction result commit

Duration of one transaction cache insert

Used in: MetricsExecle

• uint64 b0 = 1

  [0, 10) nanos

• uint64 b1 = 2

  [10, 32) nanos

• uint64 b2 = 3

  [32, 101) nanos

• uint64 b3 = 4

  [101, 319) nanos

• uint64 b4 = 5

  [319, 1008) nanos

• uint64 b5 = 6

  [1008, 3185) nanos

• uint64 b6 = 7

  [3185, 10064) nanos

• uint64 b7 = 8

  [10064, 31800) nanos

• uint64 b8 = 9

  [31800, 100480) nanos

• uint64 b9 = 10

  [100480, 317492) nanos

• uint64 b10 = 11

  [317492, 1003197) nanos

• uint64 b11 = 12

  [1003197, 3169857) nanos

• uint64 b12 = 13

  [3169857, 10015972) nanos

• uint64 b13 = 14

  [10015972, 31648020) nanos

• uint64 b14 = 15

  [31648020, 100000000) nanos

• uint64 b15 = 16

  [100000000, inf) nanos

• uint64 sum = 17

  Sum of samples (nanos)

Duration of one transaction cache query

Used in: MetricsExecle

• uint64 b0 = 1

  [0, 10) nanos

• uint64 b1 = 2

  [10, 32) nanos

• uint64 b2 = 3

  [32, 101) nanos

• uint64 b3 = 4

  [101, 319) nanos

• uint64 b4 = 5

  [319, 1008) nanos

• uint64 b5 = 6

  [1008, 3185) nanos

• uint64 b6 = 7

  [3185, 10064) nanos

• uint64 b7 = 8

  [10064, 31800) nanos

• uint64 b8 = 9

  [31800, 100480) nanos

• uint64 b9 = 10

  [100480, 317492) nanos

• uint64 b10 = 11

  [317492, 1003197) nanos

• uint64 b11 = 12

  [1003197, 3169857) nanos

• uint64 b12 = 13

  [3169857, 10015972) nanos

• uint64 b13 = 14

  [10015972, 31648020) nanos

• uint64 b14 = 15

  [31648020, 100000000) nanos

• uint64 b15 = 16

  [100000000, inf) nanos

• uint64 sum = 17

  Sum of samples (nanos)