simpleaudit 0.3.1__tar.gz → 0.3.3__tar.gz

{simpleaudit-0.3.1/simpleaudit.egg-info → simpleaudit-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simpleaudit
-Version: 0.3.1
+Version: 0.3.3
 Summary: Lightweight AI Safety Auditing Framework
 Author: SimpleAudit Contributors
 License: MIT

{simpleaudit-0.3.1 → simpleaudit-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simpleaudit"
-version = "0.3.1"
+version = "0.3.3"
 description = "Lightweight AI Safety Auditing Framework"
 readme = "README.md"
 license = {text = "MIT"}

{simpleaudit-0.3.1 → simpleaudit-0.3.3}/simpleaudit/__init__.py

@@ -34,7 +34,7 @@ except PackageNotFoundError:
     __version__ = "0.0.0+unknown"
 __author__ = "SimpleAudit Contributors"
 
-from .model_auditor import ModelAuditor
+from .model_auditor import ModelAuditor, ScenarioExecution
 from .auditor import Auditor
 from .targets import (
     CallableTarget,
@@ -86,6 +86,7 @@ from .perturbations import (
 
 __all__ = [
     "ModelAuditor",
+    "ScenarioExecution",
     "Auditor",
     "Target",
     "TargetContext",

{simpleaudit-0.3.1 → simpleaudit-0.3.3}/simpleaudit/model_auditor.py

@@ -43,6 +43,31 @@ from .utils import (
 from .utils import parse_json_response as _parse_json_response
 
 
+from dataclasses import dataclass
+
+
+@dataclass
+class ScenarioExecution:
+    """Captures the state of a scenario after target execution but before judgment.
+
+    This dataclass represents one scenario execution through the target conversation phase.
+    It holds all state necessary for the evidence resolver to select trace evidence, which
+    can then be passed to the judge.
+    """
+    scenario_name: str
+    scenario_description: str
+    conversation: List[Dict]
+    trace_correlation: Optional[Any] = None
+    audit_run_id: Optional[str] = None
+    error: Optional[str] = None
+    scenario_meta: Optional[Dict[str, Any]] = None
+    expected_behavior: Optional[List[str]] = None
+    target_input_tokens: int = 0
+    target_output_tokens: int = 0
+    auditor_input_tokens: int = 0
+    auditor_output_tokens: int = 0
+
+
 def _user_agent() -> str:
     try:
         return f"simpleaudit/{_pkg_version('simpleaudit')}"
@@ -867,6 +892,7 @@ Evaluate this conversation and respond with this exact JSON structure:
         evidence_spans: Optional[List[Dict[str, Any]]] = None,
         audit_run_id: Optional[str] = None,
         trace_correlation: Optional[Any] = None,
+        evidence_resolver: Optional[Callable[[ScenarioExecution], Union[List[Dict[str, Any]], None]]] = None,
     ) -> AuditResult:
         turns = max_turns or self.max_turns
         # Per-scenario correlation ids. A fresh trace id per scenario keeps each
@@ -976,6 +1002,30 @@ Evaluate this conversation and respond with this exact JSON structure:
             self._log(f"--- Scenario FAILED mid-conversation: {name} [{error}] ---")
 
         if error is None:
+            # Call evidence resolver if provided, after target conversation, before judge.
+            resolved_evidence = evidence_spans
+            if evidence_resolver is not None:
+                execution = ScenarioExecution(
+                    scenario_name=name,
+                    scenario_description=description,
+                    conversation=conversation,
+                    scenario_meta=scenario_meta,
+                    expected_behavior=expected_behavior,
+                    trace_correlation=trace_correlation,
+                    audit_run_id=audit_run_id,
+                    error=None,
+                    target_input_tokens=target_input_tokens,
+                    target_output_tokens=target_output_tokens,
+                    auditor_input_tokens=auditor_input_tokens,
+                    auditor_output_tokens=auditor_output_tokens,
+                )
+                try:
+                    resolved_evidence = await evidence_resolver(execution) if asyncio.iscoroutinefunction(evidence_resolver) else evidence_resolver(execution)
+                except Exception as exc:
+                    self._log(f"--- Evidence resolution failed: {type(exc).__name__}: {exc} ---")
+                    # If evidence resolution fails, continue without evidence
+                    resolved_evidence = evidence_spans
+
             self._log("Judging conversation...", name=name)
             judge_prompt, judge_schema, judge_postprocess, fell_back = self._resolve_judge_spec(
                 self.judge_prompt,
@@ -1003,7 +1053,7 @@ Evaluate this conversation and respond with this exact JSON structure:
                     postprocess=judge_postprocess,
                     scenario_meta=scenario_meta,
                     params=effective_judge or None,
-                    evidence_spans=evidence_spans,
+                    evidence_spans=resolved_evidence,
                 )
                 judge_input_tokens += j_in
                 judge_output_tokens += j_out
@@ -1076,6 +1126,7 @@ Evaluate this conversation and respond with this exact JSON structure:
         evidence_spans: Optional[List[Dict[str, Any]]] = None,
         audit_run_id: Optional[str] = None,
         trace_correlation: Optional[Any] = None,
+        evidence_resolver: Optional[Callable[[ScenarioExecution], Union[List[Dict[str, Any]], None]]] = None,
     ) -> AuditResults:
         if max_workers < 1:
             raise ValueError(
@@ -1150,6 +1201,7 @@ Evaluate this conversation and respond with this exact JSON structure:
                         evidence_spans=evidence_spans,
                         audit_run_id=audit_run_id,
                         trace_correlation=trace_correlation,
+                        evidence_resolver=evidence_resolver,
                     )
                 except Exception as exc:
                     # Don't let one failing scenario abort the whole batch and
@@ -1210,6 +1262,7 @@ Evaluate this conversation and respond with this exact JSON structure:
         evidence_spans: Optional[List[Dict[str, Any]]] = None,
         audit_run_id: Optional[str] = None,
         trace_correlation: Optional[Any] = None,
+        evidence_resolver: Optional[Callable[[ScenarioExecution], Union[List[Dict[str, Any]], None]]] = None,
     ) -> AuditResults:
         try:
             asyncio.get_running_loop()
@@ -1228,6 +1281,7 @@ Evaluate this conversation and respond with this exact JSON structure:
                     evidence_spans=evidence_spans,
                     audit_run_id=audit_run_id,
                     trace_correlation=trace_correlation,
+                    evidence_resolver=evidence_resolver,
                 )
             )
         msg = "ModelAuditor.run() cannot be called from an active event loop. Use await <object>.run_async()."

{simpleaudit-0.3.1 → simpleaudit-0.3.3}/simpleaudit/targets/model.py

@@ -88,6 +88,7 @@ class ModelTarget:
             documents=documents,
             response_format=response_format,
             params=params,
+            context=context,
             max_retries=self.max_retries,
             retry_backoff=self.retry_backoff,
         )
