querysub 0.456.0 → 0.458.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.456.0",
+  "version": "0.458.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/-a-archives/archivesBackBlaze.ts

@@ -516,8 +516,9 @@ export class ArchivesBackblaze {
         fnc: (api: B2Api) => Promise<T>,
         retries = 3
     ): Promise<T> {
-        let api = await this.getBucketAPI();
+        let api: B2Api | undefined;
         try {
+            api = await this.getBucketAPI();
             return await fnc(api);
         } catch (err: any) {
             if (retries <= 0) throw err;
@@ -570,19 +571,21 @@ export class ArchivesBackblaze {
             }
 
             if (err.stack.includes(`getaddrinfo ENOTFOUND`)) {
-                let urlObj = new URL(api.apiUrl);
-                let hostname = urlObj.hostname;
-                let lookupAddresses = await new Promise(resolve => {
-                    dns.lookup(hostname, (err, addresses) => {
-                        resolve(addresses);
+                if (api) {
+                    let urlObj = new URL(api.apiUrl);
+                    let hostname = urlObj.hostname;
+                    let lookupAddresses = await new Promise(resolve => {
+                        dns.lookup(hostname, (err, addresses) => {
+                            resolve(addresses);
+                        });
                     });
-                });
-                let resolveAddresses = await new Promise(resolve => {
-                    dns.resolve4(hostname, (err, addresses) => {
-                        resolve(addresses);
+                    let resolveAddresses = await new Promise(resolve => {
+                        dns.resolve4(hostname, (err, addresses) => {
+                            resolve(addresses);
+                        });
                     });
-                });
-                console.error(`[${context}] getaddrinfo ENOTFOUND ${hostname}`, { lookupAddresses, resolveAddresses, apiUrl: api.apiUrl, fullError: err.stack });
+                    console.error(`[${context}] getaddrinfo ENOTFOUND ${hostname}`, { lookupAddresses, resolveAddresses, apiUrl: api.apiUrl, fullError: err.stack });
+                }
             }
 
             // NOTE: The AI thought case that happens when we run out of retries, that's stupid. This obviously isn't the case. This is the case when it's a normal error, as in the file doesn't exist, we need to throw. We absolutely should not warn here. Warning here wouldn't be anything. It would just be saying, oh, we checked if a file and it didn't, which is normal, which is why we check if a file exists. 

package/src/-h-path-value-serialize/PathValueSerializer.ts

@@ -997,23 +997,23 @@ class PathValueSerializer {
     public getPathValue(pathValue: PathValue | undefined, noMutate?: "noMutate"): unknown {
         if (!pathValue) return undefined;
         if (pathValue.isValueLazy) {
-            // NOTE: If this throws, it likely means you used atomicObjectWrite.
-            //  Use atomicObjectWriteNoFreeze or doAtomicWrites instead.
-            if (!noMutate) {
-                try {
-                    pathValue.isValueLazy = false;
-                } catch { }
-            }
             let buffer = this.lazyValues.get(pathValue.value as {});
             if (!buffer) {
-                console.error(`Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
-                return pathValue.value;
+                throw new Error(`Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
             }
             let newValue = recursiveFreeze(cbor.decode(buffer));
-            if (!noMutate) {
+            if (!noMutate && !pathValue.isValueLazy) {
+                // NOTE: If this throws, it likely means you used atomicObjectWrite.
+                //  Use atomicObjectWriteNoFreeze or doAtomicWrites instead.
                 try {
+                    pathValue.isValueLazy = false;
                     pathValue.value = newValue;
-                } catch { }
+                } catch {
+                    // In theory, it could be that you can set the is value lazy property but not the value property. In which case we want to reset the isValazy property back. Otherwise, we will no longer try to deserialize it, and we will emit the lazy placeholder instead of the actual value next time.
+                    try {
+                        pathValue.isValueLazy = true;
+                    } catch { }
+                }
             }
             return newValue;
         }
@@ -1027,8 +1027,7 @@ class PathValueSerializer {
                 // NOTE: Did you pass a raw PathValue and then try to use PathValueSerializer with it?
                 //  - Instead you should pass a buffer serialized with pathValueSerializer.serialize and
                 //      deserialized with pathValueSerializer.deserialize.
-                console.error(`Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
-                return pathValue.value;
+                throw new Error(`Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
             }
             return buffer;
         }
@@ -1036,8 +1035,11 @@ class PathValueSerializer {
     }
 
     private getBuffer(pathValue: PathValue): Buffer {
-        let buffer = pathValue.isValueLazy && this.lazyValues.get(pathValue.value as {});
-        if (buffer) return buffer;
+        if (pathValue.isValueLazy) {
+            let buffer = this.lazyValues.get(pathValue.value as {});
+            if (!buffer) throw new Error(`Expected lazy value to have a buffer, but it didn't. Lazy ref has a typeof ${typeof pathValue.value} (${String(pathValue.value)})`);
+            return buffer;
+        }
         return cborEncoder().encode(pathValue.value);
     }
     public compareValuePaths(a: PathValue | undefined, b: PathValue | undefined) {

package/src/0-path-value-core/PathValueController.ts

@@ -23,6 +23,9 @@ import { debugGetAllCallFactories } from "socket-function/src/nodeCache";
 import { delay } from "socket-function/src/batching";
 export { pathValueCommitter };
 
+let pathValueSendCount = 0;
+export function getPathValueSendCount() { return pathValueSendCount; }
+
 // ONLY returns non-canGCValues that are valid
 export type AuditSnapshotEntry = {
     path: string;
@@ -47,6 +50,7 @@ export class PathValueControllerBase {
         const { Querysub } = await import("../4-querysub/Querysub");
         let { pathValues, nodeId } = config;
 
+        pathValueSendCount += pathValues.length;
         let serializedValues = await pathValueSerializer.serialize(pathValues, { compress: Querysub.COMPRESS_NETWORK });
         if (isDebugLogEnabled()) {
             for (let value of pathValues) {
@@ -70,6 +74,7 @@ export class PathValueControllerBase {
         nodeId: string;
         pathValues: PathValue[];
         initialTriggers?: { values: Set<string>; parentPaths: Set<string> },
+        reason: string;
     }) {
         let { nodeId, pathValues, initialTriggers } = config;
         if (isDebugLogEnabled()) {
@@ -88,6 +93,7 @@ export class PathValueControllerBase {
                     initialTrigger: initialTriggers?.values.has(pathValue.path),
                     triggerId: nextId(),
                     totalChanges: pathValues.length,
+                    reason: config.reason,
                 });
             }
         }
@@ -96,14 +102,16 @@ export class PathValueControllerBase {
         nodeId: string;
         pathValues: PathValue[];
         initialTriggers?: { values: Set<string>; parentPaths: Set<string> },
+        reason: string;
     }) {
         let changes = config.pathValues;
         let { nodeId, initialTriggers } = config;
+        pathValueSendCount += changes.length;
         let buffers = await pathValueSerializer.serialize(changes, {
             noLocks: true,
             compress: getCompressNetwork(),
         });
-        this.logSendValues({ nodeId, pathValues: changes, initialTriggers, });
+        this.logSendValues({ nodeId, pathValues: changes, initialTriggers, reason: config.reason });
         return await PathValueController.nodes[nodeId].sendData({
             valueBuffers: buffers,
             initialTriggers: initialTriggers,
@@ -201,6 +209,7 @@ export class PathValueControllerBase {
                 await timeoutToError(timeInSecond * 15, PathValueControllerBase.sendValues({
                     nodeId: otherAuthority,
                     pathValues: values,
+                    reason: "authorityShareValues",
                 }), () => new Error(`Timeout forwarding shared values (${values.length} values) to authority ${otherAuthority}`));
             } catch (error: any) {
                 console.error(error.message, { otherAuthority, count: values.length });

package/src/0-path-value-core/PathWatcher.ts

@@ -494,6 +494,7 @@ class PathWatcher {
                     nodeId: watcher,
                     pathValues: changes,
                     initialTriggers: initialTriggers,
+                    reason: "triggerLatestWatcher",
                 });
             })());
         }

package/src/0-path-value-core/pathValueCore.ts

@@ -746,7 +746,7 @@ class AuthorityPathValueStorage {
 
         if (isDebugLogEnabled() && !config?.doNotArchive) {
             for (let value of newValues) {
-                auditLog("INGEST VALUE", { path: value.path, timeId: value.time.time });
+                auditLog("INGEST VALUE", { path: value.path, timeId: value.time.time, batchTime: now });
             }
         }
 

package/src/3-path-functions/PathFunctionRunner.ts

@@ -26,6 +26,11 @@ import { getRoutingOverride, getRoutingOverridePart } from "../0-path-value-core
 import { PathRouter } from "../0-path-value-core/PathRouter";
 setImmediate(() => import("../4-querysub/Querysub"));
 
+let functionCallOuterCount = 0;
+let functionCallInnerCount = 0;
+export function getFunctionCallOuterCount() { return functionCallOuterCount; }
+export function getFunctionCallInnerCount() { return functionCallInnerCount; }
+
 export const functionSchema = rawSchema<{
     [domainName: string]: {
         PathFunctionRunner: {
@@ -520,6 +525,7 @@ export class PathFunctionRunner {
 
         stats.isInsideRunCall = true;
         stats.outerLoopCount++;
+        functionCallOuterCount++;
         try {
             await this.runCallBase(callSpec, functionSpec, stats);
         } finally {
@@ -647,6 +653,7 @@ export class PathFunctionRunner {
                         runCount++;
                         stats.lastInternalLoopCount = runCount;
                         stats.totalInternalLoopCount++;
+                        functionCallInnerCount++;
                         if (PathFunctionRunner.DEBUG_CALLS) {
                             console.log(`Evaluating (try count ${runCount}) ${debugNameColored}`);
                         }

package/src/4-querysub/QuerysubController.ts

@@ -488,6 +488,7 @@ export class QuerysubControllerBase {
                         values: new Set(undefinedValues.map(value => value.path)),
                         parentPaths: new Set(newParentPathsNotAllowed)
                     },
+                    reason: "QuerysubController.watch disallowed paths (permissions)",
                 }));
             }
 

package/src/5-diagnostics/gross-stats/grossStats.ts

@@ -0,0 +1,102 @@
+// Gross cluster statistics — per-minute counters of high-level activity, kept for a
+//  week per-node and polled by the management UI. See managementPages.tsx GrossStatsInfo / GrossStatsPage.
+//
+// Sources of stats live in their own modules and just maintain monotonic counters; this file
+//  imports those counters and samples them once a minute, recording deltas against the
+//  previous sample. Sources never depend on this file.
+
+import { SocketFunction } from "socket-function/SocketFunction";
+import { runInfinitePoll } from "socket-function/src/batching";
+import { timeInMinute } from "socket-function/src/misc";
+import { isNode } from "typesafecss";
+import { getFunctionCallInnerCount, getFunctionCallOuterCount } from "../../3-path-functions/PathFunctionRunner";
+import { getPathValueSendCount } from "../../0-path-value-core/PathValueController";
+import { getLogWriteCount } from "../../diagnostics/logs/diskLogger";
+
+export const GROSS_STATS_FIELDS = [
+    "functionCallsInner",
+    "functionCallsOuter",
+    "pathValuesSent",
+    "socketCalls",
+    "socketUploadBytes",
+    "socketDownloadBytes",
+    "socketCallTimeMs",
+    "logsWritten",
+] as const;
+export type GrossStatsField = typeof GROSS_STATS_FIELDS[number];
+
+export type GrossStatsBucket = {
+    // Epoch ms of the END of the minute this bucket covers
+    time: number;
+    deltas: Record<GrossStatsField, number>;
+};
+
+const BUCKETS_PER_WEEK = 60 * 24 * 7;
+
+function zeroCounts(): Record<GrossStatsField, number> {
+    let out = {} as Record<GrossStatsField, number>;
+    for (let field of GROSS_STATS_FIELDS) out[field] = 0;
+    return out;
+}
+
+// socketUploadBytes / socketDownloadBytes / socketCallTimeMs come from SocketFunction callbacks
+//  rather than a foreign module's counter, so we maintain monotonic running totals locally.
+let socketTotals = { uploadBytes: 0, downloadBytes: 0, callTimeMs: 0 };
+let socketHooksInstalled = false;
+function installSocketHooks() {
+    if (socketHooksInstalled) return;
+    socketHooksInstalled = true;
+    SocketFunction.trackMessageSizes.upload.push(size => {
+        socketTotals.uploadBytes += size;
+    });
+    SocketFunction.trackMessageSizes.download.push(size => {
+        socketTotals.downloadBytes += size;
+    });
+    SocketFunction.trackMessageSizes.callTimes.push(({ start, end }) => {
+        socketTotals.callTimeMs += Math.max(0, end - start);
+    });
+}
+
+function readCurrentTotals(): Record<GrossStatsField, number> {
+    return {
+        functionCallsInner: getFunctionCallInnerCount(),
+        functionCallsOuter: getFunctionCallOuterCount(),
+        pathValuesSent: getPathValueSendCount(),
+        socketCalls: SocketFunction.TOTAL_CALLS,
+        socketUploadBytes: socketTotals.uploadBytes,
+        socketDownloadBytes: socketTotals.downloadBytes,
+        socketCallTimeMs: socketTotals.callTimeMs,
+        logsWritten: getLogWriteCount(),
+    };
+}
+
+let prevSnapshot = zeroCounts();
+let buckets: GrossStatsBucket[] = [];
+
+function sampleMinute() {
+    let snapshot = readCurrentTotals();
+    let deltas = {} as Record<GrossStatsField, number>;
+    for (let field of GROSS_STATS_FIELDS) {
+        deltas[field] = snapshot[field] - prevSnapshot[field];
+    }
+    prevSnapshot = snapshot;
+    buckets.push({ time: Date.now(), deltas });
+    if (buckets.length > BUCKETS_PER_WEEK) {
+        buckets.splice(0, buckets.length - BUCKETS_PER_WEEK);
+    }
+}
+
+if (isNode()) {
+    installSocketHooks();
+    prevSnapshot = readCurrentTotals();
+    void runInfinitePoll(timeInMinute, sampleMinute);
+}
+
+export function getGrossStatsBuckets(sinceTime?: number): GrossStatsBucket[] {
+    if (sinceTime === undefined) return buckets;
+    let i = 0;
+    while (i < buckets.length && buckets[i].time <= sinceTime) {
+        i++;
+    }
+    return i === 0 ? buckets : buckets.slice(i);
+}

package/src/deployManager/machineApplyMainCode.ts

@@ -984,13 +984,7 @@ export async function machineApplyMain() {
     await Querysub.hostService("machine-apply");
     onServiceConfigChange(resyncServices);
 
-    runInfinitePoll(DEBUGGER_WEDGE_POLL_INTERVAL, async () => {
-        try {
-            await unwedgeStuckDebuggerScreens();
-        } catch (e: any) {
-            console.error(`Error in debugger-wedge watcher: ${e.stack ?? e}`);
-        }
-    });
+    runInfinitePoll(DEBUGGER_WEDGE_POLL_INTERVAL, unwedgeStuckDebuggerScreens);
 
     runInfinitePoll(timeInMinute * 3, async () => {
         //console.log(magenta(`Quick outdated check at ${new Date().toISOString()}`));

package/src/diagnostics/auditDiskValues.ts

@@ -184,7 +184,7 @@ export async function auditDiskValues(spec: AuthoritySpec) {
     if (valuesToSync.length > 0) {
         let valuesPerAuthority = PathRouter.getAllAuthoritiesForValues(valuesToSync);
         for (let [authorityNodeId, values] of valuesPerAuthority) {
-            await PathValueControllerBase.sendValues({ nodeId: authorityNodeId, pathValues: values });
+            await PathValueControllerBase.sendValues({ nodeId: authorityNodeId, pathValues: values, reason: "auditDiskValues" });
         }
     }
     let timeSync = Date.now() - timeStartSync;

package/src/diagnostics/grossStats/GrossStatsController.ts

@@ -0,0 +1,111 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { lazy } from "socket-function/src/caching";
+import { runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { timeInHour, timeInMinute, timeInSecond } from "socket-function/src/misc";
+import { assertIsManagementUser } from "../managementPages";
+import {
+    getGrossStatsBuckets,
+    GrossStatsBucket,
+    GrossStatsField,
+    GROSS_STATS_FIELDS,
+} from "../../5-diagnostics/gross-stats/grossStats";
+import { getOwnNodeId, isOwnNodeId } from "../../-f-node-discovery/NodeDiscovery";
+import { authorityLookup } from "../../0-path-value-core/AuthorityLookup";
+import { timeoutToUndefinedSilent } from "../../errors";
+
+const POLL_INTERVAL = timeInMinute;
+const PER_NODE_TIMEOUT = 30 * timeInSecond;
+const HEADER_WINDOW_MS = 60 * timeInMinute;
+const RETENTION_MS = 7 * 24 * timeInHour;
+
+let polledBuckets: Map<string, GrossStatsBucket[]> = new Map();
+
+async function listClusterNodeIds(): Promise<string[]> {
+    let topology = await authorityLookup.getTopology();
+    let ids = new Set<string>();
+    for (let entry of topology) ids.add(entry.nodeId);
+    ids.add(getOwnNodeId());
+    return Array.from(ids);
+}
+
+async function pollOnce() {
+    let nodeIds = await listClusterNodeIds();
+    let cutoff = Date.now() - RETENTION_MS;
+    await Promise.all(nodeIds.map(async nodeId => {
+        if (isOwnNodeId(nodeId)) {
+            polledBuckets.set(nodeId, getGrossStatsBuckets().filter(b => b.time >= cutoff));
+            return;
+        }
+        let prev = polledBuckets.get(nodeId);
+        let sinceTime = prev && prev.length > 0 ? prev[prev.length - 1].time : undefined;
+
+        let result = await timeoutToUndefinedSilent(
+            PER_NODE_TIMEOUT,
+            GrossStatsController.nodes[nodeId].getGrossStatsLocal({ sinceTime }),
+        );
+        let merged = prev ? (result ? prev.concat(result.buckets) : prev) : (result?.buckets ?? []);
+        merged = merged.filter(b => b.time >= cutoff);
+        polledBuckets.set(nodeId, merged);
+    }));
+}
+
+let ensurePolling = lazy(() => {
+    void runInfinitePollCallAtStart(POLL_INTERVAL, pollOnce);
+});
+
+class GrossStatsControllerBase {
+    public async getGrossStatsLocal(config?: { sinceTime?: number }): Promise<{
+        nodeId: string;
+        buckets: GrossStatsBucket[];
+    }> {
+        return {
+            nodeId: getOwnNodeId(),
+            buckets: getGrossStatsBuckets(config?.sinceTime),
+        };
+    }
+
+    /** Trampoline: returns the latest polled buckets for every node in the cluster.
+     *  Starts the background poller on first call. */
+    public async getGrossStats(): Promise<{
+        bucketsByNode: Map<string, GrossStatsBucket[]>;
+    }> {
+        ensurePolling();
+        return { bucketsByNode: new Map(polledBuckets) };
+    }
+
+    /** Trampoline: computes the cluster-wide per-second sum over the last hour from polled buckets.
+     *  Cheap — at ~100 nodes × ~60 buckets/hour = ~6000 numbers per field. */
+    public async getGrossStatsHeaderSummary(): Promise<{
+        clusterSum: Record<GrossStatsField, number>;
+    }> {
+        ensurePolling();
+        let windowStart = Date.now() - HEADER_WINDOW_MS;
+        let windowSec = HEADER_WINDOW_MS / 1000;
+
+        let clusterSum = {} as Record<GrossStatsField, number>;
+        for (let f of GROSS_STATS_FIELDS) clusterSum[f] = 0;
+        for (let buckets of polledBuckets.values()) {
+            for (let bucket of buckets) {
+                if (bucket.time < windowStart) continue;
+                for (let f of GROSS_STATS_FIELDS) {
+                    clusterSum[f] += bucket.deltas[f];
+                }
+            }
+        }
+        for (let f of GROSS_STATS_FIELDS) clusterSum[f] /= windowSec;
+        return { clusterSum };
+    }
+}
+
+export const GrossStatsController = SocketFunction.register(
+    "GrossStatsController-0193f8aa-7b91-7402-a4be-91a4b1f9c93d",
+    new GrossStatsControllerBase(),
+    () => ({
+        getGrossStatsLocal: { compress: true },
+        getGrossStats: { compress: true },
+        getGrossStatsHeaderSummary: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    }),
+);

package/src/diagnostics/grossStats/GrossStatsInfo.tsx

@@ -0,0 +1,95 @@
+import { qreact } from "../../4-dom/qreact";
+import { css } from "../../4-dom/css";
+import { formatNumber } from "socket-function/src/formatting/format";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { timeInMinute } from "socket-function/src/misc";
+import { isCurrentUserSuperUser } from "../../user-implementation/userData";
+import { ATag } from "../../library-components/ATag";
+import { managementPageURL, showingManagementURL } from "../managementPages";
+import { getSyncedController } from "../../library-components/SyncedController";
+import { GrossStatsController } from "./GrossStatsController";
+import { GrossStatsField } from "../../5-diagnostics/gross-stats/grossStats";
+
+module.hotreload = true;
+
+const REFRESH_INTERVAL_MS = 5 * timeInMinute;
+
+const HEADER_FIELDS: GrossStatsField[] = [
+    "functionCallsInner",
+    "pathValuesSent",
+    "socketCalls",
+    "socketUploadBytes",
+    "socketDownloadBytes",
+    "socketCallTimeMs",
+    "logsWritten",
+];
+const FIELD_GLYPHS: Partial<Record<GrossStatsField, string>> = {
+    functionCallsInner: "⚡",
+    pathValuesSent: "📤",
+    socketCalls: "📞",
+    socketUploadBytes: "⬆",
+    socketDownloadBytes: "⬇",
+    socketCallTimeMs: "⏱",
+    logsWritten: "📝",
+};
+const FIELD_TITLES: Partial<Record<GrossStatsField, string>> = {
+    functionCallsInner: "Function calls per second, last hour",
+    pathValuesSent: "Path values sent per second, last hour",
+    socketCalls: "SocketFunction calls per second, last hour",
+    socketUploadBytes: "Upload bytes per second, last hour",
+    socketDownloadBytes: "Download bytes per second, last hour",
+    socketCallTimeMs: "SocketFunction call time ms per second, last hour",
+    logsWritten: "Log entries per second, last hour",
+};
+
+function formatField(field: GrossStatsField, value: number): string {
+    if (field === "socketUploadBytes" || field === "socketDownloadBytes") {
+        if (value >= 1024 * 1024) return `${(value / 1024 / 1024).toFixed(2)}MB`;
+        if (value >= 1024) return `${(value / 1024).toFixed(1)}KB`;
+        return `${value.toFixed(0)}B`;
+    }
+    if (field === "socketCallTimeMs") {
+        return `${value.toFixed(1)}ms`;
+    }
+    return formatNumber(value);
+}
+
+let grossStatsController = getSyncedController(GrossStatsController);
+
+export class GrossStatsInfo extends qreact.Component {
+    refreshTimer: ReturnType<typeof setInterval> | undefined;
+    componentDidMount() {
+        this.refreshTimer = setInterval(() => {
+            grossStatsController.refreshAll();
+        }, REFRESH_INTERVAL_MS);
+    }
+    componentWillUnmount() {
+        if (this.refreshTimer) clearInterval(this.refreshTimer);
+    }
+    render() {
+        if (!isCurrentUserSuperUser()) return undefined;
+
+        let result = grossStatsController(SocketFunction.browserNodeId()).getGrossStatsHeaderSummary();
+        if (!result) return undefined;
+
+        let parts: preact.ComponentChild[] = [];
+        for (let field of HEADER_FIELDS) {
+            parts.push(
+                <span title={FIELD_TITLES[field]}>
+                    {formatField(field, result.clusterSum[field])}{FIELD_GLYPHS[field]}
+                </span>
+            );
+        }
+
+        return <ATag
+            className={css.button.hbox(7).pad2(4)}
+            values={[
+                showingManagementURL.getOverride(true),
+                managementPageURL.getOverride("GrossStatsPage"),
+            ]}
+            title="Cluster activity per second over the past hour. Click for detail."
+        >
+            {parts}
+        </ATag>;
+    }
+}