---
title: "Dashboards Public API Reference"
url: "https://nsta1.github.io/Orleans.Lattice/docs/lattice.dashboards/api.html"
source: "https://github.com/NSTA1/Orleans.Lattice/blob/release/9.9/docs/lattice.dashboards/api.md"
package: "Orleans.Lattice.Dashboards"
version: "9.9.0"
documents: "Orleans.Lattice 9.9.0 (release line 9.9)"
built: "2026-10-04"
all-pages: "https://nsta1.github.io/Orleans.Lattice/llms.txt"
bundle: "https://nsta1.github.io/Orleans.Lattice/docs/lattice.dashboards/llms-full.txt"
---
# Dashboards Public API Reference

Part of the [Dashboards documentation](README.md).

This document is the contract for the public `Orleans.Lattice.Dashboards` surface. The package exposes a single accessor type and a kind enum; everything else (the embedded JSON resources, the resource-name resolution) is an internal detail described by behaviour in [Architecture](architecture.md).

## Retrieving a dashboard

```csharp verify
using Orleans.Lattice.Dashboards;

public static class DashboardExample
{
    public static string GetOverviewJson()
        => LatticeDashboards.GetGrafanaDashboardJson(LatticeDashboardKind.Overview);
}
```

| Type | Kind | Purpose | Key public members |
|---|---|---|---|
| `LatticeDashboards` | static class | Retrieves the bundled Grafana dashboard JSON. | `GetGrafanaDashboardJson(LatticeDashboardKind)`, `All` |
| `LatticeDashboardKind` | enum | Identifies one bundled dashboard, each resolving to a focused operator workflow. | `Overview`, `CommitPath`, `Replication`, `AtomicWrites`, `MaterialisedViews`, `Authorization`, `Backup`, `Scaling`, `ReplicationGrpc`, `Tenancy`, `GrainIndex` |

### `LatticeDashboards`

| Member | Semantics |
|---|---|
| `string GetGrafanaDashboardJson(LatticeDashboardKind kind)` | Returns the Grafana dashboard JSON for `kind` as a UTF-8 string. The result is a complete Grafana dashboard model (panels, templating, time range) suitable for import. Throws `ArgumentOutOfRangeException` when `kind` is not a defined value. The call is synchronous and performs no I/O beyond reading an embedded resource. |
| `IReadOnlyList<LatticeDashboardKind> All` | Every dashboard kind shipped with the package, in declaration order. Use it to enumerate and export all dashboards in one pass. |

### `LatticeDashboardKind`

