History is kept by flow id: runs, cascades, rollups and events file the id in their flow column and nodes as <flow id>.<node>, the API answers flow plus flow_name and shows and takes nodes as <key>.<node>; events carry flow_id from the moment they are published; run queue items, the stage cache and cached curves keep ids and keys apart; endpoints, the brain graph, device bindings and search name the id to open
This commit is contained in:
@@ -28,6 +28,7 @@ from fluksio.api.deps import (
|
||||
from fluksio.api.routes.runs import elapsed_ms
|
||||
from fluksio.core.config import settings
|
||||
from fluksio.flow.controller import NodeStatus
|
||||
from fluksio.flow.tombstones import names_of, shown_nodes, stored_node
|
||||
from fluksio.models import EngineEvent, FlowRun, Message, MetricBucket
|
||||
|
||||
router = APIRouter(
|
||||
@@ -77,7 +78,9 @@ class SeriesPoint(BaseModel):
|
||||
|
||||
|
||||
class FlowRollup(BaseModel):
|
||||
#: The flow's id, and its key: what it is called now, or was last called.
|
||||
flow: str
|
||||
flow_name: str = ""
|
||||
executions: int
|
||||
errors: int
|
||||
messages: int
|
||||
@@ -100,7 +103,9 @@ class NodeTypeTiming(BaseModel):
|
||||
|
||||
class RunRow(BaseModel):
|
||||
id: str
|
||||
#: The flow's id, and its key as `FlowRollup` has it.
|
||||
flow: str
|
||||
flow_name: str = ""
|
||||
source: str
|
||||
#: The run this one continues: for a flush, the run whose value it released.
|
||||
parent: str = ""
|
||||
@@ -130,7 +135,11 @@ class EventRow(BaseModel):
|
||||
id: int
|
||||
ts: datetime
|
||||
type: str
|
||||
#: The flow's id, and its key as `FlowRollup` has it. Both empty for the
|
||||
#: engine as a whole.
|
||||
flow: str
|
||||
flow_name: str = ""
|
||||
#: ``<key>.<node>``, or empty.
|
||||
node: str
|
||||
detail: str
|
||||
actor: str
|
||||
@@ -138,6 +147,8 @@ class EventRow(BaseModel):
|
||||
|
||||
|
||||
class DeadLetter(BaseModel):
|
||||
"""A work item given up on, named as the engine runs it: by key."""
|
||||
|
||||
id: str
|
||||
ts: float
|
||||
flow: str
|
||||
@@ -317,6 +328,7 @@ async def read_summary(request: Request, controller: FlowControllerDep) -> Any:
|
||||
@router.get("/timeseries", response_model=list[SeriesPoint])
|
||||
def read_timeseries(
|
||||
session: SessionDep,
|
||||
controller: FlowControllerDep,
|
||||
flow: str | None = None,
|
||||
node: str | None = None,
|
||||
hours: Annotated[int, Query(ge=0, le=8760)] = 24,
|
||||
@@ -331,6 +343,8 @@ def read_timeseries(
|
||||
the same pair ``/runs`` and ``/events`` take — so a chart dragged to a
|
||||
span can be re-fetched at that span's own resolution rather than
|
||||
magnifying the buckets it already has.
|
||||
|
||||
``flow`` is a flow id, ``node`` a ``<key>.<node>`` as the engine names it.
|
||||
"""
|
||||
hours = _window_hours(hours)
|
||||
# The database does the fold: a week of minute rows per node used to cross
|
||||
@@ -356,9 +370,10 @@ def read_timeseries(
|
||||
col(MetricBucket.bucket) < (_aware(until) if until else _closed_before(stride)),
|
||||
)
|
||||
if flow:
|
||||
statement = statement.where(col(MetricBucket.flow) == flow)
|
||||
statement = statement.where(col(MetricBucket.flow_id) == flow)
|
||||
if node:
|
||||
statement = statement.where(col(MetricBucket.node) == node)
|
||||
stored = stored_node(node, controller.store, flow or "")
|
||||
statement = statement.where(col(MetricBucket.node) == stored)
|
||||
|
||||
return [
|
||||
SeriesPoint(
|
||||
@@ -376,7 +391,9 @@ def read_timeseries(
|
||||
|
||||
@router.get("/flows", response_model=list[FlowRollup])
|
||||
def read_flow_rollups(
|
||||
session: SessionDep, hours: Annotated[int, Query(ge=0, le=8760)] = 24
|
||||
session: SessionDep,
|
||||
controller: FlowControllerDep,
|
||||
hours: Annotated[int, Query(ge=0, le=8760)] = 24,
|
||||
) -> Any:
|
||||
"""One row per flow, with a coarse trend of how much it ran."""
|
||||
hours = _window_hours(hours)
|
||||
@@ -399,7 +416,7 @@ def read_flow_rollups(
|
||||
).label("slot")
|
||||
statement = (
|
||||
sa_select(
|
||||
col(MetricBucket.flow),
|
||||
col(MetricBucket.flow_id),
|
||||
slot,
|
||||
func.sum(col(MetricBucket.executions)).label("executions"),
|
||||
func.sum(col(MetricBucket.errors)).label("errors"),
|
||||
@@ -412,13 +429,13 @@ def read_flow_rollups(
|
||||
col(MetricBucket.bucket) >= since,
|
||||
col(MetricBucket.bucket) < datetime.fromtimestamp(float(end), UTC),
|
||||
)
|
||||
.group_by(col(MetricBucket.flow), slot)
|
||||
.group_by(col(MetricBucket.flow_id), slot)
|
||||
)
|
||||
|
||||
rollups: dict[str, dict[str, Any]] = {}
|
||||
for row in session.execute(statement):
|
||||
entry = rollups.setdefault(
|
||||
row.flow,
|
||||
row.flow_id,
|
||||
{
|
||||
"executions": 0,
|
||||
"errors": 0,
|
||||
@@ -448,15 +465,17 @@ def read_flow_rollups(
|
||||
# mapping and subscript it.
|
||||
last_errors = dict(
|
||||
session.exec(
|
||||
select(col(EngineEvent.flow), func.max(col(EngineEvent.ts)))
|
||||
select(col(EngineEvent.flow_id), func.max(col(EngineEvent.ts)))
|
||||
.where(col(EngineEvent.type) == "node_error", col(EngineEvent.ts) >= since)
|
||||
.group_by(col(EngineEvent.flow))
|
||||
.group_by(col(EngineEvent.flow_id))
|
||||
).all()
|
||||
)
|
||||
|
||||
names = names_of(rollups, controller.store)
|
||||
return [
|
||||
FlowRollup(
|
||||
flow=flow,
|
||||
flow_name=names[flow],
|
||||
executions=entry["executions"],
|
||||
errors=entry["errors"],
|
||||
messages=entry["messages"],
|
||||
@@ -483,8 +502,9 @@ def read_node_type_timings(
|
||||
flows. A node deleted since it ran has no type left to count under.
|
||||
"""
|
||||
hours = _window_hours(hours)
|
||||
# By `<flow id>.<node>`, the way the rollups name a node.
|
||||
types = {
|
||||
f"{flow.name}.{node.id}": node.type
|
||||
f"{flow.id}.{node.id}": node.type
|
||||
for flow in controller.store.read_all()
|
||||
for node in flow.nodes
|
||||
}
|
||||
@@ -526,6 +546,7 @@ def read_node_type_timings(
|
||||
@router.get("/runs", response_model=RunPage)
|
||||
def read_runs(
|
||||
session: SessionDep,
|
||||
controller: FlowControllerDep,
|
||||
flow: str | None = None,
|
||||
status: str | None = None,
|
||||
since: datetime | None = None,
|
||||
@@ -536,10 +557,11 @@ def read_runs(
|
||||
|
||||
``since`` is inclusive and ``until`` exclusive, so a window of one minute
|
||||
holds exactly the runs of the minute bucket the charts are drawn from.
|
||||
``flow`` is a flow id.
|
||||
"""
|
||||
filters: list[ColumnElement[bool]] = []
|
||||
if flow:
|
||||
filters.append(col(FlowRun.flow) == flow)
|
||||
filters.append(col(FlowRun.flow_id) == flow)
|
||||
if status:
|
||||
filters.append(col(FlowRun.status) == status)
|
||||
if since:
|
||||
@@ -563,12 +585,20 @@ def read_runs(
|
||||
).one()
|
||||
)
|
||||
)
|
||||
return {"data": rows, "count": count}
|
||||
names = names_of({row.flow_id for row in rows}, controller.store)
|
||||
data = [
|
||||
RunRow.model_validate(
|
||||
{**row.model_dump(), "flow": row.flow_id, "flow_name": names[row.flow_id]}
|
||||
)
|
||||
for row in rows
|
||||
]
|
||||
return {"data": data, "count": count}
|
||||
|
||||
|
||||
@router.get("/events", response_model=list[EventRow])
|
||||
def read_events(
|
||||
session: SessionDep,
|
||||
controller: FlowControllerDep,
|
||||
kind: Literal["failure", "audit"] = "failure",
|
||||
flow: str | None = None,
|
||||
run: str | None = None,
|
||||
@@ -582,7 +612,8 @@ def read_events(
|
||||
takes, so a list can cover the span the charts beside it are drawn from.
|
||||
``run`` narrows to one run — a batch run's id, or the journaled item a live
|
||||
cascade came from. Rows recorded before the column existed carry none, so
|
||||
an old failure answers no run at all rather than the wrong one.
|
||||
an old failure answers no run at all rather than the wrong one. ``flow``
|
||||
is a flow id.
|
||||
"""
|
||||
statement = select(EngineEvent).order_by(col(EngineEvent.ts).desc())
|
||||
if kind == "audit":
|
||||
@@ -590,14 +621,28 @@ def read_events(
|
||||
else:
|
||||
statement = statement.where(col(EngineEvent.type) != "audit")
|
||||
if flow:
|
||||
statement = statement.where(col(EngineEvent.flow) == flow)
|
||||
statement = statement.where(col(EngineEvent.flow_id) == flow)
|
||||
if run:
|
||||
statement = statement.where(col(EngineEvent.run) == run)
|
||||
if since:
|
||||
statement = statement.where(col(EngineEvent.ts) >= _aware(since))
|
||||
if until:
|
||||
statement = statement.where(col(EngineEvent.ts) < _aware(until))
|
||||
return list(session.exec(statement.limit(min(limit, 500))))
|
||||
rows = list(session.exec(statement.limit(min(limit, 500))))
|
||||
store = controller.store
|
||||
names = names_of({row.flow_id for row in rows if row.flow_id}, store)
|
||||
nodes = shown_nodes({row.node for row in rows if row.node}, store)
|
||||
return [
|
||||
EventRow.model_validate(
|
||||
{
|
||||
**row.model_dump(),
|
||||
"flow": row.flow_id,
|
||||
"flow_name": names.get(row.flow_id, ""),
|
||||
"node": nodes.get(row.node, ""),
|
||||
}
|
||||
)
|
||||
for row in rows
|
||||
]
|
||||
|
||||
|
||||
@router.get("/dead-letter", response_model=list[DeadLetter])
|
||||
|
||||
Reference in New Issue
Block a user