monkeybrain-runtime 1.0.0__py3-none-any.whl

services/common/tracing.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import json
+import logging
+import logging.handlers
+import os
+import time
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI, Request
+
+
+logger = logging.getLogger(__name__)
+
+
+def _env_int(name: str, default: int) -> int:
+    try:
+        return int(os.getenv(name, str(default)))
+    except ValueError:
+        return default
+
+
+def _env_float(name: str, default: float) -> float:
+    try:
+        return float(os.getenv(name, str(default)))
+    except ValueError:
+        return default
+
+
+def _json_default(value: Any) -> str:
+    return str(value)
+
+
+def _local_trace_logger(service_name: str) -> logging.Logger:
+    trace_dir = Path(os.getenv("TRACE_DIR", os.getenv("LOG_TRACE_DIR", "logs/traces")))
+    trace_dir.mkdir(parents=True, exist_ok=True)
+
+    trace_logger = logging.getLogger(f"{service_name}.route_traces")
+    trace_logger.setLevel(logging.INFO)
+    trace_logger.propagate = False
+
+    trace_path = trace_dir / f"{service_name}.jsonl"
+    existing = [
+        handler
+        for handler in trace_logger.handlers
+        if isinstance(handler, logging.handlers.RotatingFileHandler)
+        and Path(handler.baseFilename) == trace_path
+    ]
+    if not existing:
+        handler = logging.handlers.RotatingFileHandler(
+            trace_path,
+            maxBytes=_env_int("TRACE_MAX_BYTES", 25 * 1024 * 1024),
+            backupCount=_env_int("TRACE_BACKUP_COUNT", 5),
+            encoding="utf-8",
+        )
+        handler.setFormatter(logging.Formatter("%(message)s"))
+        trace_logger.handlers = [handler]
+
+    return trace_logger
+
+
+def _elk_trace_logger(service_name: str) -> logging.Logger:
+    trace_logger = logging.getLogger(f"{service_name}.route_traces")
+    trace_logger.setLevel(logging.INFO)
+    trace_logger.handlers = []
+    trace_logger.propagate = True
+    return trace_logger
+
+
+def _configure_sentry(service_name: str):
+    dsn = os.getenv("SENTRY_DSN", "").strip()
+    if not dsn:
+        logger.warning("TRACE_MODE=sentry requested, but SENTRY_DSN is not configured; using local traces")
+        return None
+
+    try:
+        import sentry_sdk
+        from sentry_sdk.integrations.fastapi import FastApiIntegration
+    except ImportError:
+        logger.warning("TRACE_MODE=sentry requested, but sentry-sdk is not installed; using local traces")
+        return None
+
+    sentry_sdk.init(
+        dsn=dsn,
+        environment=os.getenv("SENTRY_ENVIRONMENT", os.getenv("ENVIRONMENT", "development")),
+        release=os.getenv("SENTRY_RELEASE"),
+        traces_sample_rate=_env_float("SENTRY_TRACES_SAMPLE_RATE", 1.0),
+        profiles_sample_rate=_env_float("SENTRY_PROFILES_SAMPLE_RATE", 0.0),
+        integrations=[FastApiIntegration()],
+        send_default_pii=os.getenv("SENTRY_SEND_DEFAULT_PII", "false").lower() == "true",
+    )
+    sentry_sdk.set_tag("service", service_name)
+    return sentry_sdk
+
+
+def install_route_tracing(app: FastAPI, service_name: str) -> None:
+    backend = os.getenv("TRACE_MODE", os.getenv("TRACE_BACKEND", "elk")).strip().lower()
+    if backend in {"off", "none", "disabled"}:
+        return
+
+    sentry_sdk = _configure_sentry(service_name) if backend == "sentry" else None
+    trace_logger = None if sentry_sdk else (_local_trace_logger(service_name) if backend == "local" else _elk_trace_logger(service_name))
+
+    @app.middleware("http")
+    async def route_trace_interceptor(request: Request, call_next):
+        trace_id = request.headers.get("x-trace-id") or request.headers.get("x-request-id") or str(uuid.uuid4())
+        start = time.perf_counter()
+        started_at = datetime.now(timezone.utc)
+        client_host = request.client.host if request.client else "-"
+
+        trace: dict[str, Any] = {
+            "trace_id": trace_id,
+            "service": service_name,
+            "started_at": started_at.isoformat(),
+            "method": request.method,
+            "path": request.url.path,
+            "query": str(request.url.query),
+            "client_host": client_host,
+            "user_agent": request.headers.get("user-agent", ""),
+        }
+
+        try:
+            response = await call_next(request)
+            trace["status_code"] = response.status_code
+            response.headers["x-trace-id"] = trace_id
+            return response
+        except Exception as exc:
+            trace["error"] = {
+                "type": exc.__class__.__name__,
+                "message": str(exc),
+            }
+            if sentry_sdk:
+                sentry_sdk.set_context("route_trace", trace)
+                sentry_sdk.capture_exception(exc)
+            raise
+        finally:
+            trace["finished_at"] = datetime.now(timezone.utc).isoformat()
+            trace["duration_ms"] = round((time.perf_counter() - start) * 1000, 2)
+
+            if sentry_sdk:
+                sentry_sdk.set_tag("trace_id", trace_id)
+                sentry_sdk.set_context("route_trace", trace)
+                if trace.get("status_code", 200) >= 500 and "error" not in trace:
+                    sentry_sdk.capture_message(
+                        f"{service_name} {request.method} {request.url.path} returned {trace['status_code']}",
+                        level="error",
+                    )
+            elif trace_logger:
+                trace_logger.info(
+                    "route trace",
+                    extra={
+                        "event": "route_trace",
+                        "trace_type": "route",
+                        **trace,
+                    },
+                )