| Value | Source meter | Operator workflow |
|---|---|---|
| `Overview` | `orleans.lattice`, plus `Orleans.Lattice.Api.Mcp.RepoContext` for its exact-KNN panels | At-a-glance per-tree throughput, latency envelopes, cache hit-rate, tombstone churn, splits, split admission and forwarding, shard consolidation and healing, compaction, atomic-write outcomes, coordinator completions and phase-tick failures, lifecycle, events, and runtime configuration changes, plus storage footprint, WAL compression and saturation, snapshot, write-admission, distributed-lock, atomic-action (saga / TCC), grain-call contention, tree-registry, shard-root optimistic point-read and leaf-division panels, and three exact-KNN gather panels (work, wall time, and budget and gather outcomes) over the repository-context meter, which populate only where that package is hosted and its meter exported. Does not require the replication package. |
| `CommitPath` | `orleans.lattice` | WAL-first commit pipeline: per-step commit latency, leaf commit concurrency and per-observer latency, `SetAsync` / `SetManyAsync` envelope and stage breakdowns, the WAL append, writer-admission and shard-dispatch pipeline, storage-provider write latency, phase-2 commit, retries and timeouts, `LatticeSaturatedException` refusals by refusing seam and the replay-admission refusals by arm, compaction latency, scan-page coalescing and shard-root wedge guards, and leaf lifecycle diagnostics (materialiser pin path, activation and deactivation outcomes, snapshot capture and hydration, the WAL replay permit gate, deferred-terminal ledger refusals, the resident leaf working set, span fail-open commits, the WAL GC blocked-consumer population). |
| `Replication` | `orleans.lattice.replication`, plus `orleans.lattice` for its WAL, WAL-compaction and WAL GC panels | Cross-cluster operator view: ship / apply / lag durations, WAL ship vs trim throughput and the log-tailing producer's append vs ship rate, dead-letter churn, apply FIFO and causal violations, causal apply-buffer occupancy, fall-off-log events, per-peer cursor lag, batches in flight and wire version, and anti-entropy (digest probes, Merkle walks, leaf re-replay, drift remediation), bootstrap, shipping-optimisation and coordinated-restore panels. Its replication panels need the replication package registered on the silo; its WAL, WAL-compaction and WAL GC panels read the core meter. |
| `AtomicWrites` | `orleans.lattice` | `SetManyAtomicAsync` saga deep-dive: outcome rate, saga duration and batch-size percentiles, per-tree committed throughput, a dedicated saga-failure-rate panel, saga phase and per-key breakdowns, cross-tree atomic-write outcome, failure-rate, duration and fan-out panels, and saga decision registry write-rate, group-commit coalescing and write-duration panels. |
| `MaterialisedViews` | `orleans.lattice` | Cluster-wide materialised-view health: apply-lag and drain-backlog-depth percentiles, filter / re-project and aggregation apply throughput, and warning panels for lag-budget evictions, re-key collisions, atomic-staging backstop fall-backs, cross-tree joint-atomicity violations, source back-pressure self-throttling, and aggregation reserved-key rejections. Keyed by view name (and cluster); no per-silo filter, because a view's maintainer is a single grain activation that migrates between silos. Does not require the replication package. |
| `Authorization` | `orleans.lattice.auth`, `orleans.lattice.membership` | Identity and authorization operator view: enforcement-gate decision throughput (by effect and operation), decision-latency percentiles, compiled-snapshot rebuild rate and the snapshot epoch / age / subjects gauges, plus subject-resolution cache hit-ratio and hit / miss throughput and identity-directory search latency, hit / miss throughput and hit ratio. Useful only when the authentication / authorization packages are registered on the silo. |
| `Backup` | `orleans.lattice.backup` | Backup / restore operator view: capture / restore throughput and duration percentiles, per-backup size / artifact / entry distributions, cumulative processed throughput, retention reclaim and prune rates, incremental lag behind the base cut, capture / restore failure rates by reason, capture retries, scheduler skipped-run, overrun and capture-failure counters, cross-tree-consistent fence selection / drain / retry counters and drain-wait percentiles, and the inventory gauges. Useful only when the backup package is registered on the silo. |
| `Scaling` | `orleans.lattice.scaling` | Autoscaling-signal operator view: the smoothed scale-in-gated and raw instantaneous scale-value gauges, the three normalised compute-pressure dimensions (activation / host-resource / WAL-dispatch), the recommended silo replica count, and the storage-axis stats. Useful only when the scaling package is registered on the silo. |
| `ReplicationGrpc` | `orleans.lattice.replication.grpc` | Replication gRPC transport-security view: the insecure (plaintext) channel construction counter as a cluster-wide cumulative total and as a per-second rate broken out by peer cluster id and transport (push / saga_control / snapshot), so an accidental plaintext downgrade under `AllowPlaintextEndpoints` is visible. Useful only when the gRPC replication transport is registered on the silo. |
| `Tenancy` | `orleans.lattice.tenancy` | Per-tenant observability view: the registered-tenant count (cluster aggregate) and, dimensioned by tenant, the usage series (stored bytes, live keys, resident memory, owned trees), the quota ceilings and burst-headroom percentage, and the durable metered overage series (bytes / keys / memory / trees). A templated `tenant` variable scopes every per-tenant panel to one tenant or to all tenants; the registered-tenant count is a cluster aggregate and ignores it. Useful only when the tenancy package is registered on the silo. |
| `GrainIndex` | `orleans.lattice` | Grain-index operator view: each index's backfill lifecycle state and percent complete, its processed-versus-total crawl progress, its live entry count, onboarding throughput split by route (activation versus backfill), projection-latency percentiles, and index-write failure rates by route. A templated `index` variable scopes every panel to one index or to all of them. Sources the shared core meter - the grain-index package publishes no meter of its own - but the series appear only once the grain-index package is registered on the silo. |

## Enumerating every dashboard

```csharp verify
using Orleans.Lattice.Dashboards;

public static class DashboardExporter
{
    public static IEnumerable<(LatticeDashboardKind Kind, string Json)> ReadAll()
    {
        foreach (LatticeDashboardKind kind in LatticeDashboards.All)
        {
            string json = LatticeDashboards.GetGrafanaDashboardJson(kind);
            yield return (kind, json);
        }
    }
}
```

## See also

- [Configuration](configuration.md) - registering the meters the dashboards read and the provisioning templates.
- [Architecture](architecture.md) - how the JSON is embedded and drift-guarded.
- [Metric-to-panel map](metrics-to-panel-map.md) - the per-instrument coverage table.