agentmetrics-hermes 0.2.0__tar.gz

agentmetrics_hermes-0.2.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: agentmetrics-hermes
+Version: 0.2.0
+Summary: AgentMetrics observability plugin for Hermes agents
+Author-email: AndaLabX <anda@andalabx.com>
+License: MIT
+Project-URL: Homepage, https://github.com/andalabx/agentmetrics
+Project-URL: Repository, https://github.com/andalabx/agentmetrics.git
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: agentmetrics-shared>=0.2.0
+Provides-Extra: crypto
+Requires-Dist: cryptography>=41.0; extra == "crypto"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.11.0; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: hypothesis>=6.0; extra == "dev"
+
+# agentmetrics-hermes
+
+[![PyPI](https://img.shields.io/pypi/v/agentmetrics-hermes?color=6366f1&label=pypi&logo=python&logoColor=white)](https://pypi.org/project/agentmetrics-hermes)
+[![License: MIT](https://img.shields.io/badge/license-MIT-6366f1)](../../LICENSE)
+
+AgentMetrics observability plugin for [Hermes](https://github.com/andalabx/hermes) agents. Auto-discovered via the `hermes_agent.plugins` entry-point — no code changes needed.
+
+---
+
+## Install
+
+```bash
+pip install agentmetrics-hermes
+```
+
+---
+
+## Configuration
+
+Create `~/.config/hermes/agentmetrics.yaml`:
+
+```yaml
+api_key: am_your_key
+server_url: http://localhost:4000
+agent_id: my-hermes-agent
+environment: production
+```
+
+Or set environment variables (take precedence over the file):
+
+| Variable | Description |
+|---|---|
+| `AGENTMETRICS_API_KEY` | API key |
+| `AGENTMETRICS_SERVER_URL` | Server URL |
+| `AGENTMETRICS_AGENT_ID` | Agent identifier |
+| `AGENTMETRICS_ENVIRONMENT` | Deployment environment |
+
+---
+
+## What gets tracked
+
+| Metric | Description |
+|---|---|
+| `input_tokens` / `output_tokens` | Aggregated LLM token usage |
+| `cache_read_tokens` / `cache_write_tokens` | Prompt cache statistics |
+| `estimated_cost_usd` | Computed from model pricing |
+| `duration_ms` | Session wall-clock time |
+| `tool_calls` / `tool_errors` | Per-step tool tracking |
+| `llm_calls` | Number of model API requests |
+| `secrets_blocked_count` | Credentials redacted before transmission |
+| `error` | Exception message on failure (secrets scrubbed) |
+
+---
+
+## Durability
+
+Events are written to a local WAL before transmission. If the server is unreachable the plugin retries automatically via an internal circuit breaker. Events that exhaust all retries go to a dead-letter queue and are surfaced as `audit_dlq_alert` events.
+
+---
+
+## Security
+
+All event payloads are scanned for API keys, JWTs, and passwords before transmission. Set `redaction_mode: debug` in the config to disable scrubbing during local development (expires automatically after a configurable TTL).
+
+---
+
+## License
+
+[MIT](../../LICENSE)

agentmetrics_hermes-0.2.0/README.md

@@ -0,0 +1,69 @@
+# agentmetrics-hermes
+
+[![PyPI](https://img.shields.io/pypi/v/agentmetrics-hermes?color=6366f1&label=pypi&logo=python&logoColor=white)](https://pypi.org/project/agentmetrics-hermes)
+[![License: MIT](https://img.shields.io/badge/license-MIT-6366f1)](../../LICENSE)
+
+AgentMetrics observability plugin for [Hermes](https://github.com/andalabx/hermes) agents. Auto-discovered via the `hermes_agent.plugins` entry-point — no code changes needed.
+
+---
+
+## Install
+
+```bash
+pip install agentmetrics-hermes
+```
+
+---
+
+## Configuration
+
+Create `~/.config/hermes/agentmetrics.yaml`:
+
+```yaml
+api_key: am_your_key
+server_url: http://localhost:4000
+agent_id: my-hermes-agent
+environment: production
+```
+
+Or set environment variables (take precedence over the file):
+
+| Variable | Description |
+|---|---|
+| `AGENTMETRICS_API_KEY` | API key |
+| `AGENTMETRICS_SERVER_URL` | Server URL |
+| `AGENTMETRICS_AGENT_ID` | Agent identifier |
+| `AGENTMETRICS_ENVIRONMENT` | Deployment environment |
+
+---
+
+## What gets tracked
+
+| Metric | Description |
+|---|---|
+| `input_tokens` / `output_tokens` | Aggregated LLM token usage |
+| `cache_read_tokens` / `cache_write_tokens` | Prompt cache statistics |
+| `estimated_cost_usd` | Computed from model pricing |
+| `duration_ms` | Session wall-clock time |
+| `tool_calls` / `tool_errors` | Per-step tool tracking |
+| `llm_calls` | Number of model API requests |
+| `secrets_blocked_count` | Credentials redacted before transmission |
+| `error` | Exception message on failure (secrets scrubbed) |
+
+---
+
+## Durability
+
+Events are written to a local WAL before transmission. If the server is unreachable the plugin retries automatically via an internal circuit breaker. Events that exhaust all retries go to a dead-letter queue and are surfaced as `audit_dlq_alert` events.
+
+---
+
+## Security
+
+All event payloads are scanned for API keys, JWTs, and passwords before transmission. Set `redaction_mode: debug` in the config to disable scrubbing during local development (expires automatically after a configurable TTL).
+
+---
+
+## License
+
+[MIT](../../LICENSE)

agentmetrics_hermes-0.2.0/agentmetrics_hermes/__init__.py

@@ -0,0 +1,162 @@
+"""AgentMetrics observability plugin for Hermes Agent.
+
+Drop-in Python plugin for Hermes' native plugin system. After installation:
+
+    pip install agentmetrics-hermes
+
+Add to your Hermes config.yaml:
+
+    plugins:
+      agentmetrics:
+        enabled: true
+        endpoint: http://localhost:8099
+        api_key: am_your_key_here
+      enabled:
+        - observability/agentmetrics
+
+Events flow automatically from the next gateway restart.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any
+
+from .client import AgentMetricsClient
+from .config import AgentMetricsConfig
+from .hooks import AgentMetricsHooks
+from .pipeline import EventPipeline
+from .state import StateStore
+from .wal import WriteAheadLog
+
+__version__ = "0.1.0"
+__all__ = ["register"]
+
+logger = logging.getLogger(__name__)
+
+# Module-level references so CLI commands can reach the live pipeline and store.
+_pipeline: EventPipeline | None = None
+_store: StateStore | None = None
+_cfg: AgentMetricsConfig | None = None
+
+_HOOK_NAMES = [
+    ("on_session_start", "on_session_start"),
+    ("on_session_end", "on_session_end"),
+    ("pre_llm_call", "pre_llm_call"),
+    ("post_llm_call", "post_llm_call"),
+    ("pre_api_request", "pre_api_request"),
+    ("post_api_request", "post_api_request"),
+    ("api_request_error", "api_request_error"),
+    ("pre_tool_call", "pre_tool_call"),
+    ("post_tool_call", "post_tool_call"),
+    # Future hooks — registered when Hermes exposes them.
+    ("on_subagent_spawn", "on_subagent_spawn"),
+    ("on_subagent_end", "on_subagent_end"),
+    ("on_skill_load", "on_skill_load"),
+    ("on_memory_write", "on_memory_write"),
+    ("on_session_search", "on_session_search"),
+    ("on_cron_start", "on_cron_start"),
+    ("on_cron_end", "on_cron_end"),
+    ("on_gateway_connect", "on_gateway_connect"),
+    ("on_gateway_disconnect", "on_gateway_disconnect"),
+    ("on_gateway_reconnect", "on_gateway_reconnect"),
+    ("on_retry", "on_retry"),
+    ("on_timeout", "on_timeout"),
+    ("on_cancel", "on_cancel"),
+    ("on_failure", "on_failure"),
+    ("on_before_compaction", "on_before_compaction"),
+    ("on_before_reset", "on_before_reset"),
+]
+
+
+def register(ctx: Any) -> None:
+    """Hermes plugin entry point. Called once by the gateway on startup."""
+    global _pipeline, _store, _cfg
+
+    cfg = AgentMetricsConfig.load()
+
+    if not cfg.enabled:
+        logger.info("agentmetrics: disabled — set plugins.agentmetrics.enabled=true")
+        return
+
+    if not cfg.api_key:
+        logger.warning(
+            "agentmetrics: no API key configured — set AGENTMETRICS_API_KEY or "
+            "plugins.agentmetrics.api_key in config.yaml"
+        )
+        return
+
+    hermes_home = os.environ.get("HERMES_HOME") or os.path.join(
+        os.environ.get("HOME") or os.path.expanduser("~"), ".hermes"
+    )
+    wal_path = os.path.join(hermes_home, "agentmetrics-wal.jsonl")
+    dlq_path = os.path.join(hermes_home, "agentmetrics-dlq.json")
+
+    wal = WriteAheadLog.from_api_key(wal_path, cfg.api_key)
+
+    # Recover any events that were queued but not flushed before last shutdown.
+    recovered = wal.recover()
+
+    client = AgentMetricsClient(cfg)
+    store = StateStore()
+    pipeline = EventPipeline(cfg, client, wal, dlq_path)
+    pipeline.start()
+
+    if recovered:
+        logger.info("agentmetrics: recovering %d event(s) from WAL", len(recovered))
+        from .pipeline import QueueItem
+
+        for event in recovered:
+            pipeline._queue.put_nowait(QueueItem(event=event))
+        pipeline.emit_audit("wal_recovery", {"recovered_count": len(recovered)})
+
+    hooks = AgentMetricsHooks(cfg, pipeline, store)
+
+    registered = 0
+    for hermes_hook, method_name in _HOOK_NAMES:
+        handler = getattr(hooks, method_name, None)
+        if handler is None:
+            continue
+        try:
+            ctx.register_hook(hermes_hook, handler)
+            registered += 1
+        except Exception:
+            # Hermes may not expose all hooks yet — skip unknown ones silently.
+            pass
+
+    # Register CLI commands via Hermes plugin API when available.
+    _register_cli(ctx, cfg, pipeline, store)
+
+    # Store for CLI/introspection access.
+    _pipeline = pipeline
+    _store = store
+    _cfg = cfg
+
+    logger.info(
+        "agentmetrics: plugin registered — %d hooks active, %d WAL event(s) recovered",
+        registered,
+        len(recovered),
+    )
+
+
+def _register_cli(ctx: Any, cfg: AgentMetricsConfig, pipeline: EventPipeline, store: StateStore) -> None:
+    """Register `agentmetrics <command>` in Hermes CLI when the API supports it."""
+    from . import cli
+
+    commands = {
+        "status": lambda **_: cli.cmd_status(cfg, pipeline, store),
+        "flush": lambda **_: cli.cmd_flush(pipeline),
+        "tail": lambda **_: cli.cmd_tail(store),
+        "test": lambda **_: cli.cmd_test(cfg),
+        "redaction-check": lambda **_: cli.cmd_redaction_check(cfg),
+        "drain": lambda **_: cli.cmd_drain(pipeline),
+        "cost": lambda **_: cli.cmd_cost(cfg, pipeline),
+    }
+
+    for name, handler in commands.items():
+        try:
+            ctx.register_command(f"agentmetrics {name}", handler)
+        except (AttributeError, TypeError):
+            # Hermes version without register_command — CLI commands unavailable until updated.
+            break

agentmetrics_hermes-0.2.0/agentmetrics_hermes/cli.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .config import AgentMetricsConfig
+    from .pipeline import EventPipeline
+    from .state import StateStore
+
+
+def cmd_status(cfg: AgentMetricsConfig, pipeline: EventPipeline, store: StateStore) -> str:
+    """Report plugin health, config, and live counters."""
+    key_preview = (cfg.api_key[:8] + "..." + cfg.api_key[-4:]) if len(cfg.api_key) > 12 else "not set"
+    lines = [
+        "AgentMetrics — status",
+        f"  API key            : {key_preview}",
+        f"  Endpoint           : {cfg.endpoint}",
+        f"  Redaction          : {cfg.redaction_mode}",
+        f"  Tool names         : {cfg.exported_tool_names}",
+        f"  Compress payloads  : {cfg.compress_payloads}",
+        f"  Flush interval     : {cfg.flush_interval}s",
+        f"  Batch size         : {cfg.batch_size}",
+        "",
+        f"  Circuit breaker    : {pipeline.cb.state}",
+        f"  Queue depth        : {pipeline._queue.qsize()} / {cfg.queue_size}",
+        f"  DLQ depth          : {pipeline.dlq.depth}",
+        "",
+        f"  Sent               : {pipeline.sent}",
+        f"  Failed             : {pipeline.failed}",
+        f"  Dropped (overflow) : {pipeline.dropped}",
+    ]
+    return "\n".join(lines)
+
+
+def cmd_flush(pipeline: EventPipeline) -> str:
+    """Force-flush all queued events immediately."""
+    result = pipeline.flush_now()
+    return f"Flushed — sent: {result['sent']}, failed: {result['failed']}"
+
+
+def cmd_tail(store: StateStore) -> str:
+    """Show active sessions and runs."""
+    lines = ["AgentMetrics — active sessions"]
+    with store._lock:
+        sessions = dict(store._sessions)
+        runs = dict(store._runs)
+        active = dict(store._active_run)
+
+    if not sessions:
+        lines.append("  (no active sessions)")
+        return "\n".join(lines)
+
+    now = time.time()
+    for sk, sess in sessions.items():
+        elapsed = int(now - sess.started_at)
+        run_id = active.get(sk)
+        run = runs.get(run_id or "")
+        lines.append(f"  session: {sk[:20]}  elapsed: {elapsed}s  runs: {sess.run_count}")
+        if run:
+            run_elapsed = int(now - run.started_at)
+            lines.append(
+                f"    ↳ run: {run.run_id[:12]}  llm: {run.llm_calls}  tools: {run.tool_calls}"
+                f"  elapsed: {run_elapsed}s"
+            )
+    return "\n".join(lines)
+
+
+def cmd_test(cfg: AgentMetricsConfig) -> str:
+    """Send a test event to verify connectivity."""
+    from .client import AgentMetricsClient
+
+    client = AgentMetricsClient(cfg)
+    status, error = client.post_test_event()
+    if 200 <= status < 300:
+        return f"Delivered — HTTP {status}"
+    return f"Failed — HTTP {status}: {error}"
+
+
+def cmd_redaction_check(cfg: AgentMetricsConfig) -> str:
+    """Show what the current redaction policy does to sample data."""
+    from .redact import active_mode, redact_tool_name, scrub_secrets
+
+    mode = active_mode(cfg)
+    samples = [
+        ("OpenAI key", "sk-proj-abc123def456ghi789jkl012mno345pqr"),
+        ("AgentMetrics key", "am_R4Z5nEek123456789012345678901234"),
+        ("JWT token", "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VyMSJ9.abc123def456"),
+        ("Password in JSON", 'password: "hunter2"'),
+    ]
+    lines = [f"AgentMetrics — redaction check (mode: {mode.value})", ""]
+    lines.append("  Secret scrubbing:")
+    for label, sample in samples:
+        result = scrub_secrets(sample, mode)
+        lines.append(f"    {label}: {result}")
+
+    tool_names = ["bash", "read_file", "send_email", "web_search"]
+    lines.append("")
+    lines.append(f"  Tool name policy ({cfg.exported_tool_names}):")
+    for name in tool_names:
+        tool_result = redact_tool_name(name, cfg)
+        lines.append(f"    {name}: {tool_result or '[not exported]'}")
+
+    return "\n".join(lines)
+
+
+def cmd_drain(pipeline: EventPipeline) -> str:
+    """Retry all events in the dead-letter queue."""
+    count = pipeline.retry_dlq()
+    if count == 0:
+        return "DLQ is empty — nothing to drain"
+    return f"Retrying {count} DLQ event(s) — check `agentmetrics flush` to confirm delivery"
+
+
+def cmd_cost(cfg: AgentMetricsConfig, pipeline: EventPipeline) -> str:
+    """Display the model pricing table and any custom overrides."""
+    from .pricing import MODEL_PRICING
+
+    lines = ["AgentMetrics — pricing table (per million tokens, USD)", ""]
+    lines.append(f"  {'Model':<30} {'Input':>8} {'Output':>8} {'CR':>8} {'CW':>8}")
+    lines.append("  " + "-" * 66)
+    for model, prices in MODEL_PRICING.items():
+        inp = f"${prices[0]:.3f}" if prices[0] is not None else "—"
+        out = f"${prices[1]:.3f}" if prices[1] is not None else "—"
+        cr = f"${prices[2]:.3f}" if prices[2] is not None else "—"
+        cw = f"${prices[3]:.3f}" if prices[3] is not None else "—"
+        lines.append(f"  {model:<30} {inp:>8} {out:>8} {cr:>8} {cw:>8}")
+
+    if cfg.cost_provider_table:
+        lines.append("")
+        lines.append("  Custom overrides:")
+        for model, prices in cfg.cost_provider_table.items():
+            lines.append(f"    {model}: {prices}")
+
+    return "\n".join(lines)

agentmetrics_hermes-0.2.0/agentmetrics_hermes/client.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import gzip
+import json
+import logging
+import urllib.error
+import urllib.request
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .config import AgentMetricsConfig
+
+logger = logging.getLogger(__name__)
+
+_CONNECT_TIMEOUT = 5   # seconds
+_READ_TIMEOUT = 15     # seconds
+_MAX_PAYLOAD_BYTES = 10 * 1024 * 1024  # 10 MB hard cap per batch (DoS guard)
+
+
+class AgentMetricsClient:
+    """HTTP transport for the AgentMetrics ingest API. Uses stdlib urllib — no extra deps."""
+
+    def __init__(self, cfg: AgentMetricsConfig) -> None:
+        self._endpoint = cfg.endpoint.rstrip("/")
+        self._api_key = cfg.api_key
+        self._compress = cfg.compress_payloads
+
+    def post_events(self, payloads: list[dict[str, Any]]) -> tuple[int, str]:
+        """POST a batch of event dicts to /v1/events. Returns (status_code, error_message)."""
+        url = f"{self._endpoint}/v1/events"
+        body = json.dumps(payloads).encode()
+
+        if len(body) > _MAX_PAYLOAD_BYTES:
+            logger.warning(
+                "agentmetrics: batch payload %d bytes exceeds %d byte cap — dropping",
+                len(body),
+                _MAX_PAYLOAD_BYTES,
+            )
+            return 413, "payload too large"
+
+        headers = self._headers()
+        if self._compress and len(body) > 1024:
+            body = gzip.compress(body)
+            headers["Content-Encoding"] = "gzip"
+        headers["Content-Length"] = str(len(body))
+
+        req = urllib.request.Request(url, data=body, headers=headers, method="POST")
+        try:
+            with urllib.request.urlopen(
+                req, timeout=max(_CONNECT_TIMEOUT, _READ_TIMEOUT)
+            ) as resp:
+                return resp.status, ""
+        except urllib.error.HTTPError as exc:
+            return exc.code, str(exc.reason)
+        except urllib.error.URLError as exc:
+            return 0, str(exc.reason)
+        except TimeoutError:
+            return 0, "timeout"
+        except Exception as exc:
+            return 0, str(exc)
+
+    def post_test_event(self) -> tuple[int, str]:
+        """Send a minimal test event. Used by the `agentmetrics test` CLI command."""
+        import time
+        import uuid
+
+        payload = [
+            {
+                "event_id": str(uuid.uuid4()),
+                "event_name": "plugin_test",
+                "agent_id": "hermes",
+                "platform": "hermes",
+                "ts": int(time.time() * 1000),
+                "status": "success",
+            }
+        ]
+        return self.post_events(payload)
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            "Content-Type": "application/json",
+            "X-API-Key": self._api_key,
+            "User-Agent": "agentmetrics-hermes/0.1.0",
+        }

agentmetrics_hermes-0.2.0/agentmetrics_hermes/config.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import logging
+import os
+from dataclasses import dataclass, field
+from urllib.parse import urlparse
+
+logger = logging.getLogger(__name__)
+
+_DEFAULT_ENDPOINT = "http://localhost:8099"
+
+
+def _validate_endpoint(url: str) -> str:
+    """Reject non-HTTP/HTTPS schemes. Warn (not block) on non-HTTPS for non-localhost URLs."""
+    try:
+        parsed = urlparse(url)
+    except Exception:
+        logger.warning("agentmetrics: invalid endpoint URL, falling back to default")
+        return _DEFAULT_ENDPOINT
+    if parsed.scheme not in ("http", "https"):
+        logger.warning(
+            "agentmetrics: endpoint scheme %r is not http/https — using default", parsed.scheme
+        )
+        return _DEFAULT_ENDPOINT
+    host = parsed.hostname or ""
+    is_local = host in ("localhost", "127.0.0.1", "::1") or host.startswith("192.168.")
+    if parsed.scheme == "http" and not is_local:
+        # Warn operators who send telemetry over plain HTTP to a remote host.
+        logger.warning(
+            "agentmetrics: endpoint %r uses plain HTTP to a non-local host — "
+            "API keys and event data will be sent unencrypted. Use HTTPS in production.",
+            url,
+        )
+    return url
+
+
+@dataclass
+class AgentMetricsConfig:
+    enabled: bool = True
+    endpoint: str = _DEFAULT_ENDPOINT
+    api_key: str = ""
+    flush_interval: int = 10
+    batch_size: int = 100
+    queue_size: int = 10_000
+    retry_max_attempts: int = 5
+    redaction_mode: str = "strict"
+    exported_tool_names: str = "blocklist"
+    redact_tool_names: list[str] = field(default_factory=list)
+    compress_payloads: bool = False
+    cost_provider_table: dict[str, list[float | None]] = field(default_factory=dict)
+    debug_expires_at: float | None = None
+
+    @classmethod
+    def load(cls) -> AgentMetricsConfig:
+        """Read from Hermes config.yaml plugins.agentmetrics.* section."""
+        try:
+            from hermes_cli.config import cfg_get, load_config  # type: ignore[import-not-found]
+
+            config = load_config()
+            raw = cfg_get(config, "plugins", "agentmetrics", default={})
+            if not isinstance(raw, dict):
+                return cls(enabled=False)
+            api_key = str(
+                raw.get("api_key") or os.environ.get("AGENTMETRICS_API_KEY", "")
+            )
+            raw_endpoint = str(
+                os.environ.get("AGENTMETRICS_URL")
+                or raw.get("endpoint", _DEFAULT_ENDPOINT)
+            )
+            endpoint = _validate_endpoint(raw_endpoint)
+            return cls(
+                enabled=bool(raw.get("enabled", True)),
+                endpoint=endpoint,
+                api_key=api_key,
+                flush_interval=int(raw.get("flush_interval", cls.flush_interval)),
+                batch_size=int(raw.get("batch_size", cls.batch_size)),
+                queue_size=int(raw.get("queue_size", cls.queue_size)),
+                retry_max_attempts=int(raw.get("retry_max_attempts", cls.retry_max_attempts)),
+                redaction_mode=str(raw.get("redaction_mode", cls.redaction_mode)),
+                exported_tool_names=str(
+                    raw.get("exported_tool_names", cls.exported_tool_names)
+                ),
+                redact_tool_names=list(raw.get("redact_tool_names") or []),
+                compress_payloads=bool(raw.get("compress_payloads", False)),
+                cost_provider_table=dict(raw.get("cost_provider_table") or {}),
+            )
+        except ImportError:
+            # Hermes not installed — config comes from env vars only.
+            api_key = os.environ.get("AGENTMETRICS_API_KEY", "")
+            raw_endpoint = os.environ.get("AGENTMETRICS_URL", _DEFAULT_ENDPOINT)
+            return cls(
+                enabled=bool(api_key),
+                endpoint=_validate_endpoint(raw_endpoint),
+                api_key=api_key,
+            )
+        except Exception:
+            logger.exception("agentmetrics: failed to load config")
+            return cls(enabled=False)