# پروژه ساده:
# یک فایل: app.py

# پروژه حجیم:
# ده‌ها پوشه و صدها فایل
complex_project/
├── microservice_1/
│   ├── api/
│   ├── models/
│   ├── services/
│   └── tests/
├── microservice_2/
├── shared_libraries/
├── infrastructure/
└── monitoring/

# مشکل ساده: ماشین حساب
def add(a, b):
    return a + b

# مشکل پیچیده: سیستم تشخیص بیماری از تصاویر پزشکی
class MedicalDiagnosisSystem:
    def __init__(self):
        self.image_processor = ImageProcessor()
        self.feature_extractor = CNNFeatureExtractor()
        self.disease_classifier = DiseaseClassifier()
        self.expert_rules = MedicalRulesEngine()
        self.patient_history = PatientHistoryAnalyzer()
    
    def diagnose(self, medical_images, patient_data):
        # ۱. پیش‌پردازش تصاویر
        processed_images = self.image_processor.preprocess(medical_images)
        
        # ۲. استخراج ویژگی‌ها
        features = self.feature_extractor.extract(processed_images)
        
        # ۳. تحلیل تاریخچه بیمار
        history_analysis = self.patient_history.analyze(patient_data)
        
        # ۴. ترکیب اطلاعات
        combined_data = self.combine_data(features, history_analysis)
        
        # ۵. تشخیص اولیه
        diagnosis = self.disease_classifier.predict(combined_data)
        
        # ۶. اعتبارسنجی با قوانین پزشکی
        validated_diagnosis = self.expert_rules.validate(diagnosis)
        
        # ۷. تولید گزارش جامع
        report = self.generate_report(validated_diagnosis)
        
        return report

┌─────────────────────────────────┐
│        Presentation Layer       │ ← رابط کاربری
├─────────────────────────────────┤
│          Business Layer         │ ← منطق کسب‌وکار
├─────────────────────────────────┤
│          Data Access Layer      │ ← دسترسی به داده
├─────────────────────────────────┤
│           Database Layer        │ ← پایگاه داده
└─────────────────────────────────┘

# هر سرویس مستقل و متمرکز بر یک قابلیت
services = {
    "user_service": {
        "responsibility": "مدیریت کاربران",
        "tech_stack": ["FastAPI", "PostgreSQL", "Redis"],
        "endpoints": ["/register", "/login", "/profile"]
    },
    "order_service": {
        "responsibility": "مدیریت سفارشات",
        "tech_stack": ["Django", "MongoDB", "Celery"],
        "endpoints": ["/create-order", "/track-order", "/cancel-order"]
    },
    "payment_service": {
        "responsibility": "پردازش پرداخت",
        "tech_stack": ["Flask", "SQLite", "Stripe API"],
        "endpoints": ["/pay", "/refund", "/invoices"]
    },
    "notification_service": {
        "responsibility": "ارسال نوتیفیکیشن",
        "tech_stack": ["WebSocket", "Firebase", "SMTP"],
        "endpoints": ["/notify", "/subscribe"]
    }
}

class EventDrivenSystem:
    def __init__(self):
        self.event_bus = EventBus()
        self.handlers = {}
        
    def register_handler(self, event_type, handler):
        """ثبت هندلر برای رویدادها"""
        self.handlers.setdefault(event_type, []).append(handler)
    
    def publish(self, event):
        """انتشار رویداد"""
        # ارسال رویداد به تمام هندلرهای مرتبط
        for handler in self.handlers.get(event.type, []):
            handler.handle(event)

# مثال رویدادها
events = [
    "USER_REGISTERED",
    "ORDER_CREATED",
    "PAYMENT_SUCCESSFUL",
    "PRODUCT_OUT_OF_STOCK",
    "SHIPMENT_DELIVERED"
]

databases = {
    "relational": {
        "postgresql": "داده‌های ساختاریافته تراکنشی",
        "mysql": "وب‌سایت‌ها و برنامه‌های کاربردی"
    },
    "nosql": {
        "mongodb": "داده‌های نیمه‌ساختاریافته",
        "cassandra": "مقیاس‌پذیری افقی",
        "redis": "کش و داده‌های موقت"
    },
    "data_warehouse": {
        "bigquery": "آنالیز داده‌های بزرگ",
        "redshift": "انبار داده"
    },
    "search_engine": {
        "elasticsearch": "جستجوی پیشرفته",
        "solr": "جستجوی متنی"
    }
}

# پردازش ناهمزمان با Celery + Redis/RabbitMQ
from celery import Celery

app = Celery('tasks', broker='redis://localhost:6379/0')

@app.task
def process_large_file(file_path):
    """پردازش فایل حجیم در پس‌زمینه"""
    # ۱. خواندن فایل
    data = read_file(file_path)  # مثلاً ۱۰GB فایل
    
    # ۲. پردازش داده
    processed_data = complex_processing(data)
    
    # ۳. ذخیره نتایج
    save_to_database(processed_data)
    
    # ۴. اطلاع‌رسانی
    send_notification("پردازش فایل کامل شد")
    
    return processed_data

# ارسال کار به صف
task_id = process_large_file.delay("huge_dataset.csv")

# سیستم کش چندلایه
class MultiLayerCache:
    def __init__(self):
        # لایه ۱: کش حافظه سریع (L1)
        self.l1_cache = {}  # LRU Cache در حافظه
        
        # لایه ۲: کش توزیع‌شده (L2)
        self.redis_client = redis.Redis(
            host='localhost',
            port=6379,
            db=0
        )
        
        # لایه ۳: کش فایل/دیسک (L3)
        self.disk_cache_path = "/cache/disk"
    
    def get(self, key):
        # ۱. جستجو در L1
        if key in self.l1_cache:
            return self.l1_cache[key]
        
        # ۲. جستجو در L2
        value = self.redis_client.get(key)
        if value:
            # ذخیره در L1 برای دسترسی بعدی
            self.l1_cache[key] = value
            return value
        
        # ۳. جستجو در L3
        file_path = os.path.join(self.disk_cache_path, key)
        if os.path.exists(file_path):
            value = read_from_disk(file_path)
            # ذخیره در لایه‌های بالاتر
            self.redis_client.set(key, value)
            self.l1_cache[key] = value
            return value
        
        return None