@@ -104,6 +105,7 @@ async def _client_send(
     documents: Optional[List[Union[str, Dict[str, Any]]]],
     response_format: Optional[Dict[str, Any]],
     params: Optional[Dict[str, Any]],
+    context: Optional[TargetContext] = None,
     max_retries: int,
     retry_backoff: float,
 ) -> TargetResponse:
@@ -111,9 +113,21 @@ async def _client_send(
 
     Imported lazily so that ``simpleaudit.targets`` does not create an import
     cycle with ``model_auditor`` at package import time.
+
+    When the per-turn context carries W3C trace headers (e.g. the engine's
+    scenario traceparent), they are merged into ``extra_headers`` so the
+    target's outgoing call propagates the trace context. This is what lets an
+    instrumented target export spans under the same trace id the engine's
+    TraceCorrelation records. User-supplied extra_headers are preserved.
     """
     from ..model_auditor import ModelAuditor
 
+    if context is not None and context.trace_headers:
+        headers = dict(params.get("extra_headers", {}) if params else {})
+        headers.update(context.trace_headers)
+        params = dict(params or {})
+        params["extra_headers"] = headers
+
     content, input_tokens, output_tokens = await ModelAuditor._call_async(
         client,
         model,

{simpleaudit-0.3.1 → simpleaudit-0.3.3}/simpleaudit/tracing/__init__.py

@@ -15,11 +15,14 @@ when the target is instrumented.
 from .auth import (
     AuthResult,
     Authenticator,
+    OTLPAuth,
+    TARGET_ID_ATTR,
     hash_secret,
     make_basic_bearer_authenticator,
     new_salt,
     parse_basic_header,
     parse_bearer_header,
+    tag_spans,
     token_lookup_prefix,
     verify_secret,
 )
@@ -71,6 +74,9 @@ __all__ = [
     "DEFAULT_NOISE_KINDS",
     "AuthResult",
     "Authenticator",
+    "OTLPAuth",
+    "TARGET_ID_ATTR",
+    "tag_spans",
     "hash_secret",
     "new_salt",
     "verify_secret",

simpleaudit-0.3.3/simpleaudit/tracing/auth.py

@@ -0,0 +1,332 @@
+"""
+OTLP receiver authentication — the "WHO is allowed to submit" layer.
+
+This module is deliberately **framework-agnostic**: it has no Django (or any
+web-framework) dependency so both the standalone ``simpleaudit`` library and
+the SimpleAuditStudio app can use the same auth. It answers one question —
+which target is allowed to push spans — and maps the credential to a stable
+``target_id`` that the receiver tags onto every ingested span.
+
+Two auth modes (plus ``none``):
+
+    - ``none``   — no check. Local / ephemeral receiver on a trusted network.
+    - ``basic``  — ``Authorization: Basic base64(username:password)``.
+                   Best for OpenWebUI, which natively supports
+                   ``OTEL_BASIC_AUTH_USERNAME`` / ``OTEL_BASIC_AUTH_PASSWORD``.
+    - ``bearer`` — ``Authorization: Bearer <token>``. Best for generic OTel
+                   exporters that can set arbitrary headers
+                   (``OTEL_EXPORTER_OTLP_HEADERS=Authorization=Bearer <t>``).
+
+Credentials are revocable and rotatable. Secrets are stored as salted
+SHA-256 hashes and compared in constant time (``hmac.compare_digest``) to
+avoid timing side-channels.
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import hashlib
+import hmac
+import os
+import secrets
+from dataclasses import dataclass
+from typing import Callable, Dict, Optional, Protocol, Tuple
+
+# Salt length (bytes) prepended to each secret before hashing.
+_SALT_LEN = 16
+# Attribute key the receiver stamps onto every authenticated span.
+TARGET_ID_ATTR = "simpleaudit.target_id"
+
+SALT_LEN = _SALT_LEN
+BEARER_TOKEN_PREFIX = "sa_otlp_"
+TOKEN_LOOKUP_PREFIX_LEN = 16
+
+
+def new_salt() -> bytes:
+    return _new_salt()
+
+
+def hash_secret(secret: str, salt: bytes) -> bytes:
+    return _hash_secret(secret, salt)
+
+
+def verify_secret(secret: str, salt: bytes, expected_hash: bytes) -> bool:
+    if not salt or not expected_hash:
+        return False
+    return hmac.compare_digest(expected_hash, _hash_secret(secret, salt))
+
+
+def generate_password() -> str:
+    return secrets.token_urlsafe(32)
+
+
+def generate_token() -> str:
+    return BEARER_TOKEN_PREFIX + secrets.token_urlsafe(32)
+
+
+def token_lookup_prefix(token: str) -> str:
+    return (token or "")[:TOKEN_LOOKUP_PREFIX_LEN]
+
+
+def parse_basic_header(authorization: Optional[str]) -> Optional[Tuple[str, str]]:
+    if not authorization:
+        return None
+    parts = authorization.strip().split(" ", 1)
+    if len(parts) != 2 or parts[0].lower() != "basic":
+        return None
+    try:
+        decoded = base64.b64decode(parts[1].strip(), validate=True).decode("utf-8")
+    except (binascii.Error, UnicodeDecodeError, ValueError):
+        return None
+    if ":" not in decoded:
+        return None
+    return tuple(decoded.split(":", 1))
+
+
+def parse_bearer_header(authorization: Optional[str]) -> Optional[str]:
+    if not authorization:
+        return None
+    parts = authorization.strip().split(" ", 1)
+    if len(parts) != 2 or parts[0].lower() != "bearer":
+        return None
+    return parts[1].strip() or None
+
+
+class Authenticator(Protocol):
+    def __call__(self, authorization: Optional[str]) -> "AuthResult": ...
+
+
+def make_basic_bearer_authenticator(
+    verify: Callable[[Optional[str]], Optional[str]],
+) -> Authenticator:
+    def _authenticate(authorization: Optional[str]) -> AuthResult:
+        identity = verify(authorization)
+        return AuthResult(ok=identity is not None, target_id=identity)
+
+    return _authenticate
+
+
+def _hash_secret(secret: str, salt: bytes) -> bytes:
+    """Salted SHA-256 of a secret. Deterministic for a given salt."""
+    return hashlib.sha256(salt + secret.encode("utf-8")).digest()
+
+
+def _new_salt() -> bytes:
+    return os.urandom(_SALT_LEN)
+
+
+@dataclass
+class _Credential:
+    """A stored credential: salt + hash of the secret, bound to a target_id."""
+
+    target_id: str
+    salt: bytes
+    secret_hash: bytes
+    revoked: bool = False
+
+    def matches(self, secret: str) -> bool:
+        """Constant-time check of a presented secret against the stored hash."""
+        if self.revoked:
+            return False
+        return hmac.compare_digest(self.secret_hash, _hash_secret(secret, self.salt))
+
+
+@dataclass(init=False)
+class AuthResult:
+    """Outcome of an :meth:`OTLPAuth.verify` call.
+
+    ``ok`` is True when the request may proceed. ``target_id`` is set (and
+    non-empty) when a credential was matched; it is ``None`` in ``none`` mode
+    and on failure. ``reason`` is a short, log-safe explanation on failure.
+    """
+
+    ok: bool
+    target_id: Optional[str] = None
+    reason: Optional[str] = None
+
+    def __init__(
+        self,
+        ok: Optional[bool] = None,
+        target_id: Optional[str] = None,
+        reason: Optional[str] = None,
+        *,
+        authenticated: Optional[bool] = None,
+        identity: Optional[str] = None,
+    ) -> None:
+        self.ok = bool(ok if ok is not None else authenticated)
+        self.target_id = target_id if target_id is not None else identity
+        self.reason = reason
+
+    @property
+    def authenticated(self) -> bool:
+        return self.ok
+
+    @property
+    def identity(self) -> Optional[str]:
+        return self.target_id
+
+
+class OTLPAuth:
+    """Credential store + verifier for an OTLP receiver.
+
+    Construct with a mode, add credentials, then hand the instance to an
+    :class:`~simpleaudit.tracing.otlp.OTLPTraceReceiver` or
+    :class:`~simpleaudit.tracing.otlp.EphemeralOTLPReceiver`. The receiver
+    calls :meth:`verify` on each request's ``Authorization`` header.
+
+    Example::
+
+        auth = OTLPAuth(mode="basic")
+        auth.add_basic("sa_owui_17", "p4ss", target_id="owui_17")
+        result = auth.verify("Basic " + b64("sa_owui_17:p4ss"))
+        assert result.ok and result.target_id == "owui_17"
+    """
+
+    def __init__(self, mode: str = "none") -> None:
+        mode = (mode or "none").strip().lower()
+        if mode not in ("none", "basic", "bearer"):
+            raise ValueError(f"Unknown OTLPAuth mode: {mode!r} (expected 'none', 'basic', or 'bearer')")
+        self.mode = mode
+        # username -> credential (basic)
+        self._basic: Dict[str, _Credential] = {}
+        # token-hash-keyed credential (bearer). We index by a *lookup* hash of
+        # the token (salted per-credential) so we can find the record to
+        # compare against without storing the raw token.
+        self._bearer: Dict[str, _Credential] = {}
+
+    # ── Credential management ────────────────────────────────────────────
+
+    def add_basic(self, username: str, password: str, target_id: str) -> None:
+        """Register (or replace) a Basic-Auth credential for ``target_id``."""
+        if not username:
+            raise ValueError("username is required")
+        salt = _new_salt()
+        self._basic[username] = _Credential(
+            target_id=target_id, salt=salt, secret_hash=_hash_secret(password, salt)
+        )
+
+    def add_bearer(self, token: str, target_id: str) -> None:
+        """Register (or replace) a Bearer credential for ``target_id``."""
+        if not token:
+            raise ValueError("token is required")
+        salt = _new_salt()
+        cred = _Credential(target_id=target_id, salt=salt, secret_hash=_hash_secret(token, salt))
+        # Index by the salted hash so lookup needs only the presented token.
+        self._bearer[_hash_secret(token, salt).hex()] = cred
+
+    def revoke(self, username_or_token: str) -> bool:
+        """Revoke a credential by username (basic) or token (bearer).
+
+        Returns True if a matching credential was found and revoked.
+        """
+        if username_or_token in self._basic:
+            self._basic[username_or_token].revoked = True
+            return True
+        # For bearer we must find the record by hashing the token with each
+        # stored salt; the index key is that hash, so we can't reverse it.
+        # Instead we scan (credential sets are small — one per target).
+        for cred in self._bearer.values():
+            if cred.matches(username_or_token):
+                cred.revoked = True
+                return True
+        return False
+
+    def rotate_basic(self, username: str, new_password: str) -> None:
+        """Re-issue the password for an existing Basic credential (same target)."""
+        cred = self._basic.get(username)
+        if cred is None:
+            raise KeyError(f"No Basic credential for username {username!r}")
+        salt = _new_salt()
+        cred.salt = salt
+        cred.secret_hash = _hash_secret(new_password, salt)
+        cred.revoked = False
+
+    def rotate_bearer(self, old_token: str, new_token: str) -> None:
+        """Replace a Bearer token, keeping the same target_id."""
+        old_cred = self._find_bearer(old_token)
+        if old_cred is None:
+            raise KeyError("No Bearer credential for the given token")
+        # Remove the old index entry and register the new token under the
+        # same target_id.
+        for key, cred in list(self._bearer.items()):
+            if cred is old_cred:
+                del self._bearer[key]
+                break
+        self.add_bearer(new_token, old_cred.target_id)
+
+    def _find_bearer(self, token: str) -> Optional[_Credential]:
+        for cred in self._bearer.values():
+            if cred.matches(token):
+                return cred
+        return None
+
+    # ── Verification ─────────────────────────────────────────────────────
+
+    def verify(self, authorization_header: Optional[str]) -> AuthResult:
+        """Verify an ``Authorization`` header and return the target id.
+
+        In ``none`` mode this always succeeds (``target_id`` is ``None``).
+        """
+        if self.mode == "none":
+            return AuthResult(ok=True)
+
+        header = (authorization_header or "").strip()
+        if not header:
+            return AuthResult(ok=False, reason="missing_authorization_header")
+
+        parts = header.split(" ", 1)
+        if len(parts) != 2 or not parts[1].strip():
+            return AuthResult(ok=False, reason="malformed_authorization_header")
+        scheme, value = parts[0].strip().lower(), parts[1].strip()
+
+        # The scheme must match the configured mode.
+        if self.mode == "basic":
+            if scheme != "basic":
+                return AuthResult(ok=False, reason="expected_basic_scheme")
+            return self._verify_basic(value)
+        # bearer
+        if scheme != "bearer":
+            return AuthResult(ok=False, reason="expected_bearer_scheme")
+        return self._verify_bearer(value)
+
+    def _verify_basic(self, value: str) -> AuthResult:
+        # value should be base64("username:password")
+        try:
+            decoded = base64.b64decode(value, validate=True).decode("utf-8")
+        except (binascii.Error, UnicodeDecodeError, ValueError):
+            return AuthResult(ok=False, reason="invalid_basic_encoding")
+        if ":" not in decoded:
+            return AuthResult(ok=False, reason="invalid_basic_credentials")
+        username, password = decoded.split(":", 1)
+        cred = self._basic.get(username)
+        if cred is None:
+            return AuthResult(ok=False, reason="unknown_username")
+        if not cred.matches(password):
+            return AuthResult(ok=False, reason="invalid_credentials")
+        return AuthResult(ok=True, target_id=cred.target_id)
+
+    def _verify_bearer(self, token: str) -> AuthResult:
+        if not token:
+            return AuthResult(ok=False, reason="empty_bearer_token")
+        cred = self._find_bearer(token)
+        if cred is None:
+            return AuthResult(ok=False, reason="unknown_token")
+        return AuthResult(ok=True, target_id=cred.target_id)
+
+
+def tag_spans(spans, target_id: Optional[str]) -> None:
+    """Stamp ``simpleaudit.target_id`` onto each span's attributes in place.
+
+    No-op when ``target_id`` is falsy (e.g. ``none`` mode). Mutates the raw
+    span dicts before they are normalized/stored, so the tag flows through
+    :func:`simpleaudit.tracing.otlp.parse_otlp_json` and is queryable via
+    ``SpanStore.by_attribute``.
+    """
+    if not target_id:
+        return
+    for span in spans:
+        attrs = span.get("attributes")
+        if attrs is None:
+            span["attributes"] = attrs = {}
+        attrs.setdefault(TARGET_ID_ATTR, target_id)

{simpleaudit-0.3.1 → simpleaudit-0.3.3}/simpleaudit/tracing/otlp.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 import json
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
+from .auth import OTLPAuth, tag_spans
 from .store import SpanStore, normalize_span
 
 if TYPE_CHECKING:  # pragma: no cover - annotation only
@@ -132,13 +133,16 @@ class OTLPTraceReceiver:
         self,
         store: Optional[SpanStore] = None,
         authenticator: Optional["Authenticator"] = None,
+        auth: Optional[OTLPAuth] = None,
     ) -> None:
+        self._default_store = store is None
         self.store = store or SpanStore()
         # Optional auth gate. When set, handle() calls it with the request's
         # Authorization header and rejects the export (401) on failure. When
         # None the receiver is open — the historical, backward-compatible
         # behaviour for the local, single-audit ephemeral case.
         self.authenticator = authenticator
+        self.auth = auth
 
     async def handle(self, body: Any, authorization: Optional[str] = None) -> Dict[str, Any]:
         """Ingest an OTLP JSON export body; return the OTLP ack payload.
@@ -147,14 +151,30 @@ class OTLPTraceReceiver:
         ``Authorization`` header) is checked first; a failed check returns a
         401 ``{"error": ...}`` payload and no spans are stored.
         """
-        if self.authenticator is not None:
-            result = self.authenticator(authorization)
-            if not result.authenticated:
-                return {"status": 401, "error": {"code": "unauthorized", "message": "Invalid or missing OTLP credentials."}}
+        result = self._authenticate(authorization)
+        if result is not None and not result.authenticated:
+            return {
+                "status": 401,
+                "authenticated": False,
+                "reason": getattr(result, "reason", None),
+                "error": {"code": "unauthorized", "message": "Invalid or missing OTLP credentials."},
+            }
         raw_spans = parse_otlp_json(body)
