Datasets:
File size: 3,260 Bytes
e1ced61 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 | """Structured logging with token and secret redaction.
No raw prompt, image, token, signed URL, or HF credential is ever written to a
log. A :class:`RedactingFilter` scrubs known secret patterns and any value of
sensitive environment variables from every record before it is emitted.
"""
from __future__ import annotations
import logging
import os
import re
from typing import Any
# Environment variables whose values must never appear in logs.
SENSITIVE_ENV_VARS = (
"HF_TOKEN",
"HUGGING_FACE_HUB_TOKEN",
"WANDB_API_KEY",
"GH_TOKEN",
"GITHUB_TOKEN",
)
_REDACTION_TOKEN = "[REDACTED]"
# Patterns that match common bearer/credential shapes regardless of env name.
_SECRET_PATTERNS: tuple[re.Pattern[str], ...] = (
re.compile(r"(?i)bearer\s+[A-Za-z0-9._\-]+"),
re.compile(r"(?i)token\s*[:=]\s*[A-Za-z0-9._\-]+"),
re.compile(r"hf_[A-Za-z0-9]{20,}"),
re.compile(r"sk-[A-Za-z0-9]{20,}"),
re.compile(r"https?://[^\s/@]+@[^\s/]+"), # userinfo in URLs
)
def _sensitive_values() -> list[str]:
values: list[str] = []
for name in SENSITIVE_ENV_VARS:
value = os.environ.get(name)
if value:
values.append(value)
return values
def redact(text: str) -> str:
"""Return ``text`` with known secrets and sensitive env values removed."""
if not text:
return text
redacted = text
for value in _sensitive_values():
if value and value in redacted:
redacted = redacted.replace(value, _REDACTION_TOKEN)
for pattern in _SECRET_PATTERNS:
redacted = pattern.sub(_REDACTION_TOKEN, redacted)
return redacted
class RedactingFilter(logging.Filter):
"""A logging filter that redacts secrets from message and args."""
def filter(self, record: logging.LogRecord) -> bool:
record.msg = redact(str(record.msg))
if record.args:
if isinstance(record.args, dict):
record.args = {k: redact(str(v)) for k, v in record.args.items()}
elif isinstance(record.args, tuple):
record.args = tuple(redact(str(a)) for a in record.args)
return True
def configure_logging(
*,
level: int = logging.INFO,
name: str = "explicit_learning",
stream: Any = None,
) -> logging.Logger:
"""Configure and return a logger with redaction applied to all records."""
logger = logging.getLogger(name)
logger.setLevel(level)
logger.propagate = False
if not logger.handlers:
handler = logging.StreamHandler(stream) if stream else logging.StreamHandler()
handler.setFormatter(
logging.Formatter(
"%(asctime)s %(levelname)s %(name)s %(message)s",
datefmt="%Y-%m-%dT%H:%M:%SZ",
)
)
handler.addFilter(RedactingFilter())
logger.addHandler(handler)
else:
for existing in logger.handlers:
existing.addFilter(RedactingFilter())
return logger
def get_logger(name: str | None = None) -> logging.Logger:
"""Return a child logger under the package logger (redaction inherited)."""
base = logging.getLogger("explicit_learning")
if not base.handlers:
configure_logging()
return base.getChild(name) if name else base
|