# سیستم مانیتورینگ جامع
class MonitoringSystem:
    def __init__(self):
        # جمع‌آوری متریک‌ها
        self.metrics_collector = MetricsCollector()
        
        # سیستم لاگینگ متمرکز
        self.logger = CentralizedLogger()
        
        # هشدارها
        self.alert_manager = AlertManager()
        
        # داشبورد
        self.dashboard = MonitoringDashboard()
    
    def monitor_service(self, service_name):
        """مانیتورینگ کامل یک سرویس"""
        metrics = {
            "cpu_usage": self.get_cpu_usage(),
            "memory_usage": self.get_memory_usage(),
            "request_rate": self.get_request_rate(),
            "error_rate": self.get_error_rate(),
            "response_time": self.get_avg_response_time(),
            "database_connections": self.get_db_connections(),
            "queue_length": self.get_queue_length()
        }
        
        # ذخیره متریک‌ها
        self.metrics_collector.store(service_name, metrics)
        
        # بررسی هشدارها
        self.check_alerts(service_name, metrics)
        
        # به‌روزرسانی داشبورد
        self.dashboard.update(service_name, metrics)
        
        return metrics

# مشکل: اسپاگتی کد (Spaghetti Code)
# راه حل: الگوهای طراحی

# قبل از بازسازی
def process_order(user_id, product_id, quantity, address, payment_method, discount_code):
    # ۱۰۰ خط کد درهم و برهم
    ...

# بعد از بازسازی با الگوهای طراحی
class OrderProcessor:
    def __init__(self):
        self.validator = OrderValidator()
        self.inventory = InventoryManager()
        self.pricing = PricingCalculator()
        self.payment = PaymentProcessor()
        self.shipping = ShippingHandler()
    
    def process(self, order_request):
        # هر مسئولیت جدا شده
        self.validator.validate(order_request)
        self.inventory.reserve_items(order_request.items)
        total = self.pricing.calculate(order_request)
        self.payment.process(order_request.payment, total)
        self.shipping.schedule_delivery(order_request)

# مقیاس‌پذیری عمودی (Vertical Scaling)
# - افزایش منابع سرور (CPU، RAM)
# - محدودیت: هزینه بالا و محدودیت فیزیکی

# مقیاس‌پذیری افقی (Horizontal Scaling)
# - اضافه کردن سرورهای بیشتر
# - نیازمند: Load Balancer + Stateless Services

class HorizontalScaler:
    def __init__(self):
        self.load_balancer = LoadBalancer()
        self.auto_scaler = AutoScaler()
        self.health_checker = HealthChecker()
    
    def handle_traffic_spike(self, current_traffic):
        """مدیریت افزایش ترافیک"""
        if current_traffic > self.threshold:
            # راه‌اندازی سرورهای جدید
            new_servers = self.auto_scaler.scale_out()
            
            # به‌روزرسانی Load Balancer
            self.load_balancer.add_servers(new_servers)
            
            # توزیع ترافیک
            self.load_balancer.distribute_traffic()

# بهینه‌سازی‌های عملکرد
optimizations = {
    "database": [
        "ایندکس‌گذاری مناسب",
        "کوئری‌های بهینه",
        "کش‌گذاری نتایج",
        "پارتیشن‌بندی داده‌ها"
    ],
    "application": [
        "کش‌گذاری در سطح برنامه",
        "لودینگ تنبل (Lazy Loading)",
        "فشرده‌سازی پاسخ‌ها",
        "مینی‌فای کردن منابع"
    ],
    "network": [
        "CDN برای فایل‌های استاتیک",
        "فشرده‌سازی Gzip/Brotli",
        "اتصال HTTP/2 یا HTTP/3",
        "کش‌گذاری مرورگر"
    ],
    "code_level": [
        "استفاده از ژنراتورها برای داده‌های بزرگ",
        "اجتناب از حلقه‌های تودرتو",
        "استفاده از کتابخانه‌های بهینه",
        "پروفایلینگ و پیدا کردن گلوگاه‌ها"
    ]
}

class SecurityManager:
    def __init__(self):
        self.authentication = AuthenticationSystem()
        self.authorization = AuthorizationSystem()
        self.encryption = EncryptionService()
        self.audit_logger = AuditLogger()
    
    def secure_endpoint(self, request):
        """امن‌سازی کامل یک درخواست"""
        
        # ۱. احراز هویت
        user = self.authentication.authenticate(request)
        
        # ۲. مجوزدهی
        if not self.authorization.is_authorized(user, request):
            raise PermissionDeniedError()
        
        # ۳. اعتبارسنجی ورودی
        self.validate_input(request.data)
        
        # ۴. لاگینگ امنیتی
        self.audit_logger.log_access(user, request)
        
        # ۵. رمزنگاری داده‌های حساس
        encrypted_data = self.encryption.encrypt_sensitive_data(request.data)
        
        # ۶. جلوگیری از حملات رایج
        self.prevent_common_attacks(request)
        
        return user, encrypted_data

# Git Flow برای پروژه‌های بزرگ
git_workflow = {
    "branches": {
        "main": "کد پایدار و آماده انتشار",
        "develop": "توسعه جاری",
        "feature/*": "توسعه ویژگی‌های جدید",
        "release/*": "آماده‌سازی برای انتشار",
        "hotfix/*": "رفع باگ‌های بحرانی"
    },
    "practices": [
        "Commit‌های کوچک و متمرکز",
        "پیام commit معنادار",
        "Code Review اجباری",
        "برنامه CI/CD پیوسته"
    ]
}

# فایل .gitlab-ci.yml یا .github/workflows
pipeline = {
    "stages": ["test", "build", "deploy"],
    "jobs": {
        "unit_tests": "اجرای تست واحد",
        "integration_tests": "تست یکپارچگی",
        "security_scan": "اسکن امنیتی",
        "performance_tests": "تست عملکرد",
        "docker_build": "ساخت image داکر",
        "deploy_staging": "استقرار در محیط staging",
        "deploy_production": "استقرار در محیط production"
    }
}