+        if result is not None:
+            tag_spans(raw_spans, result.identity)
         self.store.add_many(raw_spans)
         # OTLP ack: partialSuccess with the number of rejected spans (0 here).
-        return {"partialSuccess": {"rejectedSpans": 0}}
+        ack = {"partialSuccess": {"rejectedSpans": 0}}
+        if self.auth is not None or self._default_store:
+            ack["authenticated"] = True
+        return ack
+
+    def _authenticate(self, authorization: Optional[str]) -> Any:
+        if self.auth is not None:
+            return self.auth.verify(authorization)
+        if self.authenticator is not None:
+            return self.authenticator(authorization)
+        return None
 
     def trace_ids(self) -> List[str]:
         seen: List[str] = []
@@ -196,6 +216,7 @@ class EphemeralOTLPReceiver:
         port: int = 0,
         store: Optional[SpanStore] = None,
         authenticator: Optional["Authenticator"] = None,
+        auth: Optional[OTLPAuth] = None,
     ) -> None:
         self.host = host
         self.port = port
@@ -204,6 +225,7 @@ class EphemeralOTLPReceiver:
         # checked against the request's Authorization header and rejected with
         # 401 on failure. None = open receiver (default).
         self.authenticator = authenticator
+        self.auth = auth
         self._runner: Optional[Any] = None
         self._site: Optional[Any] = None
         self._thread: Optional[Any] = None