services/common/utils.py

@@ -0,0 +1,30 @@
+from datetime import date, datetime, timezone
+from typing import Optional
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+def _prepare(value):
+    """Recursively convert date/datetime values into BSON-safe datetimes."""
+    if isinstance(value, datetime):
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value.astimezone(timezone.utc)
+    if isinstance(value, date):
+        return datetime(value.year, value.month, value.day, tzinfo=timezone.utc)
+    if isinstance(value, dict):
+        return {k: _prepare(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_prepare(v) for v in value]
+    return value
+

services/customers/helpers/__init__.py

@@ -0,0 +1,8 @@
+"""customers service helpers package."""
+
+__all__ = [
+    "customer_details",
+    "customer_metadata",
+    "customer_order_metrics",
+    "customer_payment_data",
+]

services/customers/helpers/customer_details.py

@@ -0,0 +1,64 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.customers.models.customer_details import CustomerDetailsCreate, CustomerDetailsUpdate
+
+COLLECTION = "customer_details"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    query: dict = {}
+    total = await db[COLLECTION].count_documents(query)
+    cursor = db[COLLECTION].find(query).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(doc) async for doc in cursor], total
+
+
+async def get_by_customer_id(
+    db: AsyncIOMotorDatabase,
+    customer_id: str,
+) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"customer_id": customer_id}))
+
+
+async def create(db: AsyncIOMotorDatabase, data: CustomerDetailsCreate) -> dict:
+    doc = data.model_dump()
+    if not doc.get("customer_id"):
+        doc["customer_id"] = f"customer-{uuid4().hex[:12]}"
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    customer_id: str,
+    data: CustomerDetailsUpdate,
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_customer_id(db, customer_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"customer_id": customer_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, customer_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"customer_id": customer_id})
+    return result.deleted_count == 1

services/customers/helpers/customer_metadata.py

@@ -0,0 +1,64 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.customers.models.customer_metadata import CustomerMetadataCreate, CustomerMetadataUpdate
+
+COLLECTION = "customer_metadata"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    query: dict = {}
+    total = await db[COLLECTION].count_documents(query)
+    cursor = db[COLLECTION].find(query).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(doc) async for doc in cursor], total
+
+
+async def get_by_customer_id(
+    db: AsyncIOMotorDatabase,
+    customer_id: str,
+) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"customer_id": customer_id}))
+
+
+async def create(db: AsyncIOMotorDatabase, data: CustomerMetadataCreate) -> dict:
+    doc = data.model_dump()
+    if not doc.get("customer_id"):
+        doc["customer_id"] = f"customer-{uuid4().hex[:12]}"
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    customer_id: str,
+    data: CustomerMetadataUpdate,
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_customer_id(db, customer_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"customer_id": customer_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, customer_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"customer_id": customer_id})
+    return result.deleted_count == 1

services/customers/helpers/customer_order_metrics.py

