+ {value} + {of && {of}} +
+ {meter &&Service health
++ {at ? `Updated at ${clockUtc(at)}. Checks again every ${EVERY} seconds by itself.` : "Asking the server for its numbers."} + {failedAt && ( + + {" "} + The check at {clockUtc(failedAt)} got no answer{data ? ", so these are the last numbers that came in" : ""}. The page + keeps trying. + + )} +
++ The same as JSON{full ? "" : ", for scripts and uptime monitors"}: {url}. Times are in UTC. +
+Cards are being drawn and served. Cards already on a profile keep showing even while the service restarts.
++ GitHub asks us to slow down. Reading starts again in {mins(back)}, at {utc(now + back)}. + Until then cards show the last stats they had. +
+ ) : ( +When a card gets old, its stats are read from GitHub again, so every card stays close to current.
+ )} ++ Many people are trying questlog right now. A new user sees the busy card and gets in at the next opening, in{" "} + {mins(next)}, at {utc(now + next)}. +
+ ) : ( +A new user's first card shows a short wait message, then the real card a few seconds later.
+ )} ++ Refills in {mins(resetIn)}, at {utc(g.resets_at!)}. +
+ ) : ( +GitHub reports the quota with each fetch; nothing has been fetched since the last start.
+ )} + {g.paused_secs > 0 && ( ++ Fetching is paused for {mins(g.paused_secs)} to save the quota. New users see a wait message until then. +
+ )} +Each new or refreshed user costs a few points. Cards already drawn cost nothing.
++ {num(Math.max(0, nu.per_hour - nu.this_hour))} more first-time users can come in this hour. +
+ {freeIn !== null && freeIn > 0 && ( ++ The hour slides: the next place frees in {mins(freeIn)}, at {utc(now + freeIn)}. +
+ )} +Past the cap a new user sees the busy card and gets in a little later. People already on the list are never held back.
++ The line for new users holds {num(w.new_capacity)}. Refreshes of known users wait in their own line:{" "} + {num(w.refresh)} of {num(w.refresh_capacity)}. +
+While a refresh waits, its card keeps showing the last stats.
++ A card that is not in the cache takes a slot for a moment. When both are taken, a request waits up to 2 seconds, then + gets the busy card for a minute. +
++ {mb(c.bytes)} of {mb(c.budget)} used. Since the last start {rate}% of cards came from the cache ( + {num(c.hits)} found, {num(c.misses)} drawn). +
+Every drawn card is also saved on disk, so it is drawn once per version.
++ Version {d.version}, started at {utc(d.started_at)} on{" "} + {new Date(d.started_at * 1000).toISOString().slice(0, 10)}, with {d.scenes.length} scenes. +
+A start clears the in-memory cache; cards saved on disk come back at once.
++ {num(d.users.in_memory)} of them asked for since the last start. {num(d.users.unknown)}{" "} + {d.users.unknown === 1 ? "name was" : "names were"} not on GitHub in the last hour. +
++ {d.held > 0 + ? `${num(d.held)} held after failed GitHub fetches; their cards say the road is closed for 10 minutes.` + : "No user is held after failed fetches."} +
++ Saved cards on disk: {d.cache.disk_bytes === null ? "none" : mb(d.cache.disk_bytes)} of{" "} + {mb(d.cache.disk_budget)}. Past that, the hourly trim removes the least recently used. +
+Requests Cloudflare answers from its own cache never reach the server, so they are not counted here.
+
+ The last {num(lines.length)} lines since the start, newest first. The full log is in Portainer or docker logs questlog.
+
{lines.length ? "No line matches. Clear the search or the filter." : "Nothing logged yet."}
+ )} +