from typing import Literal
from pydantic import PostgresDsn, RedisDsn, Field
from pydantic_settings import BaseSettings, SettingsConfigDict

class Settings(BaseSettings):
    # Визначаємо рівень запуску додатка
    ENVIRONMENT: Literal["development", "staging", "production"] = "development"

    # Секретний ключ для шифрування JWT токенів
    SECRET_KEY: str = Field(min_length=32)

    # Валідація форматів підключення до БД та Redis через спеціальні типи Pydantic
    DATABASE_URL: PostgresDsn
    REDIS_URL: RedisDsn

    # Порт для запуску API
    PORT: int = 8000

    # Налаштування джерела зчитування
    # env_file вказує на файл, який зчитується локально, якщо системні змінні відсутні
    model_config = SettingsConfigDict(
        env_file=".env",
        env_file_encoding="utf-8",
        case_sensitive=True # Змінні в коді та в системі мають збігатися за регістром
    )

# Створюємо єдиний екземпляр налаштувань (Singleton)
settings = Settings()

ENVIRONMENT=development
SECRET_KEY=super-secret-key-that-must-be-at-least-32-chars-long
DATABASE_URL=postgresql://postgres:postgres@localhost:5432/taskforge
REDIS_URL=redis://localhost:6379/0
PORT=8000

.git
.github
.venv
__pycache__
*.pyc
*.pyo
*.pyd
.env
*.db
tests/
Dockerfile
docker-compose.yml

# Builder етап використовує важкий SDK
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "./"]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app

# Runner етап використовує легкий Runtime
FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS final
WORKDIR /app
COPY --from=build /app .
USER $APP_UID
ENTRYPOINT ["dotnet", "MyApp.dll"]

version: '3.8'

services:
    # 1. Сервіс Бази Даних PostgreSQL
    db:
        image: postgres:16-alpine
        container_name: taskforge_postgres
        restart: always
        environment:
            POSTGRES_USER: postgres
            POSTGRES_PASSWORD: super-secure-db-password
            POSTGRES_DB: taskforge
        ports:
            - '5432:5432'
        volumes:
            - postgres_data:/var/lib/postgresql/data
        # Налаштовуємо перевірку працездатності БД
        healthcheck:
            test: ['CMD-SHELL', 'pg_isready -U postgres -d taskforge']
            interval: 5s # Як часто перевіряти
            timeout: 5s # Таймаут на відповідь
            retries: 5 # Скільки спроб до позначки "Unhealthy"

    # 2. Сервіс Redis (Кеш та Черга задач)
    redis:
        image: redis:7-alpine
        container_name: taskforge_redis
        restart: always
        ports:
            - '6379:6379'
        # Перевірка працездатності Redis
        healthcheck:
            test: ['CMD', 'redis-cli', 'ping']
            interval: 5s
            timeout: 3s
            retries: 5

    # 3. Наш FastAPI веб-додаток
    web:
        build:
            context: .
            dockerfile: Dockerfile
        container_name: taskforge_api
        restart: always
        ports:
            - '8000:8000'
        environment:
            - ENVIRONMENT=production
            - SECRET_KEY=another-super-secret-key-for-prod-32-chars
            # Зверніть увагу: ми використовуємо імена сервісів (db, redis) замість localhost!
            # Docker Compose створює внутрішню мережу, де імена сервісів працюють як DNS-імена
            - DATABASE_URL=postgresql://postgres:super-secure-db-password@db:5432/taskforge
            - REDIS_URL=redis://redis:6379/0
        # Чекаємо повної готовності залежних контейнерів
        depends_on:
            db:
                condition: service_healthy
            redis:
                condition: service_healthy

volumes:
    postgres_data: # Зберігає дані БД на хост-машині, щоб вони не зникли при видаленні контейнерів

name: CI/CD Pipeline

# Тригери для запуску workflow
on:
    push:
        branches: ['main']
    pull_request:
        branches: ['main']

