From 6ec4dde732ab7318cdcf84440a0578173721b0cc Mon Sep 17 00:00:00 2001 From: Neimess Date: Sat, 20 Sep 2025 21:24:15 +0300 Subject: [PATCH 1/6] Implement ASGI application with fibonacci, factorial, and mean endpoints --- hw1/app.py | 188 ++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 187 insertions(+), 1 deletion(-) diff --git a/hw1/app.py b/hw1/app.py index 6107b870..1410a582 100644 --- a/hw1/app.py +++ b/hw1/app.py @@ -1,4 +1,163 @@ from typing import Any, Awaitable, Callable +from urllib.parse import parse_qs +import json +from http import HTTPStatus + + +class NegativeParameterError(Exception): + pass + + +def b_to_queries(scope: dict[str, Any]) -> dict[str, str]: + raw = scope["query_string"].decode() + return {k: v[0] for k, v in parse_qs(raw).items()} + + +def parse_numbers(raw: str | None) -> list[float]: + if not raw: + raise ValueError("missing 'numbers' param") + try: + return [float(x) for x in raw.split(",")] + except ValueError: + raise ValueError("all values must be numbers") + + +async def _send_json( + send: Callable[[dict[str, Any]], Awaitable[None]], + status: int, + payload: dict[str, Any], +): + body = json.dumps(payload).encode() + await send( + { + "type": "http.response.start", + "status": status, + "headers": [[b"content-type", b"application/json"]], + } + ) + await send({"type": "http.response.body", "body": body}) + + +async def factorial_handler( + scope: dict[str, Any], + receive: Callable[[], Awaitable[dict[str, Any]]], + send: Callable[[dict[str, Any]], Awaitable[None]], +): + params = b_to_queries(scope) + raw_n = params.get("n") + + if raw_n is None: + return await _send_json( + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "missing 'n' param"} + ) + try: + n = int(raw_n) + result = factorial(n) + except ValueError: + return await _send_json( + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "param must be integer"} + ) + except NegativeParameterError as e: + return await _send_json(send, HTTPStatus.BAD_REQUEST, {"error": str(e)}) + + return await _send_json(send, HTTPStatus.OK, {"result": result}) + + +def factorial(n: int) -> int: + if n < 0: + raise NegativeParameterError("n must be >= 0") + res = 1 + for i in range(2, n + 1): + res *= i + return res + + +async def fibonacci_handler( + scope: dict[str, Any], + receive: Callable[[], Awaitable[dict[str, Any]]], + send: Callable[[dict[str, Any]], Awaitable[None]], +): + parts = scope["path"].strip("/").split("/") + raw_n = parts[1] if len(parts) > 1 else None + if raw_n is None: + return await _send_json( + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "missing param in path"} + ) + + try: + n = int(raw_n) + result = fibonacci(n) + except NegativeParameterError: + return await _send_json( + send, HTTPStatus.BAD_REQUEST, {"error": "param must be integer"} + ) + except ValueError as e: + return await _send_json( + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": str(e)} + ) + + return await _send_json(send, HTTPStatus.OK, {"result": result}) + + +def fibonacci(n: int) -> int: + if n < 0: + raise NegativeParameterError("n must be >= 0") + if n in (0, 1): + return n + a, b = 0, 1 + for _ in range(2, n): + a, b = b, a + b + return b + + +async def mean_handler( + scope: dict[str, Any], + receive: Callable[[], Awaitable[dict[str, Any]]], + send: Callable[[dict[str, Any]], Awaitable[None]], +): + event = await receive() + raw_body: bytes = event.get("body", b"") + + if not raw_body: + return await _send_json( + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "missing body"} + ) + + try: + data = json.loads(raw_body.decode()) + except json.JSONDecodeError: + return await _send_json( + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "invalid JSON"} + ) + + if not isinstance(data, list): + return await _send_json( + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "body must be list"} + ) + + if not data: + return await _send_json(send, HTTPStatus.BAD_REQUEST, {"error": "empty list"}) + + if not all(isinstance(x, (int, float)) for x in data): + return await _send_json( + send, + HTTPStatus.UNPROCESSABLE_ENTITY, + {"error": "list must contain only numbers"}, + ) + + result = mean([float(x) for x in data]) + return await _send_json(send, HTTPStatus.OK, {"result": result}) + + +def mean(lst: list[float]) -> float: + return sum(lst) / len(lst) + + +routes: dict[str, Callable] = { + "factorial": factorial_handler, + "fibonacci": fibonacci_handler, + "mean": mean_handler, +} async def application( @@ -12,8 +171,35 @@ async def application( receive: Корутина для получения сообщений от клиента send: Корутина для отправки сообщений клиенту """ - # TODO: Ваша реализация здесь + if scope["type"] == "lifespan": + while True: + message = await receive() + if message["type"] == "lifespan.startup": + await send({"type": "lifespan.startup.complete"}) + elif message["type"] == "lifespan.shutdown": + await send({"type": "lifespan.shutdown.complete"}) + return + if scope["type"] == "http": + + path = scope["path"].strip("/").split("/") + route = path[0] if path else "" + + handler: Callable | None = routes.get(route) + if handler is None: + await send( + { + "type": "http.response.start", + "status": 404, + "headers": [[b"content-type", b"text/plain"]], + } + ) + await send({"type": "http.response.body", "body": b"Not found"}) + return + + await handler(scope, receive, send) + if __name__ == "__main__": import uvicorn + uvicorn.run("app:application", host="0.0.0.0", port=8000, reload=True) From 1880ad47954509196a89c70ffc9fb5aaf36e1afe Mon Sep 17 00:00:00 2001 From: Neimess Date: Sat, 20 Sep 2025 21:43:02 +0300 Subject: [PATCH 2/6] black fixes --- hw1/app.py | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/hw1/app.py b/hw1/app.py index 1410a582..52c653f6 100644 --- a/hw1/app.py +++ b/hw1/app.py @@ -48,17 +48,23 @@ async def factorial_handler( if raw_n is None: return await _send_json( - send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "missing 'n' param"} + send, + HTTPStatus.UNPROCESSABLE_ENTITY, + {"error": "missing 'n' param"} ) try: n = int(raw_n) result = factorial(n) except ValueError: return await _send_json( - send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "param must be integer"} + send, + HTTPStatus.UNPROCESSABLE_ENTITY, + {"error": "param must be integer"} ) except NegativeParameterError as e: - return await _send_json(send, HTTPStatus.BAD_REQUEST, {"error": str(e)}) + return await _send_json(send, + HTTPStatus.BAD_REQUEST, + {"error": str(e)}) return await _send_json(send, HTTPStatus.OK, {"result": result}) @@ -81,7 +87,9 @@ async def fibonacci_handler( raw_n = parts[1] if len(parts) > 1 else None if raw_n is None: return await _send_json( - send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "missing param in path"} + send, + HTTPStatus.UNPROCESSABLE_ENTITY, + {"error": "missing param in path"} ) try: @@ -132,11 +140,15 @@ async def mean_handler( if not isinstance(data, list): return await _send_json( - send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "body must be list"} + send, + HTTPStatus.UNPROCESSABLE_ENTITY, + {"error": "body must be list"} ) if not data: - return await _send_json(send, HTTPStatus.BAD_REQUEST, {"error": "empty list"}) + return await _send_json(send, + HTTPStatus.BAD_REQUEST, + {"error": "empty list"}) if not all(isinstance(x, (int, float)) for x in data): return await _send_json( From b504a84657fd474157192a1c1f569ba3c91ea8c4 Mon Sep 17 00:00:00 2001 From: Maxim Gavrilenko Date: Sun, 28 Sep 2025 01:22:15 +0300 Subject: [PATCH 3/6] (feature) websocket app chat done --- hw2/hw/requirements.txt | 3 +- hw2/hw/shop_api/chat/chat.py | 57 +++++++++++++++++++++++++ hw2/hw/shop_api/handlers/__init__.py | 11 +++++ hw2/hw/shop_api/handlers/chat.py | 64 ++++++++++++++++++++++++++++ hw2/hw/shop_api/models/chat.py | 25 +++++++++++ 5 files changed, 158 insertions(+), 2 deletions(-) create mode 100644 hw2/hw/shop_api/chat/chat.py create mode 100644 hw2/hw/shop_api/handlers/__init__.py create mode 100644 hw2/hw/shop_api/handlers/chat.py create mode 100644 hw2/hw/shop_api/models/chat.py diff --git a/hw2/hw/requirements.txt b/hw2/hw/requirements.txt index 207dcf5c..c3ea396f 100644 --- a/hw2/hw/requirements.txt +++ b/hw2/hw/requirements.txt @@ -1,7 +1,6 @@ # Основные зависимости для ASGI приложения fastapi>=0.117.1 -uvicorn>=0.24.0 - +uvicorn[standard] # Зависимости для тестирования pytest>=7.4.0 pytest-asyncio>=0.21.0 diff --git a/hw2/hw/shop_api/chat/chat.py b/hw2/hw/shop_api/chat/chat.py new file mode 100644 index 00000000..5c580ed5 --- /dev/null +++ b/hw2/hw/shop_api/chat/chat.py @@ -0,0 +1,57 @@ +from faker import Faker +from fastapi import WebSocket, status +from typing import Dict, Set +from collections import defaultdict +import asyncio + + +def _random_name(): + return Faker().name() + + +class ChatManager: + def __init__(self) -> None: + self._rooms: Dict[str, Set[WebSocket]] = defaultdict(set) + self._usernames: Dict[WebSocket, str] = {} + self._rooms_lock = asyncio.Lock() + self._room_locks: Dict[str, asyncio.Lock] = defaultdict(asyncio.Lock) + + async def connect(self, room: str, ws: WebSocket) -> str: + await ws.accept() + username = _random_name() + async with self._rooms_lock: + self._rooms[room].add(ws) + self._usernames[ws] = username + return username + + async def disconnect(self, room: str, ws: WebSocket) -> None: + async with self._rooms_lock: + if room in self._rooms: + self._rooms[room].discard(ws) + if not self._rooms[room]: + del self._rooms[room] + self._usernames.pop(ws, None) + + async def broadcast( + self, room: str, payload: dict, exclude: WebSocket | None = None + ) -> None: + async with self._rooms_lock: + targets = list(self._rooms.get(room, ())) + if not targets: + return + send_tasks = [] + for ws in targets: + if exclude is not None and ws is exclude: + continue + send_tasks.append(self._safe_send(ws, payload, room)) + if send_tasks: + await asyncio.gather(*send_tasks, return_exceptions=True) + + async def _safe_send(self, ws: WebSocket, payload: dict, room: str) -> None: + try: + await ws.send_json(payload) + except Exception: + try: + await ws.close(code=status.WS_1011_INTERNAL_ERROR) + finally: + await self.disconnect(room, ws) diff --git a/hw2/hw/shop_api/handlers/__init__.py b/hw2/hw/shop_api/handlers/__init__.py new file mode 100644 index 00000000..4af10e49 --- /dev/null +++ b/hw2/hw/shop_api/handlers/__init__.py @@ -0,0 +1,11 @@ +from fastapi import APIRouter + +from .cart import router as cart_router +from .item import router as item_router +from .chat import router as chat_router + +router = APIRouter() + +router.include_router(item_router) +router.include_router(cart_router) +router.include_router(chat_router) diff --git a/hw2/hw/shop_api/handlers/chat.py b/hw2/hw/shop_api/handlers/chat.py new file mode 100644 index 00000000..dca024f5 --- /dev/null +++ b/hw2/hw/shop_api/handlers/chat.py @@ -0,0 +1,64 @@ +from __future__ import annotations +import asyncio +from typing import Final + +from fastapi import APIRouter, WebSocket, WebSocketDisconnect, status + +from shop_api.models.chat import ChatHello, ChatSystem, ChatMessage, ClientInbound +from shop_api.chat.chat import ChatManager + +router = APIRouter(tags=["chat"]) +manager: Final = ChatManager() + +PING_INTERVAL = 20 +IDLE_TIMEOUT = 60 +MAX_MESSAGE_BYTES = 4096 + + +@router.websocket("/chat/{room}") +async def chat_ws(ws: WebSocket, room: str): + username = await manager.connect(room, ws) + await ws.send_json(ChatHello(room=room, username=username).model_dump()) + await manager.broadcast( + room, ChatSystem(text=f"{username} joined").model_dump(), exclude=ws + ) + + stop = asyncio.Event() + idle_task = asyncio.create_task(_idle_watchdog(ws, stop)) + + try: + while True: + raw = await ws.receive_text() + if len(raw.encode("utf-8")) > MAX_MESSAGE_BYTES: + await ws.close( + code=status.WS_1009_MESSAGE_TOO_BIG, reason="message too large" + ) + break + + data = ClientInbound.model_validate_json(raw) + idle_task.cancel() + idle_task = asyncio.create_task(_idle_watchdog(ws, stop)) + print(username) + await manager.broadcast( + room, + ChatMessage(author=username, text=data.text).model_dump(), + exclude=ws, + ) + except WebSocketDisconnect: + pass + finally: + stop.set() + for task in (ping_task, idle_task): + task.cancel() + await manager.disconnect(room, ws) + await manager.broadcast(room, ChatSystem(text=f"{username} left").model_dump()) + + +async def _idle_watchdog(ws: WebSocket, stop: asyncio.Event) -> None: + try: + await asyncio.wait_for(stop.wait(), timeout=IDLE_TIMEOUT) + except asyncio.TimeoutError: + try: + await ws.close(code=status.WS_1001_GOING_AWAY, reason="idle timeout") + finally: + stop.set() diff --git a/hw2/hw/shop_api/models/chat.py b/hw2/hw/shop_api/models/chat.py new file mode 100644 index 00000000..47889dfa --- /dev/null +++ b/hw2/hw/shop_api/models/chat.py @@ -0,0 +1,25 @@ +from pydantic import BaseModel, Field, ConfigDict + + +class ChatHello(BaseModel): + type: str = Field("hello", frozen=True) + room: str + username: str + + +class ChatSystem(BaseModel): + type: str = Field("system", frozen=True) + text: str + + +class ChatMessage(BaseModel): + type: str = Field("message", frozen=True) + author: str + text: str + + +class ClientInbound(BaseModel): + text: str = Field(min_length=1, max_length=2000) + + +model_config = ConfigDict(from_attributes=True) From 31ef52509224438651a13817e6ff8447669b9513 Mon Sep 17 00:00:00 2001 From: Neimess Date: Sat, 4 Oct 2025 22:52:21 +0300 Subject: [PATCH 4/6] hw2 done --- hw1/app.py | 24 ++--- hw2/hw/shop_api/handlers/cart.py | 106 +++++++++++++++++++ hw2/hw/shop_api/handlers/item.py | 134 +++++++++++++++++++++++++ hw2/hw/shop_api/main.py | 28 +++++- hw2/hw/shop_api/models/cart.py | 35 +++++++ hw2/hw/shop_api/models/item.py | 45 +++++++++ hw2/hw/shop_api/storage/in_mem.py | 30 ++++++ hw2/rest_example/api/pokemon/routes.py | 2 +- 8 files changed, 384 insertions(+), 20 deletions(-) create mode 100644 hw2/hw/shop_api/handlers/cart.py create mode 100644 hw2/hw/shop_api/handlers/item.py create mode 100644 hw2/hw/shop_api/models/cart.py create mode 100644 hw2/hw/shop_api/models/item.py create mode 100644 hw2/hw/shop_api/storage/in_mem.py diff --git a/hw1/app.py b/hw1/app.py index 52c653f6..1410a582 100644 --- a/hw1/app.py +++ b/hw1/app.py @@ -48,23 +48,17 @@ async def factorial_handler( if raw_n is None: return await _send_json( - send, - HTTPStatus.UNPROCESSABLE_ENTITY, - {"error": "missing 'n' param"} + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "missing 'n' param"} ) try: n = int(raw_n) result = factorial(n) except ValueError: return await _send_json( - send, - HTTPStatus.UNPROCESSABLE_ENTITY, - {"error": "param must be integer"} + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "param must be integer"} ) except NegativeParameterError as e: - return await _send_json(send, - HTTPStatus.BAD_REQUEST, - {"error": str(e)}) + return await _send_json(send, HTTPStatus.BAD_REQUEST, {"error": str(e)}) return await _send_json(send, HTTPStatus.OK, {"result": result}) @@ -87,9 +81,7 @@ async def fibonacci_handler( raw_n = parts[1] if len(parts) > 1 else None if raw_n is None: return await _send_json( - send, - HTTPStatus.UNPROCESSABLE_ENTITY, - {"error": "missing param in path"} + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "missing param in path"} ) try: @@ -140,15 +132,11 @@ async def mean_handler( if not isinstance(data, list): return await _send_json( - send, - HTTPStatus.UNPROCESSABLE_ENTITY, - {"error": "body must be list"} + send, HTTPStatus.UNPROCESSABLE_ENTITY, {"error": "body must be list"} ) if not data: - return await _send_json(send, - HTTPStatus.BAD_REQUEST, - {"error": "empty list"}) + return await _send_json(send, HTTPStatus.BAD_REQUEST, {"error": "empty list"}) if not all(isinstance(x, (int, float)) for x in data): return await _send_json( diff --git a/hw2/hw/shop_api/handlers/cart.py b/hw2/hw/shop_api/handlers/cart.py new file mode 100644 index 00000000..7b3b8750 --- /dev/null +++ b/hw2/hw/shop_api/handlers/cart.py @@ -0,0 +1,106 @@ +from http import HTTPStatus +from typing import List + +from fastapi import APIRouter, Depends, HTTPException, Query +from fastapi.responses import JSONResponse + +from shop_api.models.cart import CartLineOut, CartOut +from shop_api.models.item import ItemRecord +from shop_api.storage.in_mem import get_store + +router = APIRouter(prefix="/cart", tags=["cart"]) + + +@router.post("") +async def create_cart(deps=Depends(get_store)): + items, carts, lock = deps + async with lock: + cart_id = len(carts) + 1 + carts[cart_id] = {} + + content = {"id": cart_id} + headers = {"Location": f"/cart/{cart_id}"} + return JSONResponse( + content=content, headers=headers, status_code=HTTPStatus.CREATED + ) + + +@router.get("/{cart_id}", response_model=CartOut) +async def get_cart(cart_id: int, deps=Depends(get_store)): + items, carts, lock = deps + async with lock: + cart = carts.get(cart_id) + if cart is None: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, detail="cart not found" + ) + + return build_cart_response(cart_id, cart, items) + + +@router.get("", response_model=List[CartOut]) +async def list_carts( + offset: int = Query(0, ge=0), + limit: int = Query(10, gt=0), + min_price: float | None = Query(None, ge=0), + max_price: float | None = Query(None, ge=0), + min_quantity: int | None = Query(None, ge=0), + max_quantity: int | None = Query(None, ge=0), + deps=Depends(get_store), +): + items, carts, lock = deps + async with lock: + outs: list[CartOut] = [] + + for cid, cmap in carts.items(): + resp = build_cart_response(cid, cmap, items) + if min_price is not None and resp.price < min_price: + continue + if max_price is not None and resp.price > max_price: + continue + if min_quantity is not None and resp.quantity < min_quantity: + continue + if max_quantity is not None and resp.quantity > max_quantity: + continue + outs.append(resp) + return outs[offset : offset + limit] + + +@router.post("/{cart_id}/add/{item_id}") +async def add_to_cart(cart_id: int, item_id: int, deps=Depends(get_store)): + + items, carts, lock = deps + async with lock: + cart = carts.get(cart_id) + if cart is None: + raise HTTPException(HTTPStatus.NOT_FOUND, "cart not found") + rec: None | ItemRecord = items.get(item_id) + if not rec: + raise HTTPException(HTTPStatus.NOT_FOUND, "item not found") + if rec.deleted: + raise HTTPException(HTTPStatus.BAD_REQUEST, "item not available") + + cart[item_id] = cart.get(item_id, 0) + 1 + return build_cart_response(cart_id, cart, items) + + +def build_cart_response( + cart_id: int, cart: dict[int, int], items: dict[int, ItemRecord] +) -> CartOut: + lines: list[CartLineOut] = [] + total_price = 0.0 + total_quantity = 0 + for item_id, quantity in cart.items(): + rec = items.get(item_id) + if not rec or rec.deleted: + continue + line_total = rec.price * quantity + lines.append( + CartLineOut( + id=item_id, + quantity=quantity, + ) + ) + total_price += line_total + total_quantity += quantity + return CartOut(id=cart_id, items=lines, price=total_price, quantity=total_quantity) diff --git a/hw2/hw/shop_api/handlers/item.py b/hw2/hw/shop_api/handlers/item.py new file mode 100644 index 00000000..f25bff64 --- /dev/null +++ b/hw2/hw/shop_api/handlers/item.py @@ -0,0 +1,134 @@ +from dataclasses import asdict +from http import HTTPStatus + +from fastapi import APIRouter, Depends, HTTPException, Query, Request + +from shop_api.models.item import ItemCreate, ItemOut, ItemPatch, ItemPut, ItemRecord +from shop_api.storage.in_mem import get_store + +router = APIRouter(prefix="/item", tags=["item"]) + + +@router.get("", response_model=list[ItemOut], status_code=HTTPStatus.OK) +async def list_items( + offset: int = Query(0, ge=0), + limit: int = Query(10, gt=0), + min_price: float | None = Query(None, ge=0), + max_price: float | None = Query(None, ge=0), + show_deleted: bool = Query(False), + deps=Depends(get_store), +): + items: ItemRecord + items, _, _ = deps + result: list[ItemOut] = [] + for iid, data in items.items(): + if not show_deleted and data.deleted: + continue + if min_price is not None and data.price < min_price: + continue + if max_price is not None and data.price > max_price: + continue + result.append(ItemOut(id=iid, **asdict(data))) + return result[offset : offset + limit] + + +@router.get("/{item_id}", response_model=ItemOut, status_code=HTTPStatus.OK) +async def item_by_id( + item_id: int, + deps=Depends(get_store), +): + items, _, _ = deps + rec: None | ItemRecord = items.get(item_id) + if rec is None or rec.deleted: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, detail={"error": "item not found"} + ) + return ItemOut(id=item_id, **asdict(items[item_id])) + + +@router.post("", response_model=ItemOut, status_code=HTTPStatus.CREATED) +async def create_item( + payload: ItemCreate, + request: Request, + deps=Depends(get_store), +): + items, _, lock = deps + async with lock: + new_id = request.app.state.last_item_id + 1 + request.app.state.last_item_id = new_id + items[new_id] = ItemRecord( + name=payload.name, + price=payload.price, + description=payload.description, + deleted=False, + ) + return ItemOut(id=new_id, **asdict(items[new_id])) + + +@router.put("/{item_id}", response_model=ItemOut, status_code=HTTPStatus.OK) +async def put_item( + item_id: int, + payload: ItemPut, + deps=Depends(get_store), +): + items, _, lock = deps + async with lock: + if item_id not in items: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, + detail={ + "error": "item not found", + }, + ) + items[item_id] = ItemRecord( + name=payload.name, + price=payload.price, + description=payload.description, + deleted=False, + ) + return ItemOut(id=item_id, **asdict(items[item_id])) + + +@router.patch("/{item_id}", response_model=ItemOut, status_code=HTTPStatus.OK) +async def patch_item( + item_id: int, + payload: ItemPatch, + deps=Depends(get_store), +): + items, _, locks = deps + async with locks: + item = items.get(item_id) + if item is None: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, + detail={ + "error": "item not found", + }, + ) + + if item.deleted: + raise HTTPException( + status_code=HTTPStatus.NOT_MODIFIED, + detail={"error": "item is deleted"}, + ) + + update_data = payload.model_dump(exclude_unset=True, exclude_none=True) + for k, v in update_data.items(): + setattr(item, k, v) + return ItemOut(id=item_id, **asdict(item)) + + +@router.delete("/{item_id}", response_model=ItemOut, status_code=HTTPStatus.OK) +async def delete_item( + item_id: int, + deps=Depends(get_store), +): + items, _, locks = deps + async with locks: + rec = items.get(item_id) + if rec is None: + raise HTTPException( + status_code=HTTPStatus.NOT_FOUND, detail={"error": "item not found"} + ) + rec.deleted = True + return ItemOut(id=item_id, **asdict(items[item_id])) diff --git a/hw2/hw/shop_api/main.py b/hw2/hw/shop_api/main.py index f60a8c60..7253e17c 100644 --- a/hw2/hw/shop_api/main.py +++ b/hw2/hw/shop_api/main.py @@ -1,3 +1,29 @@ +from shop_api.storage.in_mem import lifespan +from shop_api.handlers import router +import datetime +import platform +import sys + +import fastapi +import pydantic from fastapi import FastAPI -app = FastAPI(title="Shop API") + +VERSION = "1.0.0" +AUTHOR = "Neimess" +BUILD_DATE = datetime.datetime.now().isoformat() + + +print("=" * 60) +print("Task API started") +print(f"Version: {VERSION}") +print(f"Build date: {BUILD_DATE}") +print(f"Author: {AUTHOR}") +print(f"Python: {sys.version.split()[0]}") +print(f"Platform: {platform.system()} {platform.release()}") +print(f"FastAPI: {fastapi.__version__}") +print(f"Pydantic: {pydantic.__version__}") +print("=" * 60) + +app = FastAPI(title="Shop API", lifespan=lifespan) +app.include_router(router) diff --git a/hw2/hw/shop_api/models/cart.py b/hw2/hw/shop_api/models/cart.py new file mode 100644 index 00000000..9cceb9c2 --- /dev/null +++ b/hw2/hw/shop_api/models/cart.py @@ -0,0 +1,35 @@ +from dataclasses import dataclass, field +from typing import List + +from pydantic import BaseModel + + +class CartLineOut(BaseModel): + id: int + quantity: int + + +class CartOut(BaseModel): + id: int + items: List[CartLineOut] + quantity: int + price: float + + +@dataclass +class CartRecord: + id: int + items: dict[int, int] = field(default_factory=dict) + + def add_item(self, item_id: int, qty: int = 1) -> None: + self.items[item_id] = self.items.get(item_id, 0) + qty + + def remove_item(self, item_id: int, qty: int = 1) -> None: + if item_id not in self.items: + return + self.items[item_id] -= qty + if self.items[item_id] <= 0: + del self.items[item_id] + + def clear(self) -> None: + self.items.clear() diff --git a/hw2/hw/shop_api/models/item.py b/hw2/hw/shop_api/models/item.py new file mode 100644 index 00000000..0d1c2a38 --- /dev/null +++ b/hw2/hw/shop_api/models/item.py @@ -0,0 +1,45 @@ +from dataclasses import dataclass + +from pydantic import BaseModel, ConfigDict, Field + + +class ItemCreate(BaseModel): + name: str = Field(min_length=1) + price: float = Field(gt=0) + description: str | None = None + + model_config = ConfigDict(extra="forbid") + + +class ItemPut(BaseModel): + name: str = Field(min_length=1) + price: float = Field(gt=0) + description: str | None = None + + model_config = ConfigDict(extra="forbid") + + +class ItemPatch(BaseModel): + name: str | None = Field(default=None, min_length=1) + price: float | None = Field(default=None, gt=0) + description: str | None = None + + model_config = ConfigDict(extra="forbid") + + +class ItemOut(BaseModel): + id: int + name: str + price: float + description: str | None = None + deleted: bool = False + + model_config = ConfigDict(from_attributes=True) + + +@dataclass +class ItemRecord: + name: str + price: float + description: str | None = None + deleted: bool = False diff --git a/hw2/hw/shop_api/storage/in_mem.py b/hw2/hw/shop_api/storage/in_mem.py new file mode 100644 index 00000000..42195680 --- /dev/null +++ b/hw2/hw/shop_api/storage/in_mem.py @@ -0,0 +1,30 @@ +import asyncio +from contextlib import asynccontextmanager +from typing import Dict, Tuple + +from fastapi import FastAPI, Request + + +def _ensure_state(app: FastAPI) -> None: + state = app.state + if not hasattr(state, "items"): + state.items = {} # type: dict[int, dict[str, Any]] + if not hasattr(state, "carts"): + state.carts = {} # type: dict[str, dict[int, int]] + if not hasattr(state, "lock"): + state.lock = asyncio.Lock() + if not hasattr(state, "last_item_id"): + state.last_item_id = 0 + + +def get_store( + request: Request, +) -> Tuple[Dict[str, dict], Dict[str, Dict[str, int]], asyncio.Lock]: + _ensure_state(request.app) + return request.app.state.items, request.app.state.carts, request.app.state.lock + + +@asynccontextmanager +async def lifespan(app: FastAPI): + _ensure_state(app) + yield diff --git a/hw2/rest_example/api/pokemon/routes.py b/hw2/rest_example/api/pokemon/routes.py index ab935c9a..44843296 100644 --- a/hw2/rest_example/api/pokemon/routes.py +++ b/hw2/rest_example/api/pokemon/routes.py @@ -91,7 +91,7 @@ async def patch_pokemon(id: int, info: PatchPokemonRequest) -> PokemonResponse: HTTPStatus.NOT_MODIFIED: { "description": "Failed to modify pokemon as one was not found", }, - } + }, ) async def put_pokemon( id: int, From 439d8ce7796e69b150422d8d5579c1e90e80120b Mon Sep 17 00:00:00 2001 From: Neimess Date: Sat, 4 Oct 2025 23:22:09 +0300 Subject: [PATCH 5/6] idle fix for websocket --- hw2/hw/shop_api/handlers/chat.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/hw2/hw/shop_api/handlers/chat.py b/hw2/hw/shop_api/handlers/chat.py index dca024f5..d7d0a132 100644 --- a/hw2/hw/shop_api/handlers/chat.py +++ b/hw2/hw/shop_api/handlers/chat.py @@ -48,8 +48,7 @@ async def chat_ws(ws: WebSocket, room: str): pass finally: stop.set() - for task in (ping_task, idle_task): - task.cancel() + idle_task.cancel() await manager.disconnect(room, ws) await manager.broadcast(room, ChatSystem(text=f"{username} left").model_dump()) From 36f2290fc218f39318f863da9737562fab5131b1 Mon Sep 17 00:00:00 2001 From: Neimess Date: Tue, 7 Oct 2025 02:17:42 +0300 Subject: [PATCH 6/6] hw3 done. task represented in hw2/hw/artifacts --- hw2/hw/.dockerignore | 134 +++ hw2/hw/Dockerfile | 19 + hw2/hw/artifacts/grafana_ab_after.png | Bin 0 -> 136406 bytes hw2/hw/docker-compose.yml | 47 + hw2/hw/requirements.txt | 1 + .../settings/grafana/dashboards/dashboard.yml | 7 + .../grafana/dashboards/fastapi-dashboard.json | 1008 +++++++++++++++++ .../grafana/provisioning/dashboards.yml | 12 + .../grafana/provisioning/datasource.yml | 9 + hw2/hw/settings/prometheus/prometheus.yml | 13 + hw2/hw/shop_api/main.py | 4 + 11 files changed, 1254 insertions(+) create mode 100644 hw2/hw/.dockerignore create mode 100644 hw2/hw/Dockerfile create mode 100644 hw2/hw/artifacts/grafana_ab_after.png create mode 100644 hw2/hw/docker-compose.yml create mode 100644 hw2/hw/settings/grafana/dashboards/dashboard.yml create mode 100644 hw2/hw/settings/grafana/dashboards/fastapi-dashboard.json create mode 100644 hw2/hw/settings/grafana/provisioning/dashboards.yml create mode 100644 hw2/hw/settings/grafana/provisioning/datasource.yml create mode 100644 hw2/hw/settings/prometheus/prometheus.yml diff --git a/hw2/hw/.dockerignore b/hw2/hw/.dockerignore new file mode 100644 index 00000000..852216e6 --- /dev/null +++ b/hw2/hw/.dockerignore @@ -0,0 +1,134 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class +venv/ +.vscode/ +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# pipenv +Pipfile.lock + +# PEP 582 +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# IDE +.vscode/ +.idea/ +*.swp +*.swo +*~ + +# macOS +.DS_Store diff --git a/hw2/hw/Dockerfile b/hw2/hw/Dockerfile new file mode 100644 index 00000000..937bab83 --- /dev/null +++ b/hw2/hw/Dockerfile @@ -0,0 +1,19 @@ +FROM python:3.12 AS base + +ARG PYTHONFAULTHANDLER=1 \ + PYTHONUNBUFFERED=1 \ + PYTHONHASHSEED=random \ + PIP_NO_CACHE_DIR=on \ + PIP_DISABLE_PIP_VERSION_CHECK=on \ + PIP_DEFAULT_TIMEOUT=500 + +WORKDIR /usr/src/app +COPY requirements.txt ./ + +RUN pip install --no-cache-dir -r requirements.txt + +COPY . . + +FROM base as dev + +ENTRYPOINT ["uvicorn", "shop_api.main:app", "--port", "8000", "--host", "0.0.0.0"] diff --git a/hw2/hw/artifacts/grafana_ab_after.png b/hw2/hw/artifacts/grafana_ab_after.png new file mode 100644 index 0000000000000000000000000000000000000000..13f34a42a3b85351156e491517566e578d0605b2 GIT binary patch literal 136406 zcmb@tbyQo;+b#^HI20`|#X@l_P@DpVQmlpIPLLKY?$F{6h2riOBv9NTK=D%CDH7Zz zK!AK{pFZ#J{m#42TIZ~F{$P`2&z_k*_sn%)_dVByzfo1d$DzVOK|#S+d?lxjf`TE7 zg7N@}g@OE~L)nrC`481uT|ow=a+GEV`Q@S23zZirDBxJ!TT^u8ckGX^be&O9$XI^= zp(?5~AETfk3KivEyz?;HU-C5hI@NZCfC=a)rGm_X*rwRcksgUbe&cYaC51y+yG%~V02+2%Pv%@h-n}W6%A8eQ!{wUUc()m!Rtx> zxSW#{|JG=hraP($FU9xaU8R>6o-N$fzu)}FsI3qQ35n9TBHE@!?u(|P8U3zMEh84{mpjQbDL|h5z=Vk0TFW)i~G0O3nH7v*& z<&(bb+H_K6l>0rZ=3Z@CvrhpsC@v9?^2bpajP~A=W~df7YyM-ZaTSq_(H}=A`A^r( z!~TwG5V5tBOux&tWAHyev}H2O{{IYvHD0dB|GW0T5B&brmiGUykYud`Vsp3eBS@>f zc_*GPoon))b~)0BuT>wxbwX4#Af2FgbM(ekYaVr=w*O0b;fAW2oIi;x%Tx(Ldc0UT z5!zjQM{dj-RXY3YZ(|fuzC}6DHrL(C;i9P@9)Sl)cp&wE0UM;W(hTc{gCBX zpj_AmufFSo09xb!Lo$!y6v-oL{% zc%0A^FB$UwHaaCzfGhe{8LWWp+QCw9W3 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 oQtky$ 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.117.1 uvicorn[standard] +prometheus_fastapi_instrumentator # Зависимости для тестирования pytest>=7.4.0 pytest-asyncio>=0.21.0 diff --git a/hw2/hw/settings/grafana/dashboards/dashboard.yml b/hw2/hw/settings/grafana/dashboards/dashboard.yml new file mode 100644 index 00000000..528c704c --- /dev/null +++ b/hw2/hw/settings/grafana/dashboards/dashboard.yml @@ -0,0 +1,7 @@ +apiVersion: 1 + +providers: + - name: 'Default' + folder: 'Services' + options: + path: /etc/grafana/provisioning/dashboards \ No newline at end of file diff --git a/hw2/hw/settings/grafana/dashboards/fastapi-dashboard.json b/hw2/hw/settings/grafana/dashboards/fastapi-dashboard.json new file mode 100644 index 00000000..6fd70144 --- /dev/null +++ b/hw2/hw/settings/grafana/dashboards/fastapi-dashboard.json @@ -0,0 +1,1008 @@ +{ + "__inputs": [ + { + "name": "DS_PROMETHEUS", + "label": "prometheus", + "description": "", + "type": "datasource", + "pluginId": "prometheus", + "pluginName": "Prometheus" + } + ], + "__elements": {}, + "__requires": [ + { + "type": "panel", + "id": "bargauge", + "name": "Bar gauge", + "version": "" + }, + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "11.1.3" + }, + { + "type": "datasource", + "id": "prometheus", + "name": "Prometheus", + "version": "1.0.0" + }, + { + "type": "panel", + "id": "stat", + "name": "Stat", + "version": "" + }, + { + "type": "panel", + "id": "timeseries", + "name": "Time series", + "version": "" + } + ], + "annotations": { + "list": [ + { + "builtIn": 1, + "datasource": { + "type": "datasource", + "uid": "grafana" + }, + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "target": { + "limit": 100, + "matchAny": false, + "tags": [], + "type": "dashboard" + }, + "type": "dashboard" + } + ] + }, + "editable": true, + "fiscalYearStartMonth": 0, + "gnetId": 16110, + "graphTooltip": 0, + "id": null, + "links": [], + "liveNow": false, + "panels": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { + "h": 6, + "w": 4, + "x": 0, + "y": 0 + }, + "id": 4, + "options": { + "colorMode": "value", + "graphMode": "area", + "justifyMode": "auto", + "orientation": "auto", + "percentChangeColorMode": "standard", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "showPercentChange": false, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "11.1.3", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "editorMode": "code", + "exemplar": true, + "expr": "sum(rate(http_requests_total[40m]))", + "instant": true, + "interval": "", + "legendFormat": "", + "range": true, + "refId": "A" + } + ], + "timeFrom": "24h", + "title": "Total Requests", + "transformations": [ + { + "id": "seriesToRows", + "options": {} + }, + { + "id": "sortBy", + "options": { + "fields": {}, + "sort": [ + { + "field": "Time" + } + ] + } + } + ], + "type": "stat" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { + "h": 6, + "w": 8, + "x": 4, + "y": 0 + }, + "id": 16, + "options": { + "colorMode": "value", + "graphMode": "area", + "justifyMode": "auto", + "orientation": "auto", + "percentChangeColorMode": "standard", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "showPercentChange": false, + "textMode": "value_and_name", + "wideLayout": true + }, + "pluginVersion": "11.1.3", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "editorMode": "code", + "exemplar": true, + "expr": "http_requests_total", + "instant": true, + "interval": "", + "legendFormat": "{{method}} {{path}}", + "range": true, + "refId": "A" + } + ], + "timeFrom": "24h", + "title": "Requests Count", + "transformations": [ + { + "id": "seriesToRows", + "options": {} + }, + { + "id": "sortBy", + "options": { + "fields": {}, + "sort": [ + { + "field": "Time" + } + ] + } + }, + { + "id": "partitionByValues", + "options": { + "fields": [ + "Metric" + ] + } + } + ], + "type": "stat" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "continuous-GrYlRd" + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "s" + }, + "overrides": [] + }, + "gridPos": { + "h": 6, + "w": 12, + "x": 12, + "y": 0 + }, + "id": 6, + "options": { + "displayMode": "lcd", + "maxVizHeight": 300, + "minVizHeight": 10, + "minVizWidth": 0, + "namePlacement": "auto", + "orientation": "horizontal", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "showUnfilled": true, + "sizing": "auto", + "valueMode": "color" + }, + "pluginVersion": "11.1.3", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "editorMode": "code", + "exemplar": true, + "expr": "sum(rate(http_request_duration_seconds_sum[1m])) / sum(rate(http_request_duration_seconds_count[60m]))", + "interval": "", + "legendFormat": "{{method}} {{path}}", + "range": true, + "refId": "A" + } + ], + "title": "Requests Average Duration", + "type": "bargauge" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "thresholds" + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + } + }, + "overrides": [] + }, + "gridPos": { + "h": 7, + "w": 4, + "x": 0, + "y": 6 + }, + "id": 22, + "options": { + "colorMode": "value", + "graphMode": "area", + "justifyMode": "auto", + "orientation": "auto", + "percentChangeColorMode": "standard", + "reduceOptions": { + "calcs": [ + "lastNotNull" + ], + "fields": "", + "values": false + }, + "showPercentChange": false, + "textMode": "auto", + "wideLayout": true + }, + "pluginVersion": "11.1.3", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "editorMode": "code", + "exemplar": true, + "expr": "sum(rate(http_requests_total{status=\"404\"}[50m]))", + "interval": "", + "legendFormat": "", + "range": true, + "refId": "A" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "disableTextWrap": false, + "editorMode": "builder", + "expr": "rate(http_requests_total{status=\"4xx\"}[1h])", + "fullMetaSearch": false, + "hide": false, + "includeNullMetadata": false, + "instant": false, + "legendFormat": "__auto", + "range": true, + "refId": "B", + "useBackend": false + } + ], + "timeFrom": "24h", + "title": "Total Exceptions", + "type": "stat" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "axisSoftMax": 1, + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 0, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "area" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "red", + "value": null + }, + { + "color": "green", + "value": 0.8 + } + ] + }, + "unit": "percentunit" + }, + "overrides": [] + }, + "gridPos": { + "h": 7, + "w": 10, + "x": 4, + "y": 6 + }, + "id": 18, + "options": { + "legend": { + "calcs": [], + "displayMode": "list", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "single", + "sort": "none" + } + }, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "editorMode": "code", + "exemplar": true, + "expr": "sum(rate(http_requests_total{status=\"200\"}[60m])) / sum(rate(http_requests_total[60m]))", + "interval": "", + "legendFormat": "{{path}}", + "range": true, + "refId": "A" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "disableTextWrap": false, + "editorMode": "builder", + "expr": "rate(http_requests_total{status=\"2xx\"}[1h])", + "fullMetaSearch": false, + "hide": false, + "includeNullMetadata": false, + "instant": false, + "legendFormat": "__auto", + "range": true, + "refId": "B", + "useBackend": false + } + ], + "title": "Percent of 2xx Requests", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "axisSoftMax": 1, + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 0, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "area" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 0.1 + } + ] + }, + "unit": "percentunit" + }, + "overrides": [] + }, + "gridPos": { + "h": 7, + "w": 10, + "x": 14, + "y": 6 + }, + "id": 20, + "options": { + "legend": { + "calcs": [], + "displayMode": "list", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "single", + "sort": "none" + } + }, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "editorMode": "code", + "exemplar": true, + "expr": "sum(rate(http_requests_total{status_codes=\"404\"}[60m])) / sum(rate(http_requests_total[60m]))", + "interval": "", + "legendFormat": "{{path}}", + "range": true, + "refId": "A" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "disableTextWrap": false, + "editorMode": "builder", + "expr": "http_requests_total{status=\"4xx\"}", + "fullMetaSearch": false, + "hide": false, + "includeNullMetadata": true, + "instant": false, + "legendFormat": "__auto", + "range": true, + "refId": "B", + "useBackend": false + } + ], + "title": "Percent of 4xx Requests", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 0, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "s" + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 0, + "y": 13 + }, + "id": 8, + "options": { + "legend": { + "calcs": [], + "displayMode": "list", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "single", + "sort": "none" + } + }, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "editorMode": "code", + "exemplar": true, + "expr": "histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket[60m])) by (le))", + "interval": "", + "legendFormat": "{{path}}", + "range": true, + "refId": "A" + } + ], + "title": "PR 99 Requests Duration", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 0, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + } + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 8, + "y": 13 + }, + "id": 10, + "options": { + "legend": { + "calcs": [], + "displayMode": "list", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "single", + "sort": "none" + } + }, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "editorMode": "code", + "exemplar": true, + "expr": "http_requests_total{app_name=\"$app_name\", path!=\"/metrics\"}", + "interval": "", + "legendFormat": "{{path}}", + "range": true, + "refId": "A" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "disableTextWrap": false, + "editorMode": "builder", + "expr": "http_requests_created", + "fullMetaSearch": false, + "hide": false, + "includeNullMetadata": true, + "instant": false, + "legendFormat": "__auto", + "range": true, + "refId": "B", + "useBackend": false + } + ], + "title": "Request In Process", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 0, + "gradientMode": "none", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "auto", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "reqps" + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 8, + "x": 16, + "y": 13 + }, + "id": 12, + "options": { + "legend": { + "calcs": [], + "displayMode": "list", + "placement": "bottom", + "showLegend": true + }, + "tooltip": { + "mode": "single", + "sort": "none" + } + }, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "editorMode": "code", + "exemplar": true, + "expr": "rate(http_requests_total[60m])", + "interval": "", + "legendFormat": "{{path}}", + "range": true, + "refId": "A" + } + ], + "title": "Request Per Sec", + "type": "timeseries" + } + ], + "refresh": "5s", + "schemaVersion": 39, + "tags": [], + "templating": { + "list": [ + { + "current": {}, + "datasource": { + "type": "prometheus", + "uid": "${DS_PROMETHEUS}" + }, + "definition": "label_values(fastapi_app_info{}, app_name)", + "hide": 0, + "includeAll": false, + "label": "Application Name", + "multi": false, + "name": "app_name", + "options": [], + "query": { + "query": "label_values(fastapi_app_info{}, app_name)", + "refId": "StandardVariableQuery" + }, + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "type": "query" + }, + { + "current": { + "selected": false, + "text": "", + "value": "" + }, + "description": "query with keyword", + "hide": 0, + "label": "Log Query", + "name": "log_keyword", + "options": [ + { + "selected": true, + "text": "", + "value": "" + } + ], + "query": "", + "skipUrlSync": false, + "type": "textbox" + } + ] + }, + "time": { + "from": "now-1h", + "to": "now" + }, + "timepicker": {}, + "timezone": "", + "title": "FastAPI Observability", + "uid": "fastapi-observability", + "version": 2, + "weekStart": "" +} \ No newline at end of file diff --git a/hw2/hw/settings/grafana/provisioning/dashboards.yml b/hw2/hw/settings/grafana/provisioning/dashboards.yml new file mode 100644 index 00000000..07462e3d --- /dev/null +++ b/hw2/hw/settings/grafana/provisioning/dashboards.yml @@ -0,0 +1,12 @@ +apiVersion: 1 +providers: + - name: "Prebuilt" + orgId: 1 + folder: "" + type: file + disableDeletion: false + allowUiUpdates: true + updateIntervalSeconds: 10 + options: + path: /var/lib/grafana/dashboards + foldersFromFilesStructure: true diff --git a/hw2/hw/settings/grafana/provisioning/datasource.yml b/hw2/hw/settings/grafana/provisioning/datasource.yml new file mode 100644 index 00000000..e8795836 --- /dev/null +++ b/hw2/hw/settings/grafana/provisioning/datasource.yml @@ -0,0 +1,9 @@ +apiVersion: 1 +datasources: + - name: Prometheus + type: prometheus + access: proxy + orgId: 1 + isDefault: true + editable: false + url: http://prometheus:9090 diff --git a/hw2/hw/settings/prometheus/prometheus.yml b/hw2/hw/settings/prometheus/prometheus.yml new file mode 100644 index 00000000..508ee30c --- /dev/null +++ b/hw2/hw/settings/prometheus/prometheus.yml @@ -0,0 +1,13 @@ +global: + scrape_interval: 15s + evaluation_interval: 15s + +scrape_configs: + - job_name: "prometheus" + static_configs: + - targets: ["prometheus:9090"] + + - job_name: "fastapi" + static_configs: + - targets: ["fastapi-app:8000"] + diff --git a/hw2/hw/shop_api/main.py b/hw2/hw/shop_api/main.py index 7253e17c..ce429950 100644 --- a/hw2/hw/shop_api/main.py +++ b/hw2/hw/shop_api/main.py @@ -7,6 +7,7 @@ import fastapi import pydantic from fastapi import FastAPI +from prometheus_fastapi_instrumentator import Instrumentator VERSION = "1.0.0" @@ -27,3 +28,6 @@ app = FastAPI(title="Shop API", lifespan=lifespan) app.include_router(router) + + +Instrumentator().instrument(app).expose(app)