# Dockerfile برای پروژه پایتون
dockerfile_content = """
# مرحله ۱: ساخت
FROM python:3.11-slim as builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --user -r requirements.txt

# مرحله ۲: اجرا
FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY . .
ENV PATH=/root/.local/bin:$PATH
CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000"]
"""

# Stack مانیتورینگ کامل
monitoring_stack = {
    "metrics": "Prometheus",
    "visualization": "Grafana",
    "logging": "ELK Stack (Elasticsearch, Logstash, Kibana)",
    "tracing": "Jaeger / Zipkin",
    "alerting": "AlertManager / PagerDuty",
    "apm": "New Relic / Datadog / AppDynamics"
}

# جداسازی لایه دسترسی به داده
class UserRepository:
    def __init__(self, session):
        self.session = session
    
    def get_by_id(self, user_id):
        return self.session.query(User).filter_by(id=user_id).first()
    
    def get_by_email(self, email):
        return self.session.query(User).filter_by(email=email).first()
    
    def add(self, user):
        self.session.add(user)
        self.session.commit()
    
    def update(self, user):
        self.session.merge(user)
        self.session.commit()

# ایجاد اشیاء بدون وابستگی مستقیم
class NotificationFactory:
    @staticmethod
    def create_notifier(notification_type):
        notifiers = {
            "email": EmailNotifier(),
            "sms": SMSNotifier(),
            "push": PushNotifier(),
            "slack": SlackNotifier(),
            "webhook": WebhookNotifier()
        }
        return notifiers.get(notification_type, EmailNotifier())

# الگوریتم‌های قابل تعویض
class PaymentStrategy:
    def pay(self, amount):
        pass

class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        # پرداخت با کارت اعتباری
        pass

class PayPalPayment(PaymentStrategy):
    def pay(self, amount):
        # پرداخت با پی‌پال
        pass

class CryptocurrencyPayment(PaymentStrategy):
    def pay(self, amount):
        # پرداخت با رمزارز
        pass

class PaymentProcessor:
    def __init__(self, strategy: PaymentStrategy):
        self.strategy = strategy
    
    def process_payment(self, amount):
        return self.strategy.pay(amount)

project_plan = {
    "phase_1": {
        "duration": "2-4 هفته",
        "deliverables": [
            "تحلیل نیازمندی‌ها",
            "طراحی معماری",
            "بررسی تکنولوژی‌ها",
            "طرح MVP"
        ]
    },
    "phase_2": {
        "duration": "1-2 ماه",
        "deliverables": [
            "ایجاد هسته پروژه",
            "پیاده سازی ماژول‌های اصلی",
            "ایجاد پایگاه داده",
            "API اولیه"
        ]
    },
    "phase_3": {
        "duration": "2-3 ماه",
        "deliverables": [
            "تکمیل ماژول‌ها",
            "رابط کاربری",
            "تست‌ها",
            "مستندات"
        ]
    },
    "phase_4": {
        "duration": "مستمر",
        "deliverables": [
            "بهینه‌سازی",
            "مقیاس‌پذیری",
            "مانیتورینگ",
            "نگهداشت"
        ]
    }
}

# ساختار نمونه پروژه حجیم
mkdir -p my_mega_project/{src,tests,docs,scripts,data,notebooks,deploy}
cd my_mega_project

# ایجاد محیط مجازی
python -m venv venv
source venv/bin/activate  # یا venv\Scripts\activate در ویندوز

# نصب ابزارهای توسعه
pip install black flake8 mypy pytest pre-commit

# فایل‌های پیکربندی
touch requirements.txt pyproject.toml Dockerfile docker-compose.yml
touch .gitignore .pre-commit-config.yaml README.md

# ساختار src
mkdir -p src/{core,modules,utils,config,api,migrations}

# شروع با یک ماژول ساده
# ۱. تعریف مدل‌ها
# models/user.py
class User:
    def __init__(self, username, email):
        self.username = username
        self.email = email
        self.created_at = datetime.now()
    
    def validate(self):
        # اعتبارسنجی
        pass

# ۲. ایجاد Repository
# repositories/user_repository.py
class UserRepository:
    def save(self, user):
        # ذخیره در پایگاه داده
        pass

# ۳. ایجاد Service
# services/user_service.py
class UserService:
    def register(self, username, email, password):
        user = User(username, email)
        user.set_password(password)
        
        if user.validate():
            repository = UserRepository()
            repository.save(user)
            return user
        
        raise ValidationError()

# ۴. ایجاد API Endpoint
# api/v1/users.py
@router.post("/register")
def register_user(user_data: UserSchema):
    service = UserService()
    user = service.register(
        user_data.username,
        user_data.email,
        user_data.password
    )
    return {"message": "User registered", "user_id": user.id}