@@ -0,0 +1,67 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.customers.models.customer_order_metrics import (
+    CustomerOrderMetricsCreate,
+    CustomerOrderMetricsUpdate,
+)
+
+COLLECTION = "customer_order_metrics"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    query: dict = {}
+    total = await db[COLLECTION].count_documents(query)
+    cursor = db[COLLECTION].find(query).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(doc) async for doc in cursor], total
+
+
+async def get_by_customer_id(
+    db: AsyncIOMotorDatabase,
+    customer_id: str,
+) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"customer_id": customer_id}))
+
+
+async def create(db: AsyncIOMotorDatabase, data: CustomerOrderMetricsCreate) -> dict:
+    doc = data.model_dump()
+    if not doc.get("customer_id"):
+        doc["customer_id"] = f"customer-{uuid4().hex[:12]}"
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    customer_id: str,
+    data: CustomerOrderMetricsUpdate,
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_customer_id(db, customer_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"customer_id": customer_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, customer_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"customer_id": customer_id})
+    return result.deleted_count == 1

services/customers/helpers/customer_payment_data.py

@@ -0,0 +1,67 @@
+from typing import Optional
+from uuid import uuid4
+
+from motor.motor_asyncio import AsyncIOMotorDatabase
+from pymongo import ReturnDocument
+
+from services.customers.models.customer_payment_data import (
+    CustomerPaymentDataCreate,
+    CustomerPaymentDataUpdate,
+)
+
+COLLECTION = "customer_payment_data"
+
+
+def _serialize(doc: Optional[dict]) -> Optional[dict]:
+    if not doc:
+        return None
+    doc = dict(doc)
+    doc.pop("_id", None)
+    return doc
+
+
+async def get_all(
+    db: AsyncIOMotorDatabase,
+    page: int = 1,
+    page_size: int = 20,
+) -> tuple[list[dict], int]:
+    query: dict = {}
+    total = await db[COLLECTION].count_documents(query)
+    cursor = db[COLLECTION].find(query).skip((page - 1) * page_size).limit(page_size)
+    return [_serialize(doc) async for doc in cursor], total
+
+
+async def get_by_customer_id(
+    db: AsyncIOMotorDatabase,
+    customer_id: str,
+) -> Optional[dict]:
+    return _serialize(await db[COLLECTION].find_one({"customer_id": customer_id}))
+
+
+async def create(db: AsyncIOMotorDatabase, data: CustomerPaymentDataCreate) -> dict:
+    doc = data.model_dump()
+    if not doc.get("customer_id"):
+        doc["customer_id"] = f"customer-{uuid4().hex[:12]}"
+    await db[COLLECTION].insert_one(doc)
+    return _serialize(doc)
+
+
+async def update(
+    db: AsyncIOMotorDatabase,
+    customer_id: str,
+    data: CustomerPaymentDataUpdate,
+) -> Optional[dict]:
+    fields = data.model_dump(exclude_unset=True)
+    if not fields:
+        return await get_by_customer_id(db, customer_id)
+    result = await db[COLLECTION].find_one_and_update(
+        {"customer_id": customer_id},
+        {"$set": fields},
+        return_document=ReturnDocument.AFTER,
+    )
+    return _serialize(result)
+
+
+async def delete(db: AsyncIOMotorDatabase, customer_id: str) -> bool:
+    result = await db[COLLECTION].delete_one({"customer_id": customer_id})
+    return result.deleted_count == 1

services/customers/main.py

