nikeshn commited on
Commit
4f415fd
Β·
verified Β·
1 Parent(s): ccad7fd

Upload 2 files

Browse files
Files changed (2) hide show
  1. app.py +109 -17
  2. requirements.txt +1 -0
app.py CHANGED
@@ -1,16 +1,29 @@
1
  """LibBee - Main Application Entry Point
2
  Phase 3: production hardening, persistence, metrics, and safer staff routing
 
 
 
 
 
 
 
 
3
  """
 
4
  import logging
5
  import time
6
- from collections import defaultdict, deque
7
  from contextlib import asynccontextmanager
8
- from datetime import datetime
9
 
10
  from fastapi import FastAPI, Request
11
  from fastapi.middleware.cors import CORSMiddleware
12
  from fastapi.responses import JSONResponse
13
 
 
 
 
 
 
 
14
  from src.config import get_settings
15
  from src.services.cache_service import CacheService
16
  from src.services.metrics_service import MetricsService
@@ -22,7 +35,39 @@ logger = logging.getLogger(__name__)
22
  rag_service = RAGService()
23
  cache_service = CacheService()
24
  metrics_service = MetricsService(get_settings().metrics_path)
25
- _request_log: dict[str, deque] = defaultdict(deque)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
26
 
27
 
28
  @asynccontextmanager
@@ -30,23 +75,43 @@ async def lifespan(app: FastAPI):
30
  from src.services.staff_service import build_staff_index
31
 
32
  settings = get_settings()
33
- build_staff_index()
34
- logger.info("Staff index built")
35
 
 
 
 
 
 
 
 
 
36
  if settings.openai_api_key:
37
- await rag_service.initialize(openai_api_key=settings.openai_api_key)
 
 
 
 
38
  else:
39
- logger.warning("OPENAI_API_KEY not set - RAG disabled")
40
 
 
 
41
  logger.info("LibBee startup complete")
 
42
  yield
 
 
 
 
 
 
 
43
  logger.info("LibBee shutting down")
44
 
45
 
46
  app = FastAPI(
47
  title="LibBee - KU Library AI",
48
  description="Khalifa University Library AI Assistant",
49
- version="3.0.0",
50
  lifespan=lifespan,
51
  )
52
 