# ساختار کامل یک پروژه حجیم واقعی
hospital_system/
├── src/
│   ├── core/                      # هسته سیستم
│   │   ├── config/               # تنظیمات
│   │   ├── database/             # اتصال پایگاه داده
│   │   ├── exceptions/           # خطاهای سفارشی
│   │   └── middleware/           # میدلورها
│   │
│   ├── modules/                   # ماژول‌های کسب‌وکار
│   │   ├── patients/             # مدیریت بیماران
│   │   │   ├── models.py         # مدل‌های داده
│   │   │   ├── schemas.py        # اسکیمای Pydantic
│   │   │   ├── repositories.py   # دسترسی به داده
│   │   │   ├── services.py       # منطق کسب‌وکار
│   │   │   ├── api/              # endpoints API
│   │   │   └── tests/            # تست‌های این ماژول
│   │   │
│   │   ├── doctors/              # مدیریت پزشکان
│   │   ├── appointments/         # نوبت‌دهی
│   │   ├── medical_records/      # سوابق پزشکی
│   │   ├── billing/              # صورتحساب
│   │   ├── pharmacy/             # داروخانه
│   │   └── inventory/            # انبار تجهیزات
│   │
│   ├── shared/                    # اشتراکی‌ها
│   │   ├── utils/                # ابزارهای کمکی
│   │   ├── validators/           # اعتبارسنجی‌ها
│   │   └── decorators/           # دکوراتورها
│   │
│   ├── api/                       # لایه API
│   │   ├── v1/                   # نسخه ۱ API
│   │   ├── v2/                   # نسخه ۲ API
│   │   └── docs/                 # مستندات API
│   │
│   └── workers/                   # کارگران پس‌زمینه
│       ├── celery_tasks.py       # تسک‌های Celery
│       └── schedulers.py         # کارهای زمان‌بندی شده
│
├── tests/                         # تست‌ها
│   ├── unit/                     # تست واحد
│   ├── integration/              # تست یکپارچگی
│   ├── functional/               # تست عملکردی
│   └── fixtures/                 # داده‌های تست
│
├── docs/                          # مستندات
│   ├── api/                      # مستندات API
│   ├── architecture/             # مستندات معماری
│   ├── deployment/               # راهنمای استقرار
│   └── development/              # راهنمای توسعه
│
├── scripts/                       # اسکریپت‌های کمکی
│   ├── deploy/                   # استقرار
│   ├── backup/                   # پشتیبان‌گیری
│   └── maintenance/              # نگهداشت
│
├── docker/                        # کانفیگ Docker
│   ├── nginx/
│   ├── postgres/
│   └── redis/
│
├── .github/                       # GitHub Actions
│   └── workflows/
│
├── requirements/                  # نیازمندی‌ها
│   ├── base.txt                  # نیازمندی‌های اصلی
│   ├── dev.txt                   # نیازمندی‌های توسعه
│   └── prod.txt                  # نیازمندی‌های تولید
│
├── docker-compose.yml            # کانتینرهای چندگانه
├── docker-compose.override.yml   # توسعه محلی
├── .env.example                  # متغیرهای محیطی
├── pyproject.toml               # پیکربندی پروژه
├── alembic.ini                  # مهاجرت‌های دیتابیس
└── README.md                    # راهنمای شروع

required_skills = {
    "programming": [
        "پایتون پیشرفته",
        "الگوهای طراحی",
        "ساختار داده‌ها و الگوریتم‌ها",
        "برنامه‌نویسی همزمان و موازی"
    ],
    "databases": [
        "طراحی پایگاه داده",
        "بهینه‌سازی کوئری",
        "مدیریت تراکنش‌ها",
        "ریداکتوری و کش"
    ],
    "devops": [
        "داکر و کوبرنتیز",
        "CI/CD",
        "مانیتورینگ",
        "مقیاس‌پذیری"
    ],
    "architecture": [
        "معماری نرم‌افزار",
        "API Design",
        "سیستم‌های توزیع‌شده",
        "الگوهای یکپارچگی"
    ]
}

# architecture_design.md
"""
سیستم تجارت الکترونیک - معماری کلی

┌─────────────────────────────────────────────────────────────┐
│                    لایه Presentation                         │
├─────────────────────────────────────────────────────────────┤
│ • وب اپلیکیشن (React)                                       │
│ • اپلیکیشن موبایل (React Native)                           │
│ • API Gateway (NGINX + Kong)                               │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                    لایه Business Logic                      │
├─────────────────────────────────────────────────────────────┤
│ میکروسرویس‌ها:                                              │
│ 1. سرویس کاربران (User Service)                            │
│ 2. سرویس محصولات (Product Service)                         │
│ 3. سرویس سفارشات (Order Service)                           │
│ 4. سرویس پرداخت (Payment Service)                          │
│ 5. سرویس انبار (Inventory Service)                         │
│ 6. سرویس حمل‌ونقل (Shipping Service)                       │
│ 7. سرویس نوتیفیکیشن (Notification Service)                 │
└─────────────────────────────────────────────────────────────┘
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                    لایه Data                                 │
├─────────────────────────────────────────────────────────────┤
│ • PostgreSQL (داده‌های ساختاریافته)                        │
│ • MongoDB (داده‌های محصولات و کاتالوگ)                     │
│ • Redis (کش و سشن)                                          │
│ • Elasticsearch (جستجوی محصولات)                           │
│ • Kafka (استریم رویدادها)                                   │
└─────────────────────────────────────────────────────────────┘
"""

# ایجاد ساختار پروژه
mkdir -p ecommerce-platform/{deploy,docs,scripts,terraform,monitoring}
cd ecommerce-platform

# ایجاد محیط توسعه
python -m venv .venv
source .venv/bin/activate

# نصب ابزارهای اصلی
pip install poetry  # یا pipenv
poetry init

# ایجاد ساختار سرویس‌ها
mkdir -p services/{user-service,product-service,order-service,payment-service}
mkdir -p shared/{common,utils,models,exceptions}
mkdir -p infrastructure/{k8s,docker,database}

# services/user-service/src/
# ۱. مدل‌های داده
# models/user.py
from sqlalchemy import Column, String, DateTime, Boolean
from sqlalchemy.dialects.postgresql import UUID
import uuid
from datetime import datetime

class User:
    __tablename__ = 'users'
    
    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
    email = Column(String(255), unique=True, nullable=False, index=True)
    username = Column(String(50), unique=True, nullable=False)
    password_hash = Column(String(255), nullable=False)
    first_name = Column(String(100))
    last_name = Column(String(100))
    phone = Column(String(20))
    is_active = Column(Boolean, default=True)
    is_verified = Column(Boolean, default=False)
    created_at = Column(DateTime, default=datetime.utcnow)
    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # روابط
    addresses = relationship("UserAddress", back_populates="user")
    orders = relationship("Order", back_populates="user")
    roles = relationship("UserRole", back_populates="user")

# ۲. اسکیمای Pydantic برای اعتبارسنجی
# schemas/user.py
from pydantic import BaseModel, EmailStr, validator
from typing import Optional
from datetime import datetime