@@ -0,0 +1,50 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from services.common.logging import configure_service_logging, install_request_logging
+from services.common.tracing import install_route_tracing
+
+from services.common.db import close_db, connect_db
+from services.customers.routers.customer_details import router as customer_details_router
+from services.customers.routers.customer_metadata import router as customer_metadata_router
+from services.customers.routers.customer_order_metrics import router as customer_order_metrics_router
+from services.customers.routers.customer_payment_data import router as customer_payment_data_router
+
+
+logger = configure_service_logging("customers")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await connect_db()
+    yield
+    await close_db()
+
+
+app = FastAPI(
+    title="Customers Service",
+    description="Microservice for customers service.",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+install_request_logging(app, "customers")
+install_route_tracing(app, "customers")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(customer_details_router, prefix="/api/v1/customer-details", tags=["Customer Details"])
+app.include_router(customer_metadata_router, prefix="/api/v1/customer-metadata", tags=["Customer Metadata"])
+app.include_router(customer_order_metrics_router, prefix="/api/v1/customer-order-metrics", tags=["Customer Order Metrics"])
+app.include_router(customer_payment_data_router, prefix="/api/v1/customer-payment-data", tags=["Customer Payment Data"])
+
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    return {"status": "healthy"}

services/customers/models/__init__.py

@@ -0,0 +1,8 @@
+"""customers service models package."""
+
+__all__ = [
+    "customer_details",
+    "customer_metadata",
+    "customer_order_metrics",
+    "customer_payment_data",
+]

services/customers/models/customer_details.py

@@ -0,0 +1,42 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class CustomerDetails(BaseModel):
+    customer_id: Optional[str] = None
+    company_name: Optional[str] = None
+    company_type: Optional[str] = None
+    company_size: Optional[str] = None
+    industry_type: Optional[str] = None
+
+    class Config:
+        str_min_length = 1
+        str_strip_whitespace = True
+
+
+class CustomerDetailsCreate(CustomerDetails):
+    pass
+
+
+class CustomerDetailsUpdate(BaseModel):
+    company_name: Optional[str] = None
+    company_type: Optional[str] = None
+    company_size: Optional[str] = None
+    industry_type: Optional[str] = None
+
+    class Config:
+        str_min_length = 1
+        str_strip_whitespace = True
+
+
+class CustomerDetailsResponse(CustomerDetails):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedCustomerDetailsResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[CustomerDetailsResponse]

services/customers/models/customer_metadata.py

@@ -0,0 +1,97 @@
+from datetime import datetime, timezone
+from typing import Optional
+
+from bson import ObjectId
+from bson.errors import InvalidId
+from fastapi import HTTPException
+from pydantic import BaseModel
+
+
+def datetime_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def object_id_to_str(obj_id):
+    return str(obj_id)
+
+
+def validate_object_id(id: str):
+    try:
+        return ObjectId(id)
+    except InvalidId:
+        raise HTTPException(status_code=400, detail="Invalid ObjectId")
+
+
+class CustomerMetadata(BaseModel):
+    customer_id: Optional[str] = ""
+    account_manager: Optional[str] = ""
+    support_contact: Optional[str] = ""
+    contact_name: Optional[str] = ""
+    job_title: Optional[str] = ""
+    preferred_communication_method: Optional[str] = ""
+    email_address: Optional[str] = ""
+    phone_number: Optional[str] = ""
+    mobile_number: Optional[str] = ""
+    revenue: Optional[str] = ""
+    website: Optional[str] = ""
+    year_founded: Optional[str] = ""
+    customer_since: Optional[str] = ""
+    lead_time: Optional[str] = ""
+    warranty_information: Optional[str] = ""
+    account_status: Optional[str] = ""
+    special_requirements: Optional[str] = ""
+    preferred_shipping_method: Optional[str] = ""
+    region: Optional[str] = ""
+    shipping_contact_name: Optional[str] = ""
+    shipping_contact_number: Optional[str] = ""
+    shipping_address: Optional[str] = ""
+    shipping_city: Optional[str] = ""
+    shipping_state: Optional[str] = ""
+    shipping_zipcode: Optional[str] = ""
+    shipping_country: Optional[str] = ""
+    notes_comments: Optional[str] = ""
+
+
+class CustomerMetadataCreate(CustomerMetadata):
+    pass
+
+
+class CustomerMetadataUpdate(BaseModel):
+    account_manager: Optional[str] = None
+    support_contact: Optional[str] = None
+    contact_name: Optional[str] = None
+    job_title: Optional[str] = None
+    preferred_communication_method: Optional[str] = None
+    email_address: Optional[str] = None
+    phone_number: Optional[str] = None
+    mobile_number: Optional[str] = None
+    revenue: Optional[str] = None
+    website: Optional[str] = None
+    year_founded: Optional[str] = None
+    customer_since: Optional[str] = None
+    lead_time: Optional[str] = None
+    warranty_information: Optional[str] = None
+    account_status: Optional[str] = None
+    special_requirements: Optional[str] = None
+    preferred_shipping_method: Optional[str] = None
+    region: Optional[str] = None
+    shipping_contact_name: Optional[str] = None
+    shipping_contact_number: Optional[str] = None
+    shipping_address: Optional[str] = None
+    shipping_city: Optional[str] = None
+    shipping_state: Optional[str] = None
+    shipping_zipcode: Optional[str] = None
+    shipping_country: Optional[str] = None
+    notes_comments: Optional[str] = None
+
+
+class CustomerMetadataResponse(CustomerMetadata):
+    class Config:
+        from_attributes = True
+
+
+class PaginatedCustomerMetadataResponse(BaseModel):
+    total: int
+    page: int
+    page_size: int
+    results: list[CustomerMetadataResponse]