Function useClusterFreshness

console/src/platform/clusters/queries.ts:582–685

({
  lookbackMs,
  clusterId,
}: ClusterFreshnessParams)

export const LINE_MAX_COUNT = 10;

export function useClusterFreshness({
  lookbackMs,
  clusterId,
}: ClusterFreshnessParams) {
  return useSuspenseQuery({
    queryKey: clusterQueryKeys.clusterFreshness({
      lookbackMs,
      clusterId,
    }),
    queryFn: async ({ queryKey, signal }) => {
      const { rows } = await fetchLagHistory({
        params: {
          lookback: {
            type: "historical",
            lookbackMs,
          },
          clusterId,
          includeSystemObjects: isSystemCluster(clusterId),
        },
        requestOptions: { signal },
        queryKey,
      });

      const dataByObjectId = flatGroup(rows, (d) => d.objectId);

      const currentData = dataByObjectId
        .map(([_, rowsByObjectId]) => {
          // We can assume the last row is the most current because the data is sorted
          // by bucket start time.
          const lastRow = rowsByObjectId.at(-1);
          if (!lastRow) {
            return null;
          }
          return lastRow;
        })
        .filter(notNullOrUndefined)
        .sort(sortLagInfo)
        .slice(0, LINE_MAX_COUNT);

      const dataByBucketStart = group(rows, (d) => d.bucketStart.getTime());

      const historicalData = [...dataByBucketStart.entries()].map(
        ([timestamp, rowsByBucketStart]) => {
          const dataPoint: DataPoint = {
            timestamp,
            lag: {},
          };

          rowsByBucketStart.forEach((row) => {
            dataPoint.lag[row.objectId] =
              row.lag !== null
                ? {
                    queryable: true,
                    totalMs: sumPostgresIntervalMs(row.lag),
                    interval: row.lag,
                    schemaName: row.schemaName,
                    objectName: row.objectName,
                  }