class UserBase(BaseModel):
    email: EmailStr
    username: str
    first_name: Optional[str] = None
    last_name: Optional[str] = None
    
    @validator('username')
    def username_alphanumeric(cls, v):
        if not v.isalnum():
            raise ValueError('نام کاربری باید حروف و اعداد باشد')
        return v.lower()

class UserCreate(UserBase):
    password: str
    password_confirm: str
    
    @validator('password_confirm')
    def passwords_match(cls, v, values):
        if 'password' in values and v != values['password']:
            raise ValueError('رمزهای عبور مطابقت ندارند')
        return v

class UserResponse(UserBase):
    id: uuid.UUID
    is_active: bool
    created_at: datetime
    
    class Config:
        orm_mode = True

# ۳. Repository برای دسترسی به داده
# repositories/user_repository.py
from sqlalchemy.orm import Session
from typing import Optional, List
from models.user import User

class UserRepository:
    def __init__(self, db: Session):
        self.db = db
    
    def create(self, user_data: dict) -> User:
        user = User(**user_data)
        self.db.add(user)
        self.db.commit()
        self.db.refresh(user)
        return user
    
    def get_by_id(self, user_id: uuid.UUID) -> Optional[User]:
        return self.db.query(User).filter(User.id == user_id).first()
    
    def get_by_email(self, email: str) -> Optional[User]:
        return self.db.query(User).filter(User.email == email).first()
    
    def get_by_username(self, username: str) -> Optional[User]:
        return self.db.query(User).filter(User.username == username).first()
    
    def update(self, user_id: uuid.UUID, update_data: dict) -> Optional[User]:
        user = self.get_by_id(user_id)
        if user:
            for key, value in update_data.items():
                setattr(user, key, value)
            self.db.commit()
            self.db.refresh(user)
        return user
    
    def delete(self, user_id: uuid.UUID) -> bool:
        user = self.get_by_id(user_id)
        if user:
            self.db.delete(user)
            self.db.commit()
            return True
        return False
    
    def list_users(self, skip: int = 0, limit: int = 100) -> List[User]:
        return self.db.query(User).offset(skip).limit(limit).all()

# ۴. سرویس کسب‌وکار
# services/user_service.py
import bcrypt
import jwt
from datetime import datetime, timedelta
from typing import Optional, Tuple
from repositories.user_repository import UserRepository
from schemas.user import UserCreate, UserResponse

class UserService:
    def __init__(self, user_repo: UserRepository, secret_key: str):
        self.user_repo = user_repo
        self.secret_key = secret_key
    
    def register_user(self, user_data: UserCreate) -> Tuple[Optional[UserResponse], Optional[str]]:
        # بررسی وجود کاربر
        if self.user_repo.get_by_email(user_data.email):
            return None, "ایمیل قبلاً ثبت شده است"
        
        if self.user_repo.get_by_username(user_data.username):
            return None, "نام کاربری قبلاً انتخاب شده است"
        
        # هش کردن رمز عبور
        password_hash = self._hash_password(user_data.password)
        
        # ایجاد کاربر
        user_dict = user_data.dict(exclude={'password', 'password_confirm'})
        user_dict['password_hash'] = password_hash
        
        user = self.user_repo.create(user_dict)
        
        # ایجاد توکن JWT
        token = self._create_access_token(user.id)
        
        return UserResponse.from_orm(user), token
    
    def authenticate_user(self, email: str, password: str) -> Tuple[Optional[UserResponse], Optional[str]]:
        user = self.user_repo.get_by_email(email)
        if not user or not self._verify_password(password, user.password_hash):
            return None, "ایمیل یا رمز عبور اشتباه است"
        
        if not user.is_active:
            return None, "حساب کاربری غیرفعال است"
        
        token = self._create_access_token(user.id)
        return UserResponse.from_orm(user), token
    
    def _hash_password(self, password: str) -> str:
        salt = bcrypt.gensalt()
        return bcrypt.hashpw(password.encode('utf-8'), salt).decode('utf-8')
    
    def _verify_password(self, plain_password: str, hashed_password: str) -> bool:
        return bcrypt.checkpw(
            plain_password.encode('utf-8'),
            hashed_password.encode('utf-8')
        )
    
    def _create_access_token(self, user_id: uuid.UUID) -> str:
        payload = {
            'sub': str(user_id),
            'exp': datetime.utcnow() + timedelta(days=7),
            'iat': datetime.utcnow(),
            'type': 'access'
        }
        return jwt.encode(payload, self.secret_key, algorithm='HS256')

# ۵. API Endpoints
# api/v1/users.py
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from typing import List
from schemas.user import UserCreate, UserResponse
from services.user_service import UserService
from dependencies import get_db, get_current_user

router = APIRouter(prefix="/users", tags=["users"])

@router.post("/register", response_model=dict, status_code=status.HTTP_201_CREATED)
async def register(
    user_data: UserCreate,
    user_service: UserService = Depends(UserService),
    db: Session = Depends(get_db)
):
    """ثبت کاربر جدید"""
    user_repo = UserRepository(db)
    service = UserService(user_repo, "SECRET_KEY")
    
    user, token = service.register_user(user_data)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail="خطا در ثبت نام"
        )
    
    return {
        "message": "ثبت نام موفقیت‌آمیز بود",
        "user": user,
        "access_token": token,
        "token_type": "bearer"
    }

@router.post("/login", response_model=dict)
async def login(
    email: str,
    password: str,
    user_service: UserService = Depends(UserService),
    db: Session = Depends(get_db)
):
    """ورود کاربر"""
    user_repo = UserRepository(db)
    service = UserService(user_repo, "SECRET_KEY")
    
    user, token = service.authenticate_user(email, password)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="احراز هویت ناموفق"
        )
    
    return {
        "access_token": token,
        "token_type": "bearer",
        "user": user
    }

@router.get("/me", response_model=UserResponse)
async def get_current_user_info(
    current_user: UserResponse = Depends(get_current_user)
):
    """دریافت اطلاعات کاربر جاری"""
    return current_user

