Buckets:
AnonymousSpottedToad/human_verified_bucket / codebase /python /Daylily-Informatics_bloom /bloom_lims /anomalies.py
| from __future__ import annotations | |
| from dataclasses import dataclass | |
| from datetime import UTC, datetime | |
| from typing import Any | |
| from daylily_tapdb import require_seeded_templates | |
| from daylily_tapdb.factory import InstanceFactory | |
| from daylily_tapdb.models.instance import generic_instance | |
| from daylily_tapdb.templates import TemplateManager | |
| from sqlalchemy import select | |
| from sqlalchemy.orm import Session | |
| from sqlalchemy.orm.attributes import flag_modified | |
| from bloom_lims.config import get_settings | |
| from bloom_lims.observability import ProjectionMetadata | |
| ANOMALY_TEMPLATE_CODE = "ops/anomaly-record/generic/1.0/" | |
| ANOMALY_PREFIX = "BAN" | |
| class AnomalyRecord: | |
| id: str | |
| service: str | |
| environment: str | |
| category: str | |
| severity: str | |
| fingerprint: str | |
| summary: str | |
| first_seen_at: str | |
| last_seen_at: str | |
| occurrence_count: int | |
| redacted_context: dict[str, Any] | |
| source_view_url: str | |
| def redact_context(value: Any) -> Any: | |
| if isinstance(value, dict): | |
| redacted: dict[str, Any] = {} | |
| for key, item in value.items(): | |
| lowered = str(key).lower() | |
| if lowered in { | |
| "authorization", | |
| "cookie", | |
| "set-cookie", | |
| "token", | |
| "secret", | |
| "password", | |
| }: | |
| redacted[str(key)] = "[redacted]" | |
| else: | |
| redacted[str(key)] = redact_context(item) | |
| return redacted | |
| if isinstance(value, list): | |
| return [redact_context(item) for item in value] | |
| if isinstance(value, str): | |
| text = value | |
| for prefix in ("/documents/", "/patients/", "/subjects/"): | |
| if prefix in text: | |
| head, _, tail = text.partition(prefix) | |
| parts = tail.split("/", 1) | |
| if parts and parts[0].isdigit(): | |
| suffix = f"/{parts[1]}" if len(parts) > 1 else "" | |
| text = f"{head}{prefix}{{id}}{suffix}" | |
| if "select " in text.lower(): | |
| return "[redacted-sql]" | |
| return text | |
| return value | |
| class TapdbAnomalyRepository: | |
| def __init__(self, db: Session): | |
| self.db = db | |
| self.domain_code = str(get_settings().tapdb.domain_code).strip().upper() | |
| self.templates = TemplateManager() | |
| self.factory = InstanceFactory( | |
| self.templates, | |
| domain_code=self.domain_code, | |
| ) | |
| self._templates_ready = False | |
| def projection(self, *, observed_at: str | None = None) -> ProjectionMetadata: | |
| seen_at = observed_at or datetime.now(UTC).isoformat() | |
| return ProjectionMetadata( | |
| state="ready", | |
| stale=False, | |
| observed_at=seen_at, | |
| last_synced_at=seen_at, | |
| detail=None, | |
| ) | |
| def record( | |
| self, | |
| *, | |
| category: str, | |
| severity: str, | |
| fingerprint: str, | |
| summary: str, | |
| redacted_context: dict[str, Any] | None = None, | |
| ) -> AnomalyRecord: | |
| self._ensure_templates() | |
| now = datetime.now(UTC).isoformat() | |
| environment = get_settings().environment or "unknown" | |
| context = redact_context(redacted_context or {}) | |
| existing = self._find_existing( | |
| category=category, | |
| severity=severity, | |
| fingerprint=fingerprint, | |
| environment=environment, | |
| ) | |
| if existing is None: | |
| instance = self.factory.create_instance( | |
| session=self.db, | |
| template_code=ANOMALY_TEMPLATE_CODE, | |
| name=summary[:120], | |
| properties={ | |
| "service": "bloom", | |
| "environment": environment, | |
| "category": category, | |
| "severity": severity, | |
| "fingerprint": fingerprint, | |
| "summary": summary, | |
| "first_seen_at": now, | |
| "last_seen_at": now, | |
| "occurrence_count": 1, | |
| "redacted_context": context, | |
| }, | |
| ) | |
| else: | |
| props = self._props(existing) | |
| props["summary"] = summary | |
| props["last_seen_at"] = now | |
| props["occurrence_count"] = int(props.get("occurrence_count") or 0) + 1 | |
| props["redacted_context"] = context | |
| self._write_props(existing, props) | |
| instance = existing | |
| self.db.commit() | |
| return self._to_record(instance) | |
| def list(self, *, skip: int = 0, limit: int = 100) -> list[AnomalyRecord]: | |
| self._ensure_templates() | |
| rows = [self._to_record(instance) for instance in self._instances()] | |
| rows.sort(key=lambda row: row.last_seen_at, reverse=True) | |
| return rows[skip : skip + limit] | |
| def get(self, anomaly_id: str) -> AnomalyRecord | None: | |
| self._ensure_templates() | |
| for instance in self._instances(): | |
| if instance.euid == anomaly_id: | |
| return self._to_record(instance) | |
| return None | |
| def record_db_probe_failure( | |
| self, *, detail: str, latency_ms: float | |
| ) -> AnomalyRecord: | |
| return self.record( | |
| category="database", | |
| severity="error", | |
| fingerprint=f"db:{hash(detail)}", | |
| summary="Bloom database probe failed", | |
| redacted_context={ | |
| "detail": detail, | |
| "latency_ms": round(float(latency_ms), 3), | |
| }, | |
| ) | |
| def _ensure_templates(self) -> None: | |
| if self._templates_ready: | |
| return | |
| require_seeded_templates( | |
| self.db, | |
| [(ANOMALY_TEMPLATE_CODE, ANOMALY_PREFIX)], | |
| app_name="Bloom", | |
| domain_code=self.domain_code, | |
| template_manager=self.templates, | |
| ) | |
| self._templates_ready = True | |
| def _find_existing( | |
| self, | |
| *, | |
| category: str, | |
| severity: str, | |
| fingerprint: str, | |
| environment: str, | |
| ) -> generic_instance | None: | |
| for instance in self._instances(): | |
| props = self._props(instance) | |
| if ( | |
| str(props.get("category") or "") == category | |
| and str(props.get("severity") or "") == severity | |
| and str(props.get("fingerprint") or "") == fingerprint | |
| and str(props.get("environment") or "") == environment | |
| ): | |
| return instance | |
| return None | |
| def _instances(self) -> list[generic_instance]: | |
| category, type_name, subtype, version = ANOMALY_TEMPLATE_CODE.strip("/").split( | |
| "/" | |
| ) | |
| stmt = ( | |
| select(generic_instance) | |
| .where( | |
| generic_instance.domain_code == self.domain_code, | |
| generic_instance.category == category, | |
| generic_instance.type == type_name, | |
| generic_instance.subtype == subtype, | |
| generic_instance.version == version, | |
| generic_instance.is_deleted.is_(False), | |
| ) | |
| .order_by(generic_instance.created_dt.desc()) | |
| ) | |
| return list(self.db.execute(stmt).scalars()) | |
| def _props(self, instance: generic_instance) -> dict[str, Any]: | |
| payload = instance.json_addl or {} | |
| if not isinstance(payload, dict): | |
| payload = {} | |
| properties = payload.get("properties") | |
| if not isinstance(properties, dict): | |
| properties = {} | |
| payload["properties"] = properties | |
| instance.json_addl = payload | |
| return properties | |
| def _write_props( | |
| self, instance: generic_instance, properties: dict[str, Any] | |
| ) -> None: | |
| payload = instance.json_addl or {} | |
| if not isinstance(payload, dict): | |
| payload = {} | |
| payload["properties"] = properties | |
| instance.json_addl = payload | |
| if hasattr(instance, "_sa_instance_state"): | |
| flag_modified(instance, "json_addl") | |
| def _to_record(self, instance: generic_instance) -> AnomalyRecord: | |
| props = self._props(instance) | |
| return AnomalyRecord( | |
| id=str(instance.euid), | |
| service=str(props.get("service") or "bloom"), | |
| environment=str( | |
| props.get("environment") or (get_settings().environment or "unknown") | |
| ), | |
| category=str(props.get("category") or "unknown"), | |
| severity=str(props.get("severity") or "unknown"), | |
| fingerprint=str(props.get("fingerprint") or ""), | |
| summary=str(props.get("summary") or ""), | |
| first_seen_at=str(props.get("first_seen_at") or ""), | |
| last_seen_at=str(props.get("last_seen_at") or ""), | |
| occurrence_count=_safe_int(props.get("occurrence_count")), | |
| redacted_context=_safe_redacted_context(props.get("redacted_context")), | |
| source_view_url=f"/admin/anomalies/{instance.euid}", | |
| ) | |
| def _safe_int(value: Any) -> int: | |
| try: | |
| return int(value) | |
| except (TypeError, ValueError): | |
| return 0 | |
| def _safe_redacted_context(value: Any) -> dict[str, Any]: | |
| if isinstance(value, dict): | |
| return dict(value) | |
| if value is None: | |
| return {} | |
| if isinstance(value, str) and not value.strip(): | |
| return {} | |
| if isinstance(value, (list, tuple)) and not value: | |
| return {} | |
| return {"value": redact_context(value)} | |
| def open_anomaly_repository(*, app_username: str): | |
| from bloom_lims.tapdb_adapter import BLOOMdb3 | |
| bdb = BLOOMdb3(app_username=app_username) | |
| return TapdbAnomalyRepository(bdb.session), bdb | |
Xet Storage Details
- Size:
- 9.67 kB
- Xet hash:
- 81c76c84734b1dca03e4c07abf3710429f8f6cf2bd21c23a8284f3c4ecc8366e
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.