@@ -225,13 +247,12 @@ class EphemeralOTLPReceiver:
     async def _handle_traces(self, request: Any) -> Any:
         from aiohttp import web
 
-        if self.authenticator is not None:
-            result = self.authenticator(request.headers.get("Authorization"))
-            if not result.authenticated:
-                return web.json_response(
-                    {"error": {"code": "unauthorized", "message": "Invalid or missing OTLP credentials."}},
-                    status=401,
-                )
+        result = self._authenticate(request.headers.get("Authorization"))
+        if result is not None and not result.authenticated:
+            return web.json_response(
+                {"authenticated": False, "error": {"code": "unauthorized", "message": "Invalid or missing OTLP credentials."}},
+                status=401,
+            )
 
         content_type = request.headers.get("Content-Type", "")
         body_bytes = await request.read()
@@ -240,12 +261,21 @@ class EphemeralOTLPReceiver:
                 raw_spans = _parse_otlp_http_protobuf(body_bytes)
             else:
                 raw_spans = parse_otlp_json(body_bytes.decode("utf-8"))
+            if result is not None:
+                tag_spans(raw_spans, result.identity)
             self.store.add_many(raw_spans)
         except Exception:
             # Never fail the export; ack with a rejection count so the target
             # doesn't retry-loop. The audit continues regardless.
             return web.json_response({"partialSuccess": {"rejectedSpans": 1}}, status=200)
-        return web.json_response({"partialSuccess": {"rejectedSpans": 0}}, status=200)
+        return web.json_response({"partialSuccess": {"rejectedSpans": 0}, "authenticated": True}, status=200)
+
+    def _authenticate(self, authorization: Optional[str]) -> Any:
+        if self.auth is not None:
+            return self.auth.verify(authorization)
+        if self.authenticator is not None:
+            return self.authenticator(authorization)
+        return None
 
     def _serve(self, loop: Any) -> None:
         import asyncio