@router.get("/", response_model=List[UserResponse])
async def list_users(
    skip: int = 0,
    limit: int = 100,
    db: Session = Depends(get_db),
    current_user: UserResponse = Depends(get_current_user)
):
    """لیست کاربران (فقط مدیران)"""
    if not current_user.is_admin:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="دسترسی غیرمجاز"
        )
    
    user_repo = UserRepository(db)
    users = user_repo.list_users(skip, limit)
    return users

# services/user-service/Dockerfile
# Stage 1: Builder
FROM python:3.11-slim as builder

WORKDIR /app

# نصب وابستگی‌های سیستم
RUN apt-get update && apt-get install -y \
    gcc \
    g++ \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

# کپی فایل وابستگی‌ها
COPY pyproject.toml poetry.lock* ./

# نصب Poetry و وابستگی‌ها
RUN pip install poetry && \
    poetry config virtualenvs.create false && \
    poetry install --no-dev --no-interaction --no-ansi

# Stage 2: Runtime
FROM python:3.11-slim

WORKDIR /app

# کپی وابستگی‌ها از مرحله builder
COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
COPY --from=builder /usr/local/bin /usr/local/bin

# کپی کد اپلیکیشن
COPY . .

# ایجاد کاربر غیر root
RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
USER appuser

# پورت اکسپوز
EXPOSE 8000

# کامند اجرا
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "4"]

# docker-compose.yml
version: '3.8'

services:
  # پایگاه‌داده PostgreSQL
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secretpassword
      POSTGRES_DB: ecommerce
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    networks:
      - ecommerce-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U admin"]
      interval: 10s
      timeout: 5s
      retries: 5

  # کش Redis
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - ecommerce-network
    command: redis-server --appendonly yes

  # سرویس کاربران
  user-service:
    build:
      context: ./services/user-service
      dockerfile: Dockerfile
    environment:
      DATABASE_URL: postgresql://admin:secretpassword@postgres:5432/ecommerce
      REDIS_URL: redis://redis:6379/0
      JWT_SECRET_KEY: supersecretjwtkey
    ports:
      - "8001:8000"
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - ecommerce-network
    volumes:
      - ./services/user-service:/app
      - /app/.venv

  # NGINX به عنوان API Gateway
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./ssl:/etc/nginx/ssl
    depends_on:
      - user-service
      - product-service
      - order-service
    networks:
      - ecommerce-network

  # مانیتورینگ با Prometheus و Grafana
  prometheus:
    image: prom/prometheus:latest
    ports:
      - "9090:9090"
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    networks:
      - ecommerce-network

  grafana:
    image: grafana/grafana:latest
    ports:
      - "3000:3000"
    environment:
      GF_SECURITY_ADMIN_PASSWORD: admin
    volumes:
      - grafana_data:/var/lib/grafana
      - ./monitoring/grafana/dashboards:/etc/grafana/provisioning/dashboards
    depends_on:
      - prometheus
    networks:
      - ecommerce-network

volumes:
  postgres_data:
  redis_data:
  prometheus_data:
  grafana_data:

networks:
  ecommerce-network:
    driver: bridge

# alembic/versions/001_initial_migration.py
"""initial migration

Revision ID: 001
Revises: 
Create Date: 2024-01-01 00:00:00.000000
"""

from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql

def upgrade():
    # ایجاد جدول کاربران
    op.create_table('users',
        sa.Column('id', postgresql.UUID(as_uuid=True), nullable=False),
        sa.Column('email', sa.String(length=255), nullable=False),
        sa.Column('username', sa.String(length=50), nullable=False),
        sa.Column('password_hash', sa.String(length=255), nullable=False),
        sa.Column('first_name', sa.String(length=100), nullable=True),
        sa.Column('last_name', sa.String(length=100), nullable=True),
        sa.Column('phone', sa.String(length=20), nullable=True),
        sa.Column('is_active', sa.Boolean(), nullable=True),
        sa.Column('is_verified', sa.Boolean(), nullable=True),
        sa.Column('is_admin', sa.Boolean(), nullable=True),
        sa.Column('created_at', sa.DateTime(), nullable=True),
        sa.Column('updated_at', sa.DateTime(), nullable=True),
        sa.PrimaryKeyConstraint('id')
    )
    
    # ایجاد ایندکس
    op.create_index(op.f('ix_users_email'), 'users', ['email'], unique=True)
    op.create_index(op.f('ix_users_username'), 'users', ['username'], unique=True)
    
    # ایجاد جدول آدرس‌ها
    op.create_table('user_addresses',
        sa.Column('id', postgresql.UUID(as_uuid=True), nullable=False),
        sa.Column('user_id', postgresql.UUID(as_uuid=True), nullable=False),
        sa.Column('address_line1', sa.String(length=255), nullable=False),
        sa.Column('address_line2', sa.String(length=255), nullable=True),
        sa.Column('city', sa.String(length=100), nullable=False),
        sa.Column('state', sa.String(length=100), nullable=False),
        sa.Column('postal_code', sa.String(length=20), nullable=False),
        sa.Column('country', sa.String(length=100), nullable=False),
        sa.Column('is_default', sa.Boolean(), nullable=True),
        sa.Column('created_at', sa.DateTime(), nullable=True),
        sa.Column('updated_at', sa.DateTime(), nullable=True),
        sa.ForeignKeyConstraint(['user_id'], ['users.id'], ondelete='CASCADE'),
        sa.PrimaryKeyConstraint('id')
    )

def downgrade():
    op.drop_table('user_addresses')
    op.drop_table('users')

# tests/test_user_service.py
import pytest
from unittest.mock import Mock, patch
from services.user_service import UserService
from repositories.user_repository import UserRepository
from schemas.user import UserCreate
import bcrypt

