feast 0.67.0.dev100__tar.gz → 0.67.0.dev101__tar.gz

{feast-0.67.0.dev100 → feast-0.67.0.dev101}/.secrets.baseline

@@ -1501,14 +1501,14 @@
         "filename": "sdk/python/tests/universal/feature_repos/universal/data_sources/file.py",
         "hashed_secret": "d70eab08607a4d05faa2d0d6647206599e9abc65",
         "is_verified": false,
-        "line_number": 257
+        "line_number": 259
       },
       {
         "type": "Secret Keyword",
         "filename": "sdk/python/tests/universal/feature_repos/universal/data_sources/file.py",
         "hashed_secret": "d70eab08607a4d05faa2d0d6647206599e9abc65",
         "is_verified": false,
-        "line_number": 257
+        "line_number": 259
       }
     ],
     "sdk/python/tests/universal/feature_repos/universal/online_store/couchbase.py": [
@@ -1564,5 +1564,5 @@
       }
     ]
   },
-  "generated_at": "2026-08-20T15:20:58Z"
+  "generated_at": "2026-09-15T09:12:05Z"
 }

{feast-0.67.0.dev100 → feast-0.67.0.dev101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: feast
-Version: 0.67.0.dev100
+Version: 0.67.0.dev101
 Summary: Python SDK for Feast
 Author: Feast
 License-Expression: Apache-2.0

feast-0.67.0.dev101/sdk/python/feast/audit/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2025 The Feast Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

feast-0.67.0.dev101/sdk/python/feast/audit/audit_logger.py

@@ -0,0 +1,381 @@
+# Copyright 2025 The Feast Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Structured audit logging for the Feast feature server.
+
+Emits JSONL audit events for MCP tool calls, REST requests, and
+authentication/authorization decisions. Sensitive payloads (tokens,
+entity rows, feature values) are never included.
+"""
+
+import abc
+import contextvars
+import logging
+import sys
+import threading
+import uuid
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    from feast.infra.feature_servers.base_config import AuditLoggingConfig
+
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+# ContextVar used by the MCP audit wrapper to propagate a single request_id
+# into the internal REST call so that ``mcp.tools.call`` and
+# ``http.request`` events share the same identifier in SIEM.
+mcp_audit_request_id: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+    "mcp_audit_request_id", default=None
+)
+
+
+# ---------------------------------------------------------------------------
+# Audit event schema
+# ---------------------------------------------------------------------------
+
+
+class AuditPrincipal(BaseModel):
+    username: str = ""
+    roles: List[str] = Field(default_factory=list)
+    auth_type: str = ""
+
+
+class AuditSource(BaseModel):
+    ip: str = ""
+    transport: str = ""
+
+
+class AuditAction(BaseModel):
+    mcp_tool: str = ""
+    path: str = ""
+
+
+class AuditResource(BaseModel):
+    type: str = ""
+    name: str = ""
+    actions: List[str] = Field(default_factory=list)
+
+
+class AuditEvent(BaseModel):
+    """A single structured audit log entry.
+
+    Fields follow the schema proposed in feast-dev/feast#6452.
+    No sensitive payloads (tokens, entity rows, feature values) are stored.
+    When OpenTelemetry is active, ``trace_id`` and ``span_id`` are populated
+    automatically for correlation with distributed traces.
+    """
+
+    event_type: str
+    timestamp: str = ""
+    request_id: str = ""
+    trace_id: Optional[str] = None
+    span_id: Optional[str] = None
+    jsonrpc_id: Optional[str] = None
+    principal: AuditPrincipal = Field(default_factory=AuditPrincipal)
+    source: AuditSource = Field(default_factory=AuditSource)
+    action: AuditAction = Field(default_factory=AuditAction)
+    resource: AuditResource = Field(default_factory=AuditResource)
+    outcome: str = ""
+    duration_ms: Optional[float] = None
+    detail: str = ""
+
+    def to_jsonl(self) -> str:
+        return self.model_dump_json(exclude_none=True)
+
+
+# ---------------------------------------------------------------------------
+# Sink abstraction
+# ---------------------------------------------------------------------------
+
+
+class AuditSink(abc.ABC):
+    """Base class for audit event sinks."""
+
+    @abc.abstractmethod
+    def emit(self, event: AuditEvent) -> None: ...
+
+    def close(self) -> None:
+        pass
+
+
+class StdoutAuditSink(AuditSink):
+    """Write JSONL events to stdout (the default)."""
+
+    def emit(self, event: AuditEvent) -> None:
+        sys.stdout.write(event.to_jsonl() + "\n")
+        sys.stdout.flush()
+
+
+class FileAuditSink(AuditSink):
+    """Append JSONL events to a local file."""
+
+    def __init__(self, file_path: str) -> None:
+        self._file_path = file_path
+        self._fh = open(file_path, "a", buffering=1)
+
+    def emit(self, event: AuditEvent) -> None:
+        self._fh.write(event.to_jsonl() + "\n")
+
+    def close(self) -> None:
+        self._fh.close()
+
+
+class LoggerAuditSink(AuditSink):
+    """Emit audit events through Python's ``logging`` module at INFO level."""
+
+    def __init__(self, logger_name: str = "feast.audit") -> None:
+        self._logger = logging.getLogger(logger_name)
+
+    def emit(self, event: AuditEvent) -> None:
+        self._logger.info(event.to_jsonl())
+
+
+# ---------------------------------------------------------------------------
+# AuditLogger — the main entry point
+# ---------------------------------------------------------------------------
+
+
+class AuditLogger:
+    """Central audit logger that routes events to the configured sink.
+
+    Instantiate once during feature-server startup and share via
+    ``app.state.audit_logger``.
+    """
+
+    def __init__(
+        self,
+        sink: AuditSink,
+        *,
+        log_successful_reads: bool = True,
+    ) -> None:
+        self._sink = sink
+        self._log_successful_reads = log_successful_reads
+        self._lock = threading.Lock()
+
+    # -- helpers -----------------------------------------------------------
+
+    @staticmethod
+    def new_request_id() -> str:
+        return str(uuid.uuid4())
+
+    @staticmethod
+    def _utcnow_iso() -> str:
+        return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+    @staticmethod
+    def _inject_otel_context(event: AuditEvent) -> None:
+        """Populate trace_id/span_id from the active OpenTelemetry span, if any."""
+        if event.trace_id is not None:
+            return
+        try:
+            from opentelemetry import trace as otel_trace
+
+            span = otel_trace.get_current_span()
+            ctx = span.get_span_context()
+            if ctx and ctx.is_valid:
+                event.trace_id = format(ctx.trace_id, "032x")
+                event.span_id = format(ctx.span_id, "016x")
+        except ImportError:
+            pass
+        except Exception:
+            pass
+
+    # MCP tool names and REST paths that correspond to read operations.
+    _READ_TOOL_NAMES = frozenset(
+        {
+            "get_online_features",
+            "retrieve_online_documents",
+            "get_historical_features",
+        }
+    )
+    _READ_ACTIONS = frozenset({"READ_ONLINE", "READ_OFFLINE"})
+
+    @classmethod
+    def _is_read_event(cls, event: AuditEvent) -> bool:
+        """Return ``True`` when *event* represents a successful read.
+
+        Checks both ``resource.actions`` (populated by REST middleware) and
+        ``action.mcp_tool`` (populated by the MCP handler wrapper) so that
+        suppression via ``log_successful_reads=False`` works for both layers.
+        """
+        if event.event_type not in {"mcp.tools.call", "http.request"}:
+            return False
+        resource_actions = set(event.resource.actions)
+        if resource_actions and resource_actions.issubset(cls._READ_ACTIONS):
+            return True
+        if event.action.mcp_tool in cls._READ_TOOL_NAMES:
+            return True
+        return False
+
+    # -- public API --------------------------------------------------------
+
+    def log(self, event: AuditEvent) -> None:
+        if not event.timestamp:
+            event.timestamp = self._utcnow_iso()
+        if not event.request_id:
+            event.request_id = self.new_request_id()
+
+        self._inject_otel_context(event)
+
+        if event.outcome == "success" and not self._log_successful_reads:
+            if self._is_read_event(event):
+                return
+
+        try:
+            with self._lock:
+                self._sink.emit(event)
+        except Exception:
+            logger.exception("Failed to emit audit event")
+
+    def log_mcp_call(
+        self,
+        *,
+        request_id: str,
+        tool_name: str,
+        path: str = "",
+        principal: Optional[AuditPrincipal] = None,
+        source: Optional[AuditSource] = None,
+        resource: Optional[AuditResource] = None,
+        outcome: str = "success",
+        duration_ms: Optional[float] = None,
+        detail: str = "",
+    ) -> None:
+        self.log(
+            AuditEvent(
+                event_type="mcp.tools.call",
+                request_id=request_id,
+                principal=principal or AuditPrincipal(),
+                source=source or AuditSource(transport="mcp-http"),
+                action=AuditAction(mcp_tool=tool_name, path=path),
+                resource=resource or AuditResource(),
+                outcome=outcome,
+                duration_ms=duration_ms,
+                detail=detail,
+            )
+        )
+
+    def log_http_request(
+        self,
+        *,
+        request_id: str,
+        method: str,
+        path: str,
+        principal: Optional[AuditPrincipal] = None,
+        source: Optional[AuditSource] = None,
+        resource: Optional[AuditResource] = None,
+        outcome: str = "success",
+        duration_ms: Optional[float] = None,
+        status_code: int = 200,
+    ) -> None:
+        self.log(
+            AuditEvent(
+                event_type="http.request",
+                request_id=request_id,
+                principal=principal or AuditPrincipal(),
+                source=source or AuditSource(transport="http"),
+                action=AuditAction(path=path),
+                resource=resource or AuditResource(),
+                outcome=outcome,
+                duration_ms=duration_ms,
+                detail=f"{method} {path} -> {status_code}",
+            )
+        )
+
+    def log_authn(
+        self,
+        *,
+        request_id: str,
+        outcome: str,
+        principal: Optional[AuditPrincipal] = None,
+        source: Optional[AuditSource] = None,
+        detail: str = "",
+    ) -> None:
+        event_type = "authn.success" if outcome == "success" else "authn.failure"
+        self.log(
+            AuditEvent(
+                event_type=event_type,
+                request_id=request_id,
+                principal=principal or AuditPrincipal(),
+                source=source or AuditSource(),
+                outcome=outcome,
+                detail=detail,
+            )
+        )
+
+    def log_authz(
+        self,
+        *,
+        request_id: str,
+        outcome: str,
+        principal: Optional[AuditPrincipal] = None,
+        resource: Optional[AuditResource] = None,
+        detail: str = "",
+    ) -> None:
+        self.log(
+            AuditEvent(
+                event_type="authz.decision",
+                request_id=request_id,
+                principal=principal or AuditPrincipal(),
+                resource=resource or AuditResource(),
+                outcome=outcome,
+                detail=detail,
+            )
+        )
+
+    def close(self) -> None:
+        self._sink.close()
+
+
+# ---------------------------------------------------------------------------
+# Factory
+# ---------------------------------------------------------------------------
+
+_SINK_FACTORIES = {
+    "stdout": lambda cfg: StdoutAuditSink(),
+    "file": lambda cfg: FileAuditSink(cfg.get("file_path", "feast_audit.log")),
+    "logger": lambda cfg: LoggerAuditSink(cfg.get("logger_name", "feast.audit")),
+}
+
+
+def create_audit_logger_from_config(
+    audit_cfg: Optional["AuditLoggingConfig"],
+) -> Optional[AuditLogger]:
+    """Build an ``AuditLogger`` from an ``AuditLoggingConfig`` pydantic model.
+
+    Returns ``None`` when audit logging is disabled.
+    """
+    if audit_cfg is None or not getattr(audit_cfg, "enabled", False):
+        return None
+
+    sink_type = getattr(audit_cfg, "sink", "stdout")
+    raw: Dict[str, Any] = {}
+    if hasattr(audit_cfg, "file_path"):
+        raw["file_path"] = audit_cfg.file_path
+    if hasattr(audit_cfg, "logger_name"):
+        raw["logger_name"] = audit_cfg.logger_name
+
+    factory = _SINK_FACTORIES.get(sink_type)
+    if factory is None:
+        logger.warning("Unknown audit sink %r, falling back to stdout", sink_type)
+        factory = _SINK_FACTORIES["stdout"]
+
+    sink = factory(raw)
+    return AuditLogger(
+        sink,
+        log_successful_reads=getattr(audit_cfg, "log_successful_reads", True),
+    )

feast-0.67.0.dev101/sdk/python/feast/audit/audit_middleware.py

@@ -0,0 +1,144 @@
+# Copyright 2025 The Feast Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+FastAPI middleware for structured audit logging of REST endpoints.
+
+``AuditLoggingMiddleware`` logs every HTTP request/response on the REST
+endpoints (``/get-online-features``, ``/push``, etc.) with principal,
+resource, outcome, and duration.
+
+MCP tool-call auditing is handled at the protocol layer by wrapping
+the ``tools/call`` handler inside ``add_mcp_support_to_app()`` (see
+``feast.infra.mcp_servers.mcp_server``).
+
+The middleware is added only when ``audit_logging.enabled`` is ``true``
+in the feature-server configuration.
+"""
+
+import logging
+import time
+from typing import Optional
+
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response
+
+from feast.audit.audit_logger import (
+    AuditLogger,
+    AuditPrincipal,
+    AuditResource,
+    AuditSource,
+    mcp_audit_request_id,
+)
+
+logger = logging.getLogger(__name__)
+
+# REST paths that correspond to read/write actions
+_PATH_RESOURCE_MAP = {
+    "/get-online-features": ("feature_service", ["READ_ONLINE"]),
+    "/retrieve-online-documents": ("feature_service", ["READ_ONLINE"]),
+    "/push": ("push_source", ["WRITE_ONLINE", "WRITE_OFFLINE"]),
+    "/write-to-online-store": ("feature_view", ["WRITE_ONLINE"]),
+    "/materialize": ("feature_view", ["WRITE_ONLINE"]),
+    "/materialize-incremental": ("feature_view", ["WRITE_ONLINE"]),
+}
+
+
+def _extract_client_ip(request: Request) -> str:
+    forwarded = request.headers.get("x-forwarded-for", "")
+    if forwarded:
+        return forwarded.split(",")[0].strip()
+    if request.client:
+        return request.client.host
+    return ""
+
+
+def _principal_from_request(request: Request) -> AuditPrincipal:
+    """Build an ``AuditPrincipal`` from the security manager's current user."""
+    try:
+        from feast.permissions.security_manager import get_security_manager
+
+        sm = get_security_manager()
+        if sm and sm.current_user:
+            user = sm.current_user
+            return AuditPrincipal(
+                username=user.username,
+                roles=list(user.roles) if user.roles else [],
+                auth_type=request.headers.get("x-feast-auth-type", ""),
+            )
+    except Exception:
+        pass
+    return AuditPrincipal()
+
+
+class AuditLoggingMiddleware(BaseHTTPMiddleware):
+    """Emit ``http.request`` audit events for REST endpoints."""
+
+    async def dispatch(self, request: Request, call_next):  # type: ignore[override]
+        audit: Optional[AuditLogger] = getattr(request.app.state, "audit_logger", None)
+        if audit is None:
+            return await call_next(request)
+
+        path = request.url.path
+        # Skip health and static endpoints
+        if path in ("/health", "/docs", "/openapi.json") or path.startswith("/static"):
+            return await call_next(request)
+
+        # Skip MCP transport endpoints — tool-call auditing is handled at the
+        # protocol layer in mcp_server._wrap_call_tool_handler().
+        if path.startswith("/mcp"):
+            return await call_next(request)
+
+        # If this request was triggered by an MCP tool call, reuse the same
+        # request_id so both events correlate in SIEM.
+        propagated_id = mcp_audit_request_id.get()
+        request_id = (
+            propagated_id
+            or request.headers.get("x-request-id")
+            or audit.new_request_id()
+        )
+        request.state.audit_request_id = request_id
+
+        start = time.monotonic()
+        response: Response
+        outcome = "success"
+        status_code = 200
+        try:
+            response = await call_next(request)
+            status_code = response.status_code
+            if status_code >= 400:
+                outcome = "failure"
+        except Exception:
+            outcome = "error"
+            status_code = 500
+            raise
+        finally:
+            duration_ms = (time.monotonic() - start) * 1000.0
+            resource_info = _PATH_RESOURCE_MAP.get(path, ("", []))
+            audit.log_http_request(
+                request_id=request_id,
+                method=request.method,
+                path=path,
+                principal=_principal_from_request(request),
+                source=AuditSource(ip=_extract_client_ip(request), transport="http"),
+                resource=AuditResource(
+                    type=resource_info[0], actions=list(resource_info[1])
+                ),
+                outcome=outcome,
+                duration_ms=round(duration_ms, 2),
+                status_code=status_code,
+            )
+
+        return response

{feast-0.67.0.dev100 → feast-0.67.0.dev101}/sdk/python/feast/feature_server.py

@@ -587,11 +587,27 @@ def get_app(
             active_timer = threading.Timer(registry_ttl_sec, async_refresh)
             active_timer.start()
 
+    # --- Audit logging setup ---
+    audit_logging_cfg = getattr(fs_cfg, "audit_logging", None)
+    audit_logger_instance = None
+    if audit_logging_cfg is not None and getattr(audit_logging_cfg, "enabled", False):
+        from feast.audit.audit_logger import create_audit_logger_from_config
+
+        audit_logger_instance = create_audit_logger_from_config(audit_logging_cfg)
+        if audit_logger_instance:
+            logger.info(
+                "Structured audit logging is ENABLED (sink=%s)",
+                getattr(audit_logging_cfg, "sink", "stdout"),
+            )
+
     @asynccontextmanager
     async def lifespan(app: FastAPI):
         # Load static artifacts before initializing store
         await load_static_artifacts(app, store)
 
+        if audit_logger_instance is not None:
+            app.state.audit_logger = audit_logger_instance
+
         await store.initialize()
         async_refresh()
         try:
@@ -603,10 +619,19 @@ def get_app(
             # wait=False: do not block process exit on in-flight materialize
             # (same fire-and-forget contract as returning 202 mid-job).
             materialize_executor.shutdown(wait=False)
+            if audit_logger_instance is not None:
+                audit_logger_instance.close()
             await store.close()
 
     app = FastAPI(lifespan=lifespan)
 
+    # Add audit logging middleware when enabled (REST only;
+    # MCP audit is handled at the protocol layer in mcp_server.py)
+    if audit_logger_instance is not None:
+        from feast.audit.audit_middleware import AuditLoggingMiddleware
+
+        app.add_middleware(AuditLoggingMiddleware)
+
     @app.post(
         "/get-online-features",
         dependencies=[Depends(inject_user_details)],
@@ -1153,12 +1178,12 @@ def get_app(
         app.mount("/static", StaticFiles(directory=static_dir), name="static")
 
     # Add MCP support if enabled in feature server configuration
-    _add_mcp_support_if_enabled(app, store)
+    _add_mcp_support_if_enabled(app, store, audit_logger_instance)
 
     return app
 
 
-def _add_mcp_support_if_enabled(app, store: "feast.FeatureStore"):
+def _add_mcp_support_if_enabled(app, store: "feast.FeatureStore", audit_logger=None):
     """Add MCP support to the FastAPI app if enabled in configuration."""
     mcp_transport_not_supported_error = None
     try:
@@ -1180,7 +1205,9 @@ def _add_mcp_support_if_enabled(app, store: "feast.FeatureStore"):
                 logger.error(f"Error checking/adding MCP support: {e}")
                 return
 
-            mcp_server = add_mcp_support_to_app(app, store, store.config.feature_server)
+            mcp_server = add_mcp_support_to_app(
+                app, store, store.config.feature_server, audit_logger=audit_logger
+            )
 
             if mcp_server:
                 logger.info("MCP support has been enabled for the Feast feature server")

{feast-0.67.0.dev100 → feast-0.67.0.dev101}/sdk/python/feast/infra/feature_servers/base_config.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import Optional
+from typing import Literal, Optional
 
 from pydantic import StrictBool, StrictInt
 
@@ -94,6 +94,27 @@ class MetricsConfig(FeastConfigBaseModel):
     identity, entity keys, feature views, row counts, and latency."""
 
 
+class AuditLoggingConfig(FeastConfigBaseModel):
+    """Structured audit logging configuration for the feature server.
+
+    Emits JSONL audit events for MCP tool calls, REST requests,
+    and authentication/authorization decisions.
+    """
+
+    enabled: StrictBool = False
+    """Whether structured audit logging is enabled."""
+
+    sink: Literal["stdout", "file", "logger"] = "stdout"
+    """Audit event sink: ``stdout``, ``file``, or ``logger``."""
+
+    file_path: str = "feast_audit.log"
+    """File path when ``sink`` is ``file``."""
+
+    log_successful_reads: StrictBool = True
+    """Emit audit events for successful read operations. Set to ``False``
+    to reduce log volume in high-throughput read-heavy deployments."""
+
+
 class BaseFeatureServerConfig(FeastConfigBaseModel):
     """Base Feature Server config that should be extended"""
 
@@ -107,6 +128,10 @@ class BaseFeatureServerConfig(FeastConfigBaseModel):
     feature_logging: Optional[FeatureLoggingConfig] = None
     """ Feature logging configuration """
 
+    audit_logging: Optional[AuditLoggingConfig] = None
+    """Structured audit logging configuration. Emits JSONL audit events
+    for MCP tool calls, REST requests, and auth decisions."""
+
     offline_push_batching_enabled: Optional[StrictBool] = None
     """Whether to batch writes to the offline store via the `/push` endpoint."""