@@ -68,18 +133,44 @@ app.add_middleware(
68
  @app.middleware("http")
69
  async def operational_guardrails(request: Request, call_next):
70
  settings = get_settings()
 
 
71
  if settings.maintenance_mode and request.url.path not in {"/", "/config"}:
72
- return JSONResponse(status_code=503, content={"detail": "LibBee is in maintenance mode. Please try again shortly."})
 
 
 
73
 
 
74
  client_ip = request.client.host if request.client else "unknown"
75
  now = time.time()
76
- bucket = _request_log[client_ip]
77
- while bucket and now - bucket[0] > 60:
78
- bucket.popleft()
79
- if len(bucket) >= settings.rate_limit_per_minute:
80
- metrics_service.incr_bucket("errors", "rate_limit")
81
- return JSONResponse(status_code=429, content={"detail": "Too many requests. Please slow down and try again."})
82
- bucket.append(now)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
83
 
84
  try:
85
  response = await call_next(request)
@@ -103,7 +194,7 @@ def health_check():
103
  settings = get_settings()
104
  return {
105
  "status": "ok",
106
- "version": "3.0.0",
107
  "service": "LibBee KU Library AI",
108
  "rag_ready": rag_service.is_ready(),
109
  "maintenance_mode": settings.maintenance_mode,
@@ -123,5 +214,6 @@ def public_config():
123
 
124
  @app.get("/year")
125
  def get_year():
 
126
  now = datetime.utcnow()
127
  return {"year": now.year, "month": now.month, "date": now.strftime("%Y-%m-%d")}
 
1
  """LibBee - Main Application Entry Point
2
  Phase 3: production hardening, persistence, metrics, and safer staff routing
3
+
4
+ Fixes applied (v3.1):
5
+ 1. _request_log replaced with cachetools.TTLCache β€” no more unbounded IP dict
6
+ 2. MetricsService background flush task started in lifespan
7
+ 3. Circular import risk reduced β€” rag_service / metrics_service exposed via
8
+ module-level accessors get_rag_service() / get_metrics_service() so routers
9
+ can import the accessor instead of doing a deferred 'from app import ...'
10
+ 4. Startup errors no longer silently swallow RAG init exceptions
11
  """
12
+ import asyncio
13
  import logging
14
  import time
 
15
  from contextlib import asynccontextmanager
 
16
 
17
  from fastapi import FastAPI, Request
18
  from fastapi.middleware.cors import CORSMiddleware
19
  from fastapi.responses import JSONResponse
20
 
21
+ try:
22
+ from cachetools import TTLCache
23
+ _ttl_cache_available = True
24
+ except ImportError:
25
+ _ttl_cache_available = False
26
+
27
  from src.config import get_settings
28
  from src.services.cache_service import CacheService
29
  from src.services.metrics_service import MetricsService
 
35
  rag_service = RAGService()
36
  cache_service = CacheService()
37
  metrics_service = MetricsService(get_settings().metrics_path)
38
+
39
+ # ── Rate-limit request log ─────────────────────────────────────────────────────
40
+ # TTLCache(maxsize, ttl) auto-evicts entries older than ttl seconds.
41
+ # Falls back to a plain dict with manual sweep if cachetools not installed.
42
+ if _ttl_cache_available:
43
+ _request_log = TTLCache(maxsize=10_000, ttl=120)
44
+ _request_log_lock = asyncio.Lock()
45
+ else:
46
+ from collections import defaultdict, deque
47
+ _request_log = defaultdict(deque) # type: ignore[assignment]
48
+ _request_log_lock = asyncio.Lock()
49
+
50
+
51
+ # ── Public accessors (used by routers to avoid circular imports) ───────────────
52
+
53
+ def get_rag_service() -> RAGService:
54
+ return rag_service
55
+
56
+
57
+ def get_metrics_service() -> MetricsService:
58
+ return metrics_service
59
+
60
+
61
+ # ── Background flush task ──────────────────────────────────────────────────────
62
+
63
+ async def _metrics_flush_loop(interval: int = 30) -> None:
64
+ """Flush in-memory metric counters to disk every `interval` seconds."""
65
+ while True:
66
+ await asyncio.sleep(interval)
67
+ try:
68
+ await metrics_service.flush()
69
+ except Exception as exc:
70
+ logger.warning("Metrics flush error: %s", exc)
71
 
72
 
73
  @asynccontextmanager
 
75
  from src.services.staff_service import build_staff_index
76
 
77
  settings = get_settings()
 
 
78
 
79
+ # Build staff index
80
+ try:
81
+ build_staff_index()
82
+ logger.info("Staff index built")
83
+ except Exception as exc:
84
+ logger.error("Staff index build failed: %s", exc)
85
+
86
+ # Initialize RAG
87
  if settings.openai_api_key:
88
+ try:
89
+ await rag_service.initialize(openai_api_key=settings.openai_api_key)
90
+ logger.info("RAG service ready β€” chunks: %d", len(rag_service.bm25_corpus))
91
+ except Exception as exc:
92
+ logger.error("RAG initialization failed: %s", exc, exc_info=True)
93
  else:
94
+ logger.warning("OPENAI_API_KEY not set β€” RAG disabled")
95
 
96
+ # Start background metrics flush
97
+ flush_task = asyncio.create_task(_metrics_flush_loop(interval=30))
98
  logger.info("LibBee startup complete")
99
+
100
  yield
101
+
102
+ # Graceful shutdown β€” flush remaining metrics
103
+ flush_task.cancel()
104
+ try:
105
+ await asyncio.wait_for(metrics_service.flush(), timeout=5.0)
106
+ except Exception:
107
+ pass
108
  logger.info("LibBee shutting down")
109
 
110
 
111
  app = FastAPI(
112
  title="LibBee - KU Library AI",
113
  description="Khalifa University Library AI Assistant",
114
+ version="3.1.0",
115
  lifespan=lifespan,
116
  )
117
 
 
133
  @app.middleware("http")
134
  async def operational_guardrails(request: Request, call_next):
135
  settings = get_settings()
136
+
137
+ # Maintenance mode
138
  if settings.maintenance_mode and request.url.path not in {"/", "/config"}:
139
+ return JSONResponse(
140
+ status_code=503,
141
+ content={"detail": "LibBee is in maintenance mode. Please try again shortly."},
142
+ )
143
 
144
+ # Rate limiting
145
  client_ip = request.client.host if request.client else "unknown"
146
  now = time.time()
147
+
148
+ async with _request_log_lock:
149
+ if _ttl_cache_available:
150
+ # TTLCache stores a list of timestamps per IP
151
+ timestamps = _request_log.get(client_ip, [])
152
+ timestamps = [t for t in timestamps if now - t < 60]
153
+ if len(timestamps) >= settings.rate_limit_per_minute:
154
+ metrics_service.incr_bucket("errors", "rate_limit")
155
+ return JSONResponse(
156
+ status_code=429,
157
+ content={"detail": "Too many requests. Please slow down and try again."},
158
+ )
159
+ timestamps.append(now)
160
+ _request_log[client_ip] = timestamps
161
+ else:
162
+ # Fallback: deque-based sliding window
163
+ from collections import deque
164
+ bucket = _request_log[client_ip] # type: ignore[index]
165
+ while bucket and now - bucket[0] > 60:
166
+ bucket.popleft()
167
+ if len(bucket) >= settings.rate_limit_per_minute:
168
+ metrics_service.incr_bucket("errors", "rate_limit")
169
+ return JSONResponse(
170
+ status_code=429,
171
+ content={"detail": "Too many requests. Please slow down and try again."},
172
+ )
173
+ bucket.append(now)
174
 
175
  try:
176
  response = await call_next(request)
 
194
  settings = get_settings()
195
  return {
196
  "status": "ok",
197
+ "version": "3.1.0",
198
  "service": "LibBee KU Library AI",
199
  "rag_ready": rag_service.is_ready(),
200
  "maintenance_mode": settings.maintenance_mode,
 
214
 
215
  @app.get("/year")
216
  def get_year():
217
+ from datetime import datetime
218
  now = datetime.utcnow()
219
  return {"year": now.year, "month": now.month, "date": now.strftime("%Y-%m-%d")}
requirements.txt CHANGED
@@ -17,3 +17,4 @@ passlib>=1.7.4
17
  python-jose[cryptography]>=3.3.0
18
  numpy>=1.26.0
19
  openai>=1.40.0
 
 
17
  python-jose[cryptography]>=3.3.0
18
  numpy>=1.26.0
19
  openai>=1.40.0
20
+ cachetools>=5.3.0