class TestUserService:
    @pytest.fixture
    def mock_repo(self):
        return Mock(spec=UserRepository)
    
    @pytest.fixture
    def user_service(self, mock_repo):
        return UserService(mock_repo, "test_secret_key")
    
    def test_register_user_success(self, user_service, mock_repo):
        # Arrange
        user_data = UserCreate(
            email="test@example.com",
            username="testuser",
            password="password123",
            password_confirm="password123",
            first_name="John",
            last_name="Doe"
        )
        
        mock_repo.get_by_email.return_value = None
        mock_repo.get_by_username.return_value = None
        
        # Act
        result, token = user_service.register_user(user_data)
        
        # Assert
        assert result is not None
        assert token is not None
        assert result.email == user_data.email
        assert result.username == user_data.username
        mock_repo.create.assert_called_once()
    
    def test_register_user_duplicate_email(self, user_service, mock_repo):
        # Arrange
        user_data = UserCreate(
            email="existing@example.com",
            username="newuser",
            password="password123",
            password_confirm="password123"
        )
        
        mock_repo.get_by_email.return_value = Mock()  # شبیه‌سازی کاربر موجود
        
        # Act
        result, error = user_service.register_user(user_data)
        
        # Assert
        assert result is None
        assert error == "ایمیل قبلاً ثبت شده است"
    
    def test_authenticate_user_success(self, user_service, mock_repo):
        # Arrange
        email = "test@example.com"
        password = "password123"
        
        # شبیه‌سازی هش رمز عبور
        salt = bcrypt.gensalt()
        hashed_password = bcrypt.hashpw(password.encode('utf-8'), salt)
        
        mock_user = Mock()
        mock_user.id = "user_id"
        mock_user.email = email
        mock_user.password_hash = hashed_password.decode('utf-8')
        mock_user.is_active = True
        
        mock_repo.get_by_email.return_value = mock_user
        
        # Act
        user, token = user_service.authenticate_user(email, password)
        
        # Assert
        assert user is not None
        assert token is not None
        assert user.email == email
    
    def test_authenticate_user_wrong_password(self, user_service, mock_repo):
        # Arrange
        email = "test@example.com"
        
        mock_user = Mock()
        mock_user.password_hash = bcrypt.hashpw(
            "correct_password".encode('utf-8'),
            bcrypt.gensalt()
        ).decode('utf-8')
        
        mock_repo.get_by_email.return_value = mock_user
        
        # Act
        user, error = user_service.authenticate_user(email, "wrong_password")
        
        # Assert
        assert user is None
        assert error == "ایمیل یا رمز عبور اشتباه است"

# tests/test_api.py
from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_register_endpoint():
    response = client.post("/api/v1/users/register", json={
        "email": "newuser@example.com",
        "username": "newuser",
        "password": "password123",
        "password_confirm": "password123",
        "first_name": "New",
        "last_name": "User"
    })
    
    assert response.status_code == 201
    data = response.json()
    assert "access_token" in data
    assert data["message"] == "ثبت نام موفقیت‌آمیز بود"

def test_login_endpoint():
    # اول ثبت نام
    client.post("/api/v1/users/register", json={
        "email": "login@example.com",
        "username": "loginuser",
        "password": "password123",
        "password_confirm": "password123"
    })
    
    # سپس ورود
    response = client.post("/api/v1/users/login", data={
        "username": "login@example.com",
        "password": "password123"
    })
    
    assert response.status_code == 200
    data = response.json()
    assert "access_token" in data

# tests/test_performance.py
import asyncio
from locust import HttpUser, task, between
import random

class ECommerceUser(HttpUser):
    wait_time = between(1, 3)
    
    def on_start(self):
        """ورود کاربر در شروع تست"""
        self.login()
    
    def login(self):
        response = self.client.post("/api/v1/users/login", json={
            "email": f"user{random.randint(1, 1000)}@test.com",
            "password": "password123"
        })
        if response.status_code == 200:
            self.token = response.json()["access_token"]
            self.headers = {"Authorization": f"Bearer {self.token}"}
    
    @task(3)
    def view_products(self):
        """مشاهده محصولات"""
        self.client.get("/api/v1/products", headers=self.headers)
    
    @task(2)
    def view_product_detail(self):
        """مشاهده جزئیات محصول"""
        product_id = random.randint(1, 100)
        self.client.get(f"/api/v1/products/{product_id}", headers=self.headers)
    
    @task(1)
    def create_order(self):
        """ایجاد سفارش"""
        self.client.post("/api/v1/orders", json={
            "items": [
                {"product_id": random.randint(1, 100), "quantity": random.randint(1, 3)}
            ],
            "shipping_address_id": 1
        }, headers=self.headers)

# .github/workflows/ci-cd.yml
name: CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    
    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: testpassword
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        ports:
          - 5432:5432
      
      redis:
        image: redis:7-alpine
        ports:
          - 6379:6379
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: '3.11'
    
    - name: Install dependencies
      run: |
        pip install poetry
        poetry install
    
    - name: Run linting
      run: |
        poetry run black --check .
        poetry run flake8 .
        poetry run mypy .
    
    - name: Run unit tests
      env:
        DATABASE_URL: postgresql://postgres:testpassword@localhost:5432/test_db
        REDIS_URL: redis://localhost:6379/0
      run: |
        poetry run pytest tests/unit -v --cov=src --cov-report=xml
    
    - name: Run integration tests
      env:
        DATABASE_URL: postgresql://postgres:testpassword@localhost:5432/test_db
        REDIS_URL: redis://localhost:6379/0
      run: |
        poetry run pytest tests/integration -v
    
    - name: Upload coverage to Codecov
      uses: codecov/codecov-action@v3
      with:
        file: ./coverage.xml

  build:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v2
    
    - name: Log in to Docker Hub
      uses: docker/login-action@v2
      with:
        username: ${{ secrets.DOCKER_USERNAME }}
        password: ${{ secrets.DOCKER_PASSWORD }}
    
    - name: Build and push User Service
      uses: docker/build-push-action@v4
      with:
        context: ./services/user-service
        file: ./services/user-service/Dockerfile
        push: true
        tags: |
          ${{ secrets.DOCKER_USERNAME }}/user-service:latest
          ${{ secrets.DOCKER_USERNAME }}/user-service:${{ github.sha }}
    
    - name: Build and push Product Service
      uses: docker/build-push-action@v4
      with:
        context: ./services/product-service
        push: true
        tags: ${{ secrets.DOCKER_USERNAME }}/product-service:${{ github.sha }}

  deploy:
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Configure AWS credentials
      uses: aws-actions/configure-aws-credentials@v1
      with:
        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        aws-region: us-east-1
    
    - name: Deploy to EKS
      run: |
        aws eks update-kubeconfig --name ecommerce-cluster
        kubectl apply -f ./k8s/
        kubectl rollout status deployment/user-service
        kubectl rollout status deployment/product-service
    
    - name: Run smoke tests
      run: |
        ./scripts/smoke-test.sh

