codecortex 0.3.0__tar.gz → 0.4.0__tar.gz

{codecortex-0.3.0/src/codecortex.egg-info → codecortex-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.3.0
+Version: 0.4.0
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT
@@ -213,6 +213,9 @@ Config is **validated on load** — an out-of-range number, a misspelled enum, o
 | Variable | Effect |
 |---|---|
 | `CODEINTEL_HTTP_TOKEN` | Bearer token required by `serve-http` (equivalent to `--token`) |
+| `CODEINTEL_LOG_LEVEL` | `DEBUG`\|`INFO`\|`WARNING`(default)\|`ERROR` for the server logger |
+| `CODEINTEL_LOG_FORMAT=json` | Structured (JSON-per-line) logs for ELK / Splunk / Datadog |
+| `CODEINTEL_HTTP_ACCESS_LOG=1` | One log line per HTTP request (method, path, status, latency) |
 | `CODEINTEL_DEBUG=1` | Log the full traceback of any error the never-throw contract swallows (silent by default) — the switch for diagnosing an unexpected `null` |
 | `CODEINTEL_REINDEX=off` | Disable the background reindexer; queries then index inline to stay fresh |
 
@@ -273,6 +276,25 @@ if result["result"] is not None:
 
 The response is always JSON-safe. Check `result["result"] is not None` before use. Never catch an exception from the gateway — it never raises.
 
+## Operations & deployment
+
+Running codeintel as a shared service? It ships with what ops teams expect:
+
+| Endpoint | Auth | Purpose |
+|---|---|---|
+| `GET /healthz` | none | Liveness — always `200` (for load balancers / `livenessProbe`) |
+| `GET /readyz` | none | Readiness — `200` once the gateway is up (`readinessProbe`) |
+| `GET /metrics` | token | Prometheus exposition — request counts, latency, in-flight, build info |
+
+Plus **bearer-token auth**, **structured JSON logs** (`CODEINTEL_LOG_FORMAT=json`) with optional per-request access logs, **graceful `SIGTERM`** shutdown, a bounded connection pool, and a non-root **Dockerfile** with a healthcheck.
+
+**Full guide → [docs/deploy.md](docs/deploy.md)**: systemd, Docker / Compose, Kubernetes (liveness + readiness probes, token from a Secret), reverse-proxy TLS, a Prometheus scrape config, and a security checklist.
+
+```bash
+docker build -t codeintel . && docker run -p 127.0.0.1:8766:8766 \
+  -e CODEINTEL_HTTP_TOKEN="$(openssl rand -hex 32)" codeintel
+```
+
 ## Development
 
 ```bash

{codecortex-0.3.0 → codecortex-0.4.0}/README.md

@@ -180,6 +180,9 @@ Config is **validated on load** — an out-of-range number, a misspelled enum, o
 | Variable | Effect |
 |---|---|
 | `CODEINTEL_HTTP_TOKEN` | Bearer token required by `serve-http` (equivalent to `--token`) |
+| `CODEINTEL_LOG_LEVEL` | `DEBUG`\|`INFO`\|`WARNING`(default)\|`ERROR` for the server logger |
+| `CODEINTEL_LOG_FORMAT=json` | Structured (JSON-per-line) logs for ELK / Splunk / Datadog |
+| `CODEINTEL_HTTP_ACCESS_LOG=1` | One log line per HTTP request (method, path, status, latency) |
 | `CODEINTEL_DEBUG=1` | Log the full traceback of any error the never-throw contract swallows (silent by default) — the switch for diagnosing an unexpected `null` |
 | `CODEINTEL_REINDEX=off` | Disable the background reindexer; queries then index inline to stay fresh |
 
@@ -240,6 +243,25 @@ if result["result"] is not None:
 
 The response is always JSON-safe. Check `result["result"] is not None` before use. Never catch an exception from the gateway — it never raises.
 
+## Operations & deployment
+
+Running codeintel as a shared service? It ships with what ops teams expect:
+
+| Endpoint | Auth | Purpose |
+|---|---|---|
+| `GET /healthz` | none | Liveness — always `200` (for load balancers / `livenessProbe`) |
+| `GET /readyz` | none | Readiness — `200` once the gateway is up (`readinessProbe`) |
+| `GET /metrics` | token | Prometheus exposition — request counts, latency, in-flight, build info |
+
+Plus **bearer-token auth**, **structured JSON logs** (`CODEINTEL_LOG_FORMAT=json`) with optional per-request access logs, **graceful `SIGTERM`** shutdown, a bounded connection pool, and a non-root **Dockerfile** with a healthcheck.
+
+**Full guide → [docs/deploy.md](docs/deploy.md)**: systemd, Docker / Compose, Kubernetes (liveness + readiness probes, token from a Secret), reverse-proxy TLS, a Prometheus scrape config, and a security checklist.
+
+```bash
+docker build -t codeintel . && docker run -p 127.0.0.1:8766:8766 \
+  -e CODEINTEL_HTTP_TOKEN="$(openssl rand -hex 32)" codeintel
+```
+
 ## Development
 
 ```bash

{codecortex-0.3.0 → codecortex-0.4.0/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.3.0
+Version: 0.4.0
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT
@@ -213,6 +213,9 @@ Config is **validated on load** — an out-of-range number, a misspelled enum, o
 | Variable | Effect |
 |---|---|
 | `CODEINTEL_HTTP_TOKEN` | Bearer token required by `serve-http` (equivalent to `--token`) |
+| `CODEINTEL_LOG_LEVEL` | `DEBUG`\|`INFO`\|`WARNING`(default)\|`ERROR` for the server logger |
+| `CODEINTEL_LOG_FORMAT=json` | Structured (JSON-per-line) logs for ELK / Splunk / Datadog |
+| `CODEINTEL_HTTP_ACCESS_LOG=1` | One log line per HTTP request (method, path, status, latency) |
 | `CODEINTEL_DEBUG=1` | Log the full traceback of any error the never-throw contract swallows (silent by default) — the switch for diagnosing an unexpected `null` |
 | `CODEINTEL_REINDEX=off` | Disable the background reindexer; queries then index inline to stay fresh |
 
@@ -273,6 +276,25 @@ if result["result"] is not None:
 
 The response is always JSON-safe. Check `result["result"] is not None` before use. Never catch an exception from the gateway — it never raises.
 
+## Operations & deployment
+
+Running codeintel as a shared service? It ships with what ops teams expect:
+
+| Endpoint | Auth | Purpose |
+|---|---|---|
+| `GET /healthz` | none | Liveness — always `200` (for load balancers / `livenessProbe`) |
+| `GET /readyz` | none | Readiness — `200` once the gateway is up (`readinessProbe`) |
+| `GET /metrics` | token | Prometheus exposition — request counts, latency, in-flight, build info |
+
+Plus **bearer-token auth**, **structured JSON logs** (`CODEINTEL_LOG_FORMAT=json`) with optional per-request access logs, **graceful `SIGTERM`** shutdown, a bounded connection pool, and a non-root **Dockerfile** with a healthcheck.
+
+**Full guide → [docs/deploy.md](docs/deploy.md)**: systemd, Docker / Compose, Kubernetes (liveness + readiness probes, token from a Secret), reverse-proxy TLS, a Prometheus scrape config, and a security checklist.
+
+```bash
+docker build -t codeintel . && docker run -p 127.0.0.1:8766:8766 \
+  -e CODEINTEL_HTTP_TOKEN="$(openssl rand -hex 32)" codeintel
+```
+
 ## Development
 
 ```bash

{codecortex-0.3.0 → codecortex-0.4.0}/src/codecortex.egg-info/SOURCES.txt

@@ -17,7 +17,9 @@ src/codeintel/http_server.py
 src/codeintel/indexer.py
 src/codeintel/injector.py
 src/codeintel/installer.py
+src/codeintel/logconfig.py
 src/codeintel/mapper.py
+src/codeintel/metrics.py
 src/codeintel/onboarding.py
 src/codeintel/policy.py
 src/codeintel/provider.py
@@ -36,6 +38,7 @@ tests/test_cache.py
 tests/test_config.py
 tests/test_doctor.py
 tests/test_e2e.py
+tests/test_enterprise.py
 tests/test_gateway.py
 tests/test_graph_provider.py
 tests/test_graph_real.py

codecortex-0.4.0/src/codeintel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0"

{codecortex-0.3.0 → codecortex-0.4.0}/src/codeintel/http_server.py

@@ -2,17 +2,29 @@ from __future__ import annotations
 
 import hmac
 import json
+import logging
+import os
+import signal
 import sys
 import threading
+import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from urllib.parse import parse_qs, urlparse
 
+from codeintel import __version__
+from codeintel.logconfig import configure_logging
+from codeintel.metrics import Metrics
 from codeintel.provider import log_swallowed
 from codeintel.server import code_doctor_handler, code_query_handler, code_status_handler
 
 _MAX_BODY_BYTES = 1_048_576       # 1 MiB
 _REQUEST_TIMEOUT_S = 60           # per-request socket read timeout — drops an idle/half-open client
 _MAX_CONCURRENT_REQUESTS = 64     # cap live worker threads so a burst can't exhaust threads/FDs
+_DRAIN_TIMEOUT_S = 15             # on shutdown, wait up to this long for in-flight requests to finish
+_ACCESS_LOG = os.environ.get("CODEINTEL_HTTP_ACCESS_LOG", "").strip().lower() in ("1", "true", "on", "yes")
+_PROM_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8"
+
+_logger = logging.getLogger("codeintel")
 
 
 class _Handler(BaseHTTPRequestHandler):
@@ -21,7 +33,35 @@ class _Handler(BaseHTTPRequestHandler):
     timeout = _REQUEST_TIMEOUT_S
 
     def log_message(self, format: str, *args: object) -> None:
-        pass  # suppress default stderr noise
+        pass  # suppress default stderr noise; opt-in access logging is handled in _observe
+
+    def handle_one_request(self) -> None:
+        self._t0 = time.monotonic()
+        m = getattr(self.server, "metrics", None)
+        if m is not None:
+            m.inc_in_flight()
+        try:
+            super().handle_one_request()
+        finally:
+            if m is not None:
+                m.dec_in_flight()
+
+    def _observe(self, status: int) -> None:
+        try:
+            dur = time.monotonic() - getattr(self, "_t0", time.monotonic())
+        except Exception:
+            dur = 0.0
+        m = getattr(self.server, "metrics", None)
+        if m is not None:
+            try:
+                m.record(self.command or "?", urlparse(self.path).path, status, dur)
+            except Exception:
+                pass
+        if _ACCESS_LOG:
+            try:
+                _logger.info("%s %s -> %s (%.1fms)", self.command, self.path, status, dur * 1000.0)
+            except Exception:
+                pass
 
     def _send_json(self, status: int, data: dict) -> None:
         body = json.dumps(data).encode()
@@ -30,6 +70,16 @@ class _Handler(BaseHTTPRequestHandler):
         self.send_header("Content-Length", str(len(body)))
         self.end_headers()
         self.wfile.write(body)
+        self._observe(status)
+
+    def _send_text(self, status: int, text: str, content_type: str) -> None:
+        body = text.encode()
+        self.send_response(status)
+        self.send_header("Content-Type", content_type)
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+        self._observe(status)
 
     def _authorized(self) -> bool:
         """When the server was started with a token, require ``Authorization: Bearer <token>``
@@ -79,17 +129,44 @@ class _Handler(BaseHTTPRequestHandler):
         self._send_json(200, result)
 
     def do_GET(self) -> None:
+        parsed = urlparse(self.path)
+        path = parsed.path
+
+        # Liveness / readiness are UNAUTHENTICATED by convention (kubelet/load balancers don't send
+        # tokens) and reveal nothing sensitive — only up/ready.
+        if path == "/healthz":
+            self._send_json(200, {"status": "ok"})
+            return
+        if path == "/readyz":
+            try:
+                from codeintel.server import _get_gateway
+                _get_gateway()  # builds once (cached); readiness = the gateway is constructible
+                self._send_json(200, {"status": "ready"})
+            except Exception as exc:
+                log_swallowed("readyz", exc)
+                self._send_json(503, {"status": "not-ready"})
+            return
+
+        # Everything else is auth-gated when a token is configured (metrics can reveal usage
+        # patterns; status reveals engine/index state).
         if not self._authorized():
             self._send_json(401, {"error": "unauthorized"})
             return
-        parsed = urlparse(self.path)
-        if parsed.path != "/code/status":
-            self._send_json(404, {"error": "not-found"})
+
+        if path == "/metrics":
+            m = getattr(self.server, "metrics", None)
+            try:
+                text = m.render() if m is not None else ""
+            except Exception as exc:
+                log_swallowed("metrics.render", exc)  # never leave the client with no response
+                text = ""
+            self._send_text(200, text, _PROM_CONTENT_TYPE)
             return
-        # Optional ?project_root=... scopes the `indexed` flag to that repo.
-        project_root = (parse_qs(parsed.query).get("project_root") or [""])[0]
-        result = code_status_handler({"project_root": project_root})
-        self._send_json(200, result)
+        if path == "/code/status":
+            project_root = (parse_qs(parsed.query).get("project_root") or [""])[0]
+            self._send_json(200, code_status_handler({"project_root": project_root}))
+            return
+        self._send_json(404, {"error": "not-found"})
 
 
 class CodeIntelHTTPServer(ThreadingHTTPServer):
@@ -102,6 +179,7 @@ class CodeIntelHTTPServer(ThreadingHTTPServer):
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
+        self.metrics = Metrics(version=__version__)
         # Stdlib ThreadingHTTPServer spawns one thread per connection with no ceiling, so many
         # slow/half-open clients could exhaust threads/FDs. Bound live workers; past the cap we
         # refuse fast with 503 rather than spawn an unbounded thread. (For a genuinely hostile
@@ -110,6 +188,10 @@ class CodeIntelHTTPServer(ThreadingHTTPServer):
 
     def process_request(self, request, client_address) -> None:
         if not self._slots.acquire(blocking=False):
+            try:
+                self.metrics.inc_overload()  # surface overload in /metrics (rejected_total)
+            except Exception:
+                pass
             try:
                 request.sendall(
                     b"HTTP/1.1 503 Service Unavailable\r\n"
@@ -152,6 +234,10 @@ def _is_loopback(host: str) -> bool:
         return False  # a non-IP hostname is never treated as loopback
 
 
+def _no_auth_override() -> bool:
+    return os.environ.get("CODEINTEL_ALLOW_NO_AUTH", "").strip().lower() in ("1", "true", "on", "yes")
+
+
 def run(
     host: str = "127.0.0.1",
     port: int = 8766,
@@ -159,17 +245,50 @@ def run(
     allow_remote: bool = False,
     token: str | None = None,
 ) -> None:
-    if not _is_loopback(host) and not allow_remote:
-        print(f"refusing to bind non-loopback host {host!r} without --allow-remote — this would "
-              f"expose an UNAUTHENTICATED code-intel endpoint (your indexed repo) to the network",
-              file=sys.stderr)
-        raise SystemExit(2)
+    configure_logging()
+    server_token = (token or "").strip() or None
+    if not _is_loopback(host):
+        if not allow_remote:
+            print(f"refusing to bind non-loopback host {host!r} without --allow-remote — this would "
+                  f"expose a code-intel endpoint (your indexed repo) to the network", file=sys.stderr)
+            raise SystemExit(2)
+        if not server_token and not _no_auth_override():
+            # Fail closed: never serve an UNAUTHENTICATED endpoint on the network by accident (a
+            # containerized `serve-http --host 0.0.0.0` with no token stops here unless overridden).
+            print(f"refusing to serve on {host}:{port} with NO authentication — set --token or "
+                  f"CODEINTEL_HTTP_TOKEN (recommended), or set CODEINTEL_ALLOW_NO_AUTH=1 to override "
+                  f"for a trusted network", file=sys.stderr)
+            raise SystemExit(2)
+
     server = CodeIntelHTTPServer((host, port), _Handler)
-    server.auth_token = (token or "").strip() or None
-    if not _is_loopback(host) and not server.auth_token:
-        print(f"WARNING: serving codeintel on {host}:{port} with NO authentication — anyone who can "
-              f"reach this port can read your indexed repo (set --token to require a bearer token)",
-              file=sys.stderr)
-    auth_note = "  (bearer-token auth required)" if server.auth_token else ""
+    server.auth_token = server_token
+    if not _is_loopback(host) and not server_token:
+        print(f"WARNING: serving codeintel on {host}:{port} with NO authentication "
+              f"(CODEINTEL_ALLOW_NO_AUTH set) — anyone who can reach this port can read your "
+              f"indexed repo", file=sys.stderr)
+    auth_note = "  (bearer-token auth required)" if server_token else ""
     print(f"Listening on http://{host}:{port}{auth_note}")
-    server.serve_forever()
+
+    def _graceful(signum, frame) -> None:
+        # shutdown() blocks until serve_forever() returns, so it must run OFF the serving thread —
+        # spawn a helper thread to avoid deadlocking the signal handler on the main thread.
+        threading.Thread(target=server.shutdown, daemon=True).start()
+
+    try:
+        signal.signal(signal.SIGTERM, _graceful)
+        signal.signal(signal.SIGINT, _graceful)
+    except (ValueError, OSError):
+        pass  # not the main thread — signal handlers unavailable; rely on the caller to stop us
+
+    try:
+        server.serve_forever()
+    finally:
+        # Drain: serve_forever() has stopped accepting new connections; wait (bounded) for in-flight
+        # requests to finish before closing. Worker threads are daemons, so server_close() will NOT
+        # join them — this loop is what makes the shutdown actually graceful (a rolling restart
+        # doesn't cut a live response mid-flight).
+        deadline = time.monotonic() + _DRAIN_TIMEOUT_S
+        while server.metrics.in_flight() > 0 and time.monotonic() < deadline:
+            time.sleep(0.05)
+        server.server_close()
+        print("codeintel http server stopped", file=sys.stderr)

codecortex-0.4.0/src/codeintel/logconfig.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+
+
+class _JsonFormatter(logging.Formatter):
+    """Minimal structured formatter for log aggregators (ELK / Splunk / Datadog). One JSON object
+    per line; no external dependency."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        payload = {
+            "ts": self.formatTime(record, "%Y-%m-%dT%H:%M:%S%z"),
+            "level": record.levelname,
+            "logger": record.name,
+            "msg": record.getMessage(),
+        }
+        if record.exc_info:
+            payload["exc"] = self.formatException(record.exc_info)
+        return json.dumps(payload, ensure_ascii=False)
+
+
+_configured = False
+
+
+def configure_logging() -> None:
+    """Configure the ``codeintel`` logger for a long-running server process. Idempotent, and
+    scoped to the ``codeintel`` logger only — importing codeintel as a library never hijacks the
+    root logger. Honors:
+
+      * ``CODEINTEL_LOG_LEVEL``  (default ``WARNING``) — DEBUG | INFO | WARNING | ERROR
+      * ``CODEINTEL_LOG_FORMAT`` (default plain)       — set to ``json`` for structured output
+    """
+    global _configured
+    if _configured:
+        return
+    level_name = os.environ.get("CODEINTEL_LOG_LEVEL", "WARNING").strip().upper()
+    level = getattr(logging, level_name, logging.WARNING)
+    if not isinstance(level, int):
+        level = logging.WARNING
+
+    handler = logging.StreamHandler(sys.stderr)
+    if os.environ.get("CODEINTEL_LOG_FORMAT", "").strip().lower() == "json":
+        handler.setFormatter(_JsonFormatter())
+    else:
+        handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))
+
+    logger = logging.getLogger("codeintel")
+    logger.setLevel(level)
+    logger.handlers[:] = [handler]
+    logger.propagate = False
+    _configured = True

codecortex-0.4.0/src/codeintel/metrics.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import threading
+from typing import Dict, Tuple
+
+# Path labels are restricted to known routes so a caller cannot explode Prometheus label
+# cardinality (a memory-exhaustion vector) by hammering random URLs — everything else folds
+# into path="other". Method and status are already low-cardinality; version is our own string.
+_KNOWN_PATHS = frozenset(
+    {"/code/query", "/code/doctor", "/code/status", "/healthz", "/readyz", "/metrics"}
+)
+
+
+class Metrics:
+    """Thread-safe, dependency-free request metrics rendered in Prometheus text exposition
+    format. Shared across the threaded HTTP server's worker threads via one instance on the
+    server object; every mutation is lock-guarded."""
+
+    def __init__(self, version: str = "") -> None:
+        self._lock = threading.Lock()
+        self._version = version
+        self._count: Dict[Tuple[str, str, int], int] = {}  # (method, path, status) -> n
+        self._lat_sum: Dict[str, float] = {}               # path -> total seconds
+        self._lat_count: Dict[str, int] = {}               # path -> n
+        self._in_flight = 0
+        self._overload = 0                                 # requests refused at the concurrency cap
+
+    @staticmethod
+    def _norm(path: str) -> str:
+        return path if path in _KNOWN_PATHS else "other"
+
+    def inc_in_flight(self) -> None:
+        with self._lock:
+            self._in_flight += 1
+
+    def dec_in_flight(self) -> None:
+        with self._lock:
+            self._in_flight = max(0, self._in_flight - 1)
+
+    def in_flight(self) -> int:
+        with self._lock:
+            return self._in_flight
+
+    def inc_overload(self) -> None:
+        with self._lock:
+            self._overload += 1
+
+    def record(self, method: str, path: str, status: int, duration_s: float) -> None:
+        p = self._norm(str(path))
+        key = (str(method or "?"), p, int(status))
+        with self._lock:
+            self._count[key] = self._count.get(key, 0) + 1
+            self._lat_sum[p] = self._lat_sum.get(p, 0.0) + max(0.0, float(duration_s))
+            self._lat_count[p] = self._lat_count.get(p, 0) + 1
+
+    def render(self) -> str:
+        with self._lock:
+            count = dict(self._count)
+            lat_sum = dict(self._lat_sum)
+            lat_count = dict(self._lat_count)
+            in_flight = self._in_flight
+            overload = self._overload
+            version = self._version
+
+        out: list[str] = []
+        out.append("# HELP codeintel_requests_total Total HTTP requests handled.")
+        out.append("# TYPE codeintel_requests_total counter")
+        for (method, path, status), n in sorted(count.items()):
+            out.append(
+                f'codeintel_requests_total{{method="{method}",path="{path}",status="{status}"}} {n}'
+            )
+        out.append("# HELP codeintel_request_duration_seconds Request handling duration.")
+        out.append("# TYPE codeintel_request_duration_seconds summary")
+        for path in sorted(lat_count):
+            out.append(f'codeintel_request_duration_seconds_sum{{path="{path}"}} {lat_sum[path]:.6f}')
+            out.append(f'codeintel_request_duration_seconds_count{{path="{path}"}} {lat_count[path]}')
+        out.append("# HELP codeintel_requests_in_flight Requests currently being handled.")
+        out.append("# TYPE codeintel_requests_in_flight gauge")
+        out.append(f"codeintel_requests_in_flight {in_flight}")
+        out.append("# HELP codeintel_requests_rejected_total Requests refused at the concurrency cap.")
+        out.append("# TYPE codeintel_requests_rejected_total counter")
+        out.append(f"codeintel_requests_rejected_total {overload}")
+        if version:
+            out.append("# HELP codeintel_build_info Build metadata (constant 1).")
+            out.append("# TYPE codeintel_build_info gauge")
+            out.append(f'codeintel_build_info{{version="{version}"}} 1')
+        return "\n".join(out) + "\n"

{codecortex-0.3.0 → codecortex-0.4.0}/src/codeintel/server.py

@@ -192,6 +192,8 @@ def code_map_handler(args: dict) -> dict:
 
 
 def run() -> None:
+    from codeintel.logconfig import configure_logging
+    configure_logging()  # logs to stderr; stdout is the MCP protocol channel
     mcp = MCPServer(name="codeintel")
 
     async def _code_query(

codecortex-0.4.0/tests/test_enterprise.py

@@ -0,0 +1,145 @@
+"""Enterprise surface (0.4.0): health/readiness probes, Prometheus /metrics, and the metrics
+registry. Real live server on an ephemeral port; no mocks."""
+from __future__ import annotations
+
+import http.client
+import json
+import threading
+
+from codeintel.http_server import CodeIntelHTTPServer, _Handler
+from codeintel.metrics import Metrics
+
+
+def _serve(token=None):
+    s = CodeIntelHTTPServer(("127.0.0.1", 0), _Handler)
+    s.auth_token = token
+    threading.Thread(target=s.serve_forever, daemon=True).start()
+    return s, s.server_address[1]
+
+
+def _get(port, path, headers=None):
+    c = http.client.HTTPConnection("127.0.0.1", port, timeout=5)
+    c.request("GET", path, headers=headers or {})
+    r = c.getresponse()
+    body = r.read().decode()
+    c.close()
+    return r.status, body
+
+
+# --------------------------------------------------------------------------- probes
+
+def test_healthz_ok_and_unauthenticated_even_with_token():
+    s, port = _serve(token="secret")   # health must not require the token (kubelet won't send one)
+    try:
+        status, body = _get(port, "/healthz")
+        assert status == 200 and json.loads(body)["status"] == "ok"
+    finally:
+        s.shutdown()
+
+
+def test_readyz_reports_ready():
+    s, port = _serve()
+    try:
+        status, body = _get(port, "/readyz")
+        assert status == 200 and json.loads(body)["status"] == "ready"
+    finally:
+        s.shutdown()
+
+
+def test_readyz_unauthenticated_even_with_token():
+    s, port = _serve(token="secret")
+    try:
+        assert _get(port, "/readyz")[0] == 200
+    finally:
+        s.shutdown()
+
+
+# --------------------------------------------------------------------------- /metrics endpoint
+
+def test_metrics_exposition_format():
+    s, port = _serve()
+    try:
+        _get(port, "/healthz")            # generate a recorded request first
+        status, body = _get(port, "/metrics")
+        assert status == 200
+        assert "# TYPE codeintel_requests_total counter" in body
+        assert "codeintel_build_info" in body
+        assert 'path="/healthz"' in body  # the earlier request was counted
+    finally:
+        s.shutdown()
+
+
+def test_metrics_is_auth_gated_when_token_set():
+    s, port = _serve(token="secret")
+    try:
+        assert _get(port, "/metrics")[0] == 401
+        assert _get(port, "/metrics", {"Authorization": "Bearer secret"})[0] == 200
+    finally:
+        s.shutdown()
+
+
+# --------------------------------------------------------------------------- metrics registry
+
+def test_metrics_registry_counts_and_caps_cardinality():
+    m = Metrics(version="9.9.9")
+    m.record("POST", "/code/query", 200, 0.05)
+    m.record("POST", "/code/query", 200, 0.05)
+    m.record("GET", "/some/random/unknown/path", 404, 0.01)  # unknown → folded to path="other"
+    out = m.render()
+    assert 'codeintel_requests_total{method="POST",path="/code/query",status="200"} 2' in out
+    assert 'path="other"' in out
+    assert "/some/random/unknown/path" not in out            # no unbounded label cardinality
+    assert 'codeintel_build_info{version="9.9.9"} 1' in out
+    assert "codeintel_request_duration_seconds_count" in out
+
+
+def test_metrics_in_flight_gauge_never_negative():
+    m = Metrics()
+    m.dec_in_flight()  # underflow guard
+    assert "codeintel_requests_in_flight 0" in m.render()
+
+
+def test_metrics_exposes_rejected_and_in_flight():
+    m = Metrics()
+    m.inc_overload()
+    m.inc_overload()
+    m.inc_in_flight()
+    out = m.render()
+    assert "codeintel_requests_rejected_total 2" in out  # capacity refusals are now visible
+    assert "codeintel_requests_in_flight 1" in out
+    assert m.in_flight() == 1                             # accessor used by the shutdown drain
+
+
+# --------------------------------------------------------------------------- secure-by-default bind
+
+def test_run_refuses_non_loopback_without_auth(monkeypatch):
+    import pytest
+
+    from codeintel.http_server import run
+    monkeypatch.delenv("CODEINTEL_ALLOW_NO_AUTH", raising=False)
+    # non-loopback + --allow-remote but NO token and no override → must fail closed, not bind.
+    with pytest.raises(SystemExit):
+        run(host="0.0.0.0", port=0, allow_remote=True, token=None)
+
+
+def test_run_refuses_non_loopback_without_allow_remote():
+    import pytest
+
+    from codeintel.http_server import run
+    with pytest.raises(SystemExit):
+        run(host="0.0.0.0", port=0, allow_remote=False, token="tok")
+
+
+# --------------------------------------------------------------------------- structured logging
+
+def test_json_log_formatter_emits_valid_json():
+    import json
+    import logging
+
+    from codeintel.logconfig import _JsonFormatter
+
+    rec = logging.LogRecord("codeintel", logging.WARNING, __file__, 1, "hello %s", ("world",), None)
+    parsed = json.loads(_JsonFormatter().format(rec))
+    assert parsed["level"] == "WARNING"
+    assert parsed["msg"] == "hello world"
+    assert parsed["logger"] == "codeintel"

codecortex-0.3.0/src/codeintel/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.0"