# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-log-provenance-is-required-when-an-observability-pipeline-is-outsourced-to-a-third-party.md
# Remnant Warrant:    https://corpusfetch.com/c/what-log-provenance-is-required-when-an-observability-pipeline-is-outsourced-to-a-third-party.warrant.json
# Markdown SHA-256:   ceeb05565410f44e8b89e5da14e31861b050cabae9a5fdf171e48158baee82b1
# Code AST SHA-256:   74e5d2a43ae142b5e6cbeae53a3ee594603617d553bb3a2572ae8a5ff32df50e
# Verified Classes:   DataClass, ScrubbingVerdict, LogPayload, EgressPolicy, ScrubbingManifest, ThirdPartyTelemetryGuard
# Defensive Guards:   0 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class DataClass(Enum):
    PUBLIC = 1
    INTERNAL = 2
    PII = 3
    SECRET = 4

class ScrubbingVerdict(Enum):
    SAFE_TO_SHIP = auto()
    SCRUBBING_REQUIRED = auto()
    RULESET_OUTDATED = auto()

@dataclass(frozen=True)
class LogPayload:
    payload_hash: str
    data_class: DataClass
    scrubbing_receipt: str | None
    scrubbing_ruleset_hash: str | None

@dataclass(frozen=True)
class EgressPolicy:
    required_scrubbing_ruleset_hash: str
    third_party_trusted: bool

@dataclass(frozen=True)
class ScrubbingManifest:
    verdict: ScrubbingVerdict
    directive: str
    manifest_digest: str

class ThirdPartyTelemetryGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_log(
        cls, log: LogPayload, policy: EgressPolicy
    ) -> ScrubbingManifest:
        
        # Gate 1: Public or trusted third party
        if log.data_class == DataClass.PUBLIC or policy.third_party_trusted:
            digest = cls._hash(json.dumps({
                "payload": log.payload_hash,
                "class": log.data_class.name,
                "trust": str(policy.third_party_trusted)
            }, sort_keys=True))
            return ScrubbingManifest(
                verdict=ScrubbingVerdict.SAFE_TO_SHIP,
                directive="PROCEED: Data class or trust relationship permits shipping.",
                manifest_digest=digest
            )

        # Gate 2: Scrubbing receipt
        if not log.scrubbing_receipt:
            return ScrubbingManifest(
                verdict=ScrubbingVerdict.SCRUBBING_REQUIRED,
                directive=f"HALT: {log.data_class.name} payload lacks scrubbing receipt.",
                manifest_digest=cls._hash(f"NO_SCRUB:{log.payload_hash}")
            )

        # Gate 3: Ruleset match
        if log.scrubbing_ruleset_hash != policy.required_scrubbing_ruleset_hash:
            return ScrubbingManifest(
                verdict=ScrubbingVerdict.RULESET_OUTDATED,
                directive=f"HALT: Scrubbing ruleset mismatch. Re-scrub with current ruleset.",
                manifest_digest=cls._hash(f"RULESET:{log.payload_hash}")
            )

        # Gate 4: Safe to ship
        digest = cls._hash(json.dumps({
            "payload": log.payload_hash,
            "class": log.data_class.name,
            "receipt": log.scrubbing_receipt,
            "ruleset": log.scrubbing_ruleset_hash
        }, sort_keys=True))
        
        return ScrubbingManifest(
            verdict=ScrubbingVerdict.SAFE_TO_SHIP,
            directive="PROCEED: Scrubbed payload safe for third-party egress.",
            manifest_digest=digest
        )