# terraform/main.tf
terraform {
  required_version = ">= 1.0"
  
  backend "s3" {
    bucket = "ecommerce-tf-state"
    key    = "production/terraform.tfstate"
    region = "us-east-1"
  }
}

provider "aws" {
  region = var.aws_region
}

# VPC
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true
  
  tags = {
    Name = "ecommerce-vpc"
  }
}

# EKS Cluster
resource "aws_eks_cluster" "main" {
  name     = "ecommerce-cluster"
  role_arn = aws_iam_role.eks_cluster.arn
  
  vpc_config {
    subnet_ids = [
      aws_subnet.public_1.id,
      aws_subnet.public_2.id,
      aws_subnet.private_1.id,
      aws_subnet.private_2.id
    ]
    
    endpoint_public_access  = true
    endpoint_private_access = true
  }
  
  depends_on = [
    aws_iam_role_policy_attachment.eks_cluster_policy
  ]
}

# RDS PostgreSQL
resource "aws_db_instance" "postgres" {
  identifier              = "ecommerce-postgres"
  engine                 = "postgres"
  engine_version         = "15.3"
  instance_class         = "db.t3.medium"
  allocated_storage      = 100
  storage_type          = "gp3"
  
  db_name  = "ecommerce"
  username = var.db_username
  password = var.db_password
  
  vpc_security_group_ids = [aws_security_group.rds.id]
  db_subnet_group_name   = aws_db_subnet_group.main.name
  
  backup_retention_period = 7
  backup_window          = "03:00-04:00"
  maintenance_window     = "sun:04:00-sun:05:00"
  
  multi_az               = true
  deletion_protection    = true
  
  tags = {
    Name = "ecommerce-postgres"
  }
}

# ElastiCache Redis
resource "aws_elasticache_cluster" "redis" {
  cluster_id           = "ecommerce-redis"
  engine              = "redis"
  node_type           = "cache.t3.medium"
  num_cache_nodes     = 1
  parameter_group_name = "default.redis7"
  port                = 6379
  
  subnet_group_name  = aws_elasticache_subnet_group.main.name
  security_group_ids = [aws_security_group.redis.id]
  
  tags = {
    Name = "ecommerce-redis"
  }
}

# Load Balancer
resource "aws_lb" "main" {
  name               = "ecommerce-lb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.lb.id]
  subnets           = [
    aws_subnet.public_1.id,
    aws_subnet.public_2.id
  ]
  
  enable_deletion_protection = true
  
  tags = {
    Name = "ecommerce-load-balancer"
  }
}

# monitoring/metrics.py
from prometheus_client import Counter, Histogram, Gauge, generate_latest
import time
from functools import wraps

# تعریف متریک‌ها
REQUEST_COUNT = Counter(
    'http_requests_total',
    'Total HTTP requests',
    ['method', 'endpoint', 'status']
)

REQUEST_LATENCY = Histogram(
    'http_request_duration_seconds',
    'HTTP request latency',
    ['method', 'endpoint']
)

ACTIVE_USERS = Gauge(
    'active_users',
    'Number of active users'
)

DATABASE_CONNECTIONS = Gauge(
    'database_connections',
    'Number of active database connections'
)

# دکوراتور برای مانیتورینگ
def monitor_request(func):
    @wraps(func)
    async def wrapper(*args, **kwargs):
        start_time = time.time()
        
        try:
            response = await func(*args, **kwargs)
            
            # ثبت متریک‌ها
            REQUEST_COUNT.labels(
                method=kwargs.get('method', 'GET'),
                endpoint=func.__name__,
                status=response.status_code
            ).inc()
            
            REQUEST_LATENCY.labels(
                method=kwargs.get('method', 'GET'),
                endpoint=func.__name__
            ).observe(time.time() - start_time)
            
            return response
            
        except Exception as e:
            REQUEST_COUNT.labels(
                method=kwargs.get('method', 'GET'),
                endpoint=func.__name__,
                status=500
            ).inc()
            raise e
    
    return wrapper

# مانیتورینگ پایگاه داده
class DatabaseMonitor:
    def __init__(self, engine):
        self.engine = engine
        
    async def collect_metrics(self):
        # جمع‌آوری متریک‌های پایگاه داده
        with self.engine.connect() as conn:
            result = conn.execute("SELECT count(*) FROM pg_stat_activity")
            active_connections = result.scalar()
            
            DATABASE_CONNECTIONS.set(active_connections)
            
            # متریک‌های دیگر
            result = conn.execute("SELECT count(*) FROM users")
            total_users = result.scalar()
            
            result = conn.execute("""
                SELECT count(*) FROM users 
                WHERE last_login > NOW() - INTERVAL '30 minutes'
            """)
            active_users_count = result.scalar()
            
            ACTIVE_USERS.set(active_users_count)
            
            return {
                'active_connections': active_connections,
                'total_users': total_users,
                'active_users': active_users_count
            }

# لاگینگ ساختاریافته
import structlog

logger = structlog.get_logger()

def setup_logging():
    structlog.configure(
        processors=[
            structlog.contextvars.merge_contextvars,
            structlog.processors.add_log_level,
            structlog.processors.StackInfoRenderer(),
            structlog.dev.set_exc_info,
            structlog.processors.TimeStamper(fmt="iso"),
            structlog.dev.ConsoleRenderer()
        ],
        wrapper_class=structlog.make_filtering_bound_logger(logging.INFO),
        context_class=dict,
        logger_factory=structlog.PrintLoggerFactory(),
        cache_logger_on_first_use=False
    )

# Tracing با OpenTelemetry
from opente