decomposer: generate deliverable files for Define the service contract and project architecture for the FastAPI endpoint monitoring service.; Implement the typed monitor CRUD API and concurrency-safe in-memory state according to the service design.; Implement secure on-demand endpoint checks with status updates, latency measurement, robust error handling, and redacted structured logs.; Add operational API endpoints and environment-driven runtime configuration to the monitoring service.; Create automated tests for the monitoring service.; Package the service with Docker and developer documentation.; Validate the complete project.

app/store.py

@@ -1,63 +1,58 @@
 import asyncio
 from uuid import UUID, uuid4
 
-from app.models import CurrentStatus, Monitor, MonitorCreate, MonitorUpdate, utc_now
+from .models import CheckSnapshot, Monitor, MonitorInput, now
+
+
+class StoreFullError(Exception):
+    pass
 
 
 class MonitorStore:
-    def __init__(self) -> None:
-        self._lock = asyncio.Lock()
+    def __init__(self, max_monitors: int) -> None:
         self._items: dict[UUID, Monitor] = {}
+        self._lock = asyncio.Lock()
+        self._max = max_monitors
 
-    async def create(self, value: MonitorCreate) -> Monitor:
-        now = utc_now()
-        item = Monitor(
-            id=uuid4(), name=value.name, url=value.url, created_at=now, updated_at=now, revision=1
-        )
+    async def create(self, data: MonitorInput) -> Monitor:
         async with self._lock:
+            if len(self._items) >= self._max:
+                raise StoreFullError
+            timestamp = now()
+            item = Monitor(id=uuid4(), **data.model_dump(), created_at=timestamp,
+                           updated_at=timestamp, revision=1, status=CheckSnapshot())
             self._items[item.id] = item
-        return item.model_copy(deep=True)
+            return item
 
     async def list(self) -> list[Monitor]:
         async with self._lock:
-            values = sorted(self._items.values(), key=lambda item: item.created_at)
-            return [item.model_copy(deep=True) for item in values]
+            return sorted(self._items.values(), key=lambda item: item.created_at)
 
     async def get(self, monitor_id: UUID) -> Monitor | None:
         async with self._lock:
-            item = self._items.get(monitor_id)
-            return item.model_copy(deep=True) if item else None
+            return self._items.get(monitor_id)
 
-    async def update(self, monitor_id: UUID, value: MonitorUpdate) -> Monitor | None:
+    async def replace(self, monitor_id: UUID, data: MonitorInput) -> Monitor | None:
         async with self._lock:
             old = self._items.get(monitor_id)
             if old is None:
                 return None
-            changed_url = old.url != value.url
-            item = old.model_copy(
-                update={
-                    "name": value.name,
-                    "url": value.url,
-                    "updated_at": utc_now(),
+            item = old.model_copy(update={**data.model_dump(), "updated_at": now(),
                                           "revision": old.revision + 1,
-                    "current_status": None if changed_url else old.current_status,
-                }
-            )
+                                          "status": CheckSnapshot()})
             self._items[monitor_id] = item
-            return item.model_copy(deep=True)
+            return item
 
     async def delete(self, monitor_id: UUID) -> bool:
         async with self._lock:
             return self._items.pop(monitor_id, None) is not None
 
-    async def set_status_if_current(
-        self, monitor_id: UUID, revision: int, status: CurrentStatus
-    ) -> bool:
+    async def set_status(self, monitor_id: UUID, revision: int,
+                         status: CheckSnapshot) -> Monitor | None:
         async with self._lock:
             old = self._items.get(monitor_id)
             if old is None or old.revision != revision:
-                return False
-            self._items[monitor_id] = old.model_copy(
-                update={"current_status": status, "updated_at": utc_now()}
-            )
-            return True
+                return None
+            item = old.model_copy(update={"status": status, "updated_at": now()})
+            self._items[monitor_id] = item
+            return item