jobs:
    # ----------------------------------------------------
    # ЕТАП 1: Тестування та перевірка якості коду (Lint & Test)
    # ----------------------------------------------------
    lint-and-test:
        runs-on: ubuntu-latest

        steps:
            - name: Checkout repository code
              uses: actions/checkout@v4

            - name: Set up Python 3.12
              uses: actions/setup-python@v5
              with:
                  python-version: '3.12'
                  # Кешуємо залежності pip, щоб пришвидшити наступні збірки
                  cache: 'pip'

            - name: Install dependencies
              run: |
                  python -m pip upgrade pip
                  pip install -r requirements.txt
                  # Додаткові утиліти для тестування
                  pip install ruff mypy pytest pytest-asyncio httpx

            - name: Run Ruff Linter
              run: ruff check app/

            - name: Run Ruff Formatter check
              run: ruff format --check app/

            - name: Run Mypy Type Checker
              run: mypy app/

            - name: Run Pytest suite
              run: pytest tests/
              env:
                  # Передаємо тестові налаштування
                  SECRET_KEY: test-secret-key-placeholder-32-chars-long
                  DATABASE_URL: sqlite+aiosqlite:///./test.db
                  REDIS_URL: redis://localhost:6379/0

    # ----------------------------------------------------
    # ЕТАП 2: Збірка Docker образу (Build & Push)
    # Виконується лише якщо попередній етап пройшов успішно та гілка - main
    # ----------------------------------------------------
    build-and-publish:
        needs: lint-and-test
        runs-on: ubuntu-latest
        if: github.ref == 'refs/heads/main' && github.event_name == 'push'

        steps:
            - name: Checkout code
              uses: actions/checkout@v4

            - name: Set up Docker Buildx
              uses: actions/setup-buildx-action@v3

            # Авторизуємось у GitHub Container Registry (GHCR)
            - name: Log in to GHCR
              uses: docker/login-action@v3
              with:
                  registry: ghcr.io
                  username: ${{ github.actor }}
                  password: ${{ secrets.GITHUB_TOKEN }}

            # Збираємо образ та відправляємо його в реєстр
            - name: Build and Push Docker image
              uses: docker/build-push-action@v5
              with:
                  context: .
                  file: Dockerfile
                  push: true
                  # Формуємо теги для нашого образу
                  tags: |
                      ghcr.io/${{ github.repository }}/api:latest
                      ghcr.io/${{ github.repository }}/api:${{ github.sha }}
                  # Кешування шарів Docker для прискорення збірок у хмарі
                  cache-from: type=gha
                  cache-to: type=gha,mode=max

import logging
import sys
import structlog

def setup_logging():
    # Налаштовуємо стандартне логування для сумісності з іншими бібліотеками
    logging.basicConfig(
        format="%(message)s",
        stream=sys.stdout,
        level=logging.INFO,
    )

    structlog.configure(
        processors=[
            # Додає інформацію про рівень логування (info, error)
            structlog.processors.add_log_level,
            # Додає мітку часу
            structlog.processors.TimeStamper(fmt="iso"),
            # Форматує вивід як JSON рядок
            structlog.processors.JSONRenderer()
        ],
        # Направляємо лог у стандартний вивід
        logger_factory=structlog.stdlib.LoggerFactory(),
        wrapper_class=structlog.stdlib.BoundLogger,
        cache_logger_on_first_use=True,
    )

logger = structlog.get_logger()

from fastapi import FastAPI, status, Response
from app.database import database_check_connection # імітація перевірки з БД
from app.redis import redis_check_connection # імітація перевірки з Redis
from app.logger import logger

app = FastAPI()

# Liveness: Проста швидка відповідь
@app.get("/healthz", status_code=status.HTTP_200_OK)
async def liveness():
    return {"status": "alive"}

# Readiness: Глибока перевірка залежностей
@app.get("/readyz")
async def readiness(response: Response):
    db_healthy = await database_check_connection()
    redis_healthy = await redis_check_connection()

    if not db_healthy or not redis_healthy:
        logger.error("readiness_check_failed", database=db_healthy, redis=redis_healthy)
        response.status_code = status.HTTP_503_SERVICE_UNAVAILABLE
        return {"status": "unready", "database": db_healthy, "redis": redis_healthy}

    return {"status": "ready"}

status-monitor/
├── .github/
│   └── workflows/
│       └── ci.yml
├── app/
│   ├── __init__.py
│   ├── config.py
│   ├── database.py
│   ├── logger.py
│   └── main.py
├── .dockerignore
├── Dockerfile
├── docker-compose.yml
└── requirements.txt

fastapi>=0.110.0
uvicorn[standard]>=0.28.0
gunicorn>=22.0.0
pydantic-settings>=2.2.0
python-dotenv>=1.0.1
structlog>=24.1.0
sqlalchemy[asyncio]>=2.0.28
asyncpg>=0.29.0
redis>=5.0.3
prometheus-fastapi-instrumentator>=7.0.0
pytest>=8.1.1
pytest-asyncio>=0.23.5
httpx>=0.27.0

from pydantic_settings import BaseSettings, SettingsConfigDict
from pydantic import PostgresDsn, RedisDsn

class Settings(BaseSettings):
    ENVIRONMENT: str = "production"
    SECRET_KEY: str
    DATABASE_URL: PostgresDsn
    REDIS_URL: RedisDsn
    PORT: int = 8000

    model_config = SettingsConfigDict(
        env_file=".env",
        env_file_encoding="utf-8"
    )

settings = Settings()

import logging
import sys
import structlog

def setup_logging():
    logging.basicConfig(
        format="%(message)s",
        stream=sys.stdout,
        level=logging.INFO,
    )
    structlog.configure(
        processors=[
            structlog.processors.add_log_level,
            structlog.processors.TimeStamper(fmt="iso"),
            structlog.processors.JSONRenderer()
        ],
        logger_factory=structlog.stdlib.LoggerFactory(),
        wrapper_class=structlog.stdlib.BoundLogger,
        cache_logger_on_first_use=True,
    )

logger = structlog.get_logger()

from sqlalchemy.ext.asyncio import create_async_engine
from sqlalchemy import text
from app.config import settings
from app.logger import logger

engine = create_async_engine(str(settings.DATABASE_URL), echo=False)

async def check_db_connection() -> bool:
    try:
        async with engine.connect() as conn:
            await conn.execute(text("SELECT 1"))
        return True
    except Exception as e:
        logger.error("database_ping_failed", error=str(e))
        return False

import redis.asyncio as aioredis
from fastapi import FastAPI, Response, status
from prometheus_fastapi_instrumentator import Instrumentator

from app.config import settings
from app.logger import setup_logging, logger
from app.database import check_db_connection

# Ініціалізуємо структуровані логи
setup_logging()

app = FastAPI(title="StatusMonitor API")

# Підключаємо Prometheus метрики
Instrumentator().instrument(app).expose(app)

@app.on_event("startup")
async def startup_event():
    logger.info("application_starting", environment=settings.ENVIRONMENT)

@app.get("/healthz", status_code=status.HTTP_200_OK)
async def liveness():
    # Швидка перевірка, чи не завис Event Loop
    return {"status": "healthy"}

@app.get("/readyz")
async def readiness(response: Response):
    # Глибока перевірка зв'язку з БД
    db_ok = await check_db_connection()

    # Глибока перевірка зв'язку з Redis
    redis_ok = False
    try:
        r = aioredis.from_url(str(settings.REDIS_URL))
        redis_ok = await r.ping()
    except Exception as e:
        logger.error("redis_ping_failed", error=str(e))

    if not db_ok or not redis_ok:
        logger.warn("readiness_check_failed", database=db_ok, redis=redis_ok)
        response.status_code = status.HTTP_503_SERVICE_UNAVAILABLE
        return {"status": "unready", "database": db_ok, "redis": redis_ok}

    return {"status": "ready", "database": db_ok, "redis": redis_ok}

@app.get("/")
async def root():
    return {"message": "Welcome to StatusMonitor API"}

# STAGE 1: Builder
FROM python:3.12-slim AS builder
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1
WORKDIR /build
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt

# STAGE 2: Runner
FROM python:3.12-slim AS runner
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1
WORKDIR /app
COPY --from=builder /install /usr/local

# Створюємо безпечного non-root користувача
RUN groupadd -g 10001 appuser && \
    useradd -u 10000 -g appuser -m -s /sbin/nologin appuser
COPY ./app ./app
COPY ./main.py .
RUN chown -R appuser:appuser /app
USER appuser

EXPOSE 8000
CMD ["gunicorn", "main:app", "--workers", "4", "--worker-class", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8000"]

.git
.github
.venv
__pycache__
*.db
.env
Dockerfile
docker-compose.yml

version: '3.8'

services:
    db:
        image: postgres:16-alpine
        container_name: monitor_db
        environment:
            POSTGRES_USER: postgres
            POSTGRES_PASSWORD: monitorpassword
            POSTGRES_DB: monitordb
        ports:
            - '5432:5432'
        volumes:
            - monitor_db_data:/var/lib/postgresql/data
        healthcheck:
            test: ['CMD-SHELL', 'pg_isready -U postgres -d monitordb']
            interval: 5s
            timeout: 5s
            retries: 5

    redis:
        image: redis:7-alpine
        container_name: monitor_redis
        ports:
            - '6379:6379'
        healthcheck:
            test: ['CMD', 'redis-cli', 'ping']
            interval: 5s
            timeout: 3s
            retries: 5

    web:
        build: .
        container_name: monitor_api
        ports:
            - '8000:8000'
        environment:
            - ENVIRONMENT=production
            - SECRET_KEY=super-secret-status-monitor-key-32-chars
            - DATABASE_URL=postgresql+asyncpg://postgres:monitorpassword@db:5432/monitordb
            - REDIS_URL=redis://redis:6379/0
        depends_on:
            db:
                condition: service_healthy
            redis:
                condition: service_healthy

volumes:
    monitor_db_data:

name: Code Quality CI

on:
    push:
        branches: ['main']
    pull_request:
        branches: ['main']

jobs:
    validate:
        runs-on: ubuntu-latest
        steps:
            - name: Checkout code
              uses: actions/checkout@v4

            - name: Set up Python
              uses: actions/setup-python@v5
              with:
                  python-version: '3.12'
                  cache: 'pip'

            - name: Install dependencies
              run: |
                  python -m pip install --upgrade pip
                  pip install -r requirements.txt
                  pip install ruff mypy

            - name: Ruff Lint
              run: ruff check app/

            - name: Mypy Type Check
              run: mypy app/