svc-infra 0.1.706__py3-none-any.whl → 1.1.0__py3-none-any.whl

svc_infra/jobs/runner.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import contextlib
-from typing import Awaitable, Callable, Optional
+from collections.abc import Awaitable, Callable
 
 from .queue import JobQueue
 
@@ -16,15 +16,13 @@ class WorkerRunner:
     - stop(grace_seconds): signal stop, wait up to grace for current job to finish
     """
 
-    def __init__(
-        self, queue: JobQueue, handler: ProcessFunc, *, poll_interval: float = 0.25
-    ):
+    def __init__(self, queue: JobQueue, handler: ProcessFunc, *, poll_interval: float = 0.25):
         self._queue = queue
         self._handler = handler
         self._poll_interval = poll_interval
-        self._task: Optional[asyncio.Task] = None
+        self._task: asyncio.Task | None = None
         self._stopping = asyncio.Event()
-        self._inflight: Optional[asyncio.Task] = None
+        self._inflight: asyncio.Task | None = None
 
     async def _loop(self) -> None:
         try:
@@ -63,16 +61,14 @@ class WorkerRunner:
         if self._inflight is not None and not self._inflight.done():
             try:
                 await asyncio.wait_for(self._inflight, timeout=grace_seconds)
-            except asyncio.TimeoutError:
+            except TimeoutError:
                 # Give up; job will be retried if your queue supports visibility timeouts
                 pass
         # Finally, wait for loop to exit (should be quick since stopping is set)
         if self._task is not None:
             try:
-                await asyncio.wait_for(
-                    self._task, timeout=max(0.1, self._poll_interval + 0.1)
-                )
-            except asyncio.TimeoutError:
+                await asyncio.wait_for(self._task, timeout=max(0.1, self._poll_interval + 0.1))
+            except TimeoutError:
                 # Cancel as a last resort
                 self._task.cancel()
                 with contextlib.suppress(Exception):

svc_infra/jobs/scheduler.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-from typing import Awaitable, Callable, Dict
+from datetime import UTC, datetime, timedelta
 
 CronFunc = Callable[[], Awaitable[None]]
 
@@ -23,11 +23,11 @@ class InMemoryScheduler:
     """
 
     def __init__(self, tick_interval: float = 60.0):
-        self._tasks: Dict[str, ScheduledTask] = {}
+        self._tasks: dict[str, ScheduledTask] = {}
         self._tick_interval = tick_interval
 
     def add_task(self, name: str, interval_seconds: int, func: CronFunc) -> None:
-        now = datetime.now(timezone.utc)
+        now = datetime.now(UTC)
         self._tasks[name] = ScheduledTask(
             name=name,
             interval_seconds=interval_seconds,
@@ -36,7 +36,7 @@ class InMemoryScheduler:
         )
 
     async def tick(self) -> None:
-        now = datetime.now(timezone.utc)
+        now = datetime.now(UTC)
         for task in self._tasks.values():
             if task.next_run_at <= now:
                 await task.func()

svc_infra/jobs/worker.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 import os
-from typing import Awaitable, Callable
+from collections.abc import Awaitable, Callable
 
 from .queue import Job, JobQueue
 

svc_infra/loaders/base.py

@@ -8,7 +8,8 @@ from __future__ import annotations
 import asyncio
 import logging
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, AsyncIterator, Literal
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Literal
 
 if TYPE_CHECKING:
     from .models import LoadedContent
@@ -57,7 +58,7 @@ class BaseLoader(ABC):
         self.on_error = on_error
 
     @abstractmethod
-    async def load(self) -> list["LoadedContent"]:
+    async def load(self) -> list[LoadedContent]:
         """Load all content from the source.
 
         This is the main method that subclasses must implement.
@@ -70,7 +71,7 @@ class BaseLoader(ABC):
         """
         ...
 
-    async def aiter(self) -> AsyncIterator["LoadedContent"]:
+    async def aiter(self) -> AsyncIterator[LoadedContent]:
         """Iterate over loaded content asynchronously.
 
         This is useful for progress tracking or streaming large datasets.
@@ -88,7 +89,7 @@ class BaseLoader(ABC):
         for content in await self.load():
             yield content
 
-    def load_sync(self) -> list["LoadedContent"]:
+    def load_sync(self) -> list[LoadedContent]:
         """Synchronous wrapper for load().
 
         Creates a new event loop if needed. Prefer the async version

svc_infra/loaders/github.py

@@ -142,9 +142,7 @@ class GitHubLoader(BaseLoader):
 
         # Validate repo format
         if "/" not in repo or repo.count("/") != 1:
-            raise ValueError(
-                f"Invalid repo format: {repo!r}. Expected 'owner/repo' format."
-            )
+            raise ValueError(f"Invalid repo format: {repo!r}. Expected 'owner/repo' format.")
 
         self.repo = repo
         self.path = path.strip("/")

svc_infra/loaders/url.py

@@ -97,9 +97,7 @@ class URLLoader(BaseLoader):
         # Validate URLs
         for url in self.urls:
             if not url.startswith(("http://", "https://")):
-                raise ValueError(
-                    f"Invalid URL: {url!r}. URLs must start with http:// or https://"
-                )
+                raise ValueError(f"Invalid URL: {url!r}. URLs must start with http:// or https://")
 
     async def load(self) -> list[LoadedContent]:
         """Load content from all URLs.
@@ -132,9 +130,7 @@ class URLLoader(BaseLoader):
                         content = raw_content
 
                     # Parse content type (remove charset etc.)
-                    mime_type = (
-                        content_type.split(";")[0].strip() if content_type else None
-                    )
+                    mime_type = content_type.split(";")[0].strip() if content_type else None
 
                     loaded = LoadedContent(
                         content=content,
@@ -183,9 +179,7 @@ class URLLoader(BaseLoader):
             soup = BeautifulSoup(html, "html.parser")
 
             # Remove non-content elements
-            for tag in soup(
-                ["script", "style", "nav", "footer", "header", "aside", "noscript"]
-            ):
+            for tag in soup(["script", "style", "nav", "footer", "header", "aside", "noscript"]):
                 tag.decompose()
 
             # Get text with newlines preserved

svc_infra/logging/__init__.py

@@ -31,9 +31,10 @@ import json
 import logging
 import os
 import sys
+from collections.abc import Iterator
 from contextlib import contextmanager
-from datetime import datetime, timezone
-from typing import Any, Iterator, Optional
+from datetime import UTC, datetime
+from typing import Any
 
 # Context variables for structured logging
 _log_context: contextvars.ContextVar[dict[str, Any]] = contextvars.ContextVar(
@@ -89,7 +90,7 @@ class JsonFormatter(logging.Formatter):
         """Format a log record as JSON."""
         # Base log structure
         log_dict: dict[str, Any] = {
-            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "timestamp": datetime.now(UTC).isoformat(),
             "level": record.levelname,
             "logger": record.name,
             "message": record.getMessage(),
@@ -149,7 +150,7 @@ class TextFormatter(logging.Formatter):
 
     def format(self, record: logging.LogRecord) -> str:
         """Format a log record as human-readable text."""
-        timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
+        timestamp = datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S")
         base = f"{timestamp} [{record.levelname}] {record.name}: {record.getMessage()}"
 
         # Add context if present
@@ -166,8 +167,8 @@ class TextFormatter(logging.Formatter):
 
 
 def configure_for_container(
-    level: Optional[str] = None,
-    json_format: Optional[bool] = None,
+    level: str | None = None,
+    json_format: bool | None = None,
     stream: Any = None,
 ) -> None:
     """

svc_infra/mcp/__init__.py

@@ -0,0 +1,82 @@
+"""MCP (Model Context Protocol) server for svc-infra CLI.
+
+This module provides an MCP server that exposes svc-infra CLI commands as tools
+for AI assistants and agents.
+
+Available Tools:
+    - svc_infra_cmd_help: Get help text for the svc-infra CLI
+    - svc_infra_subcmd_help: Get help for specific subcommands
+    - svc_infra_docs_help: Get documentation help
+
+Example:
+    # Run the MCP server
+    python -m svc_infra.mcp.svc_infra_mcp
+
+    # Or use programmatically
+    from svc_infra.mcp import mcp, Subcommand, svc_infra_subcmd_help
+
+    # Get help for a subcommand
+    result = await svc_infra_subcmd_help(Subcommand.sql_upgrade)
+
+See Also:
+    - ai-infra MCP documentation for client usage
+    - svc-infra CLI reference for available commands
+
+Note:
+    This module requires ai-infra to be installed. If ai-infra is not available,
+    imports will raise ImportError with a helpful message.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .svc_infra_mcp import (
+        CLI_PROG as CLI_PROG,
+    )
+    from .svc_infra_mcp import (
+        Subcommand as Subcommand,
+    )
+    from .svc_infra_mcp import (
+        mcp as mcp,
+    )
+    from .svc_infra_mcp import (
+        svc_infra_cmd_help as svc_infra_cmd_help,
+    )
+    from .svc_infra_mcp import (
+        svc_infra_docs_help as svc_infra_docs_help,
+    )
+    from .svc_infra_mcp import (
+        svc_infra_subcmd_help as svc_infra_subcmd_help,
+    )
+
+__all__ = [
+    # MCP server instance
+    "mcp",
+    # Subcommand enum
+    "Subcommand",
+    # Tool functions
+    "svc_infra_cmd_help",
+    "svc_infra_subcmd_help",
+    "svc_infra_docs_help",
+    # Constants
+    "CLI_PROG",
+]
+
+
+def __getattr__(name: str):
+    """Lazy import to defer ai-infra dependency until runtime."""
+    if name in __all__:
+        try:
+            from . import svc_infra_mcp
+
+            return getattr(svc_infra_mcp, name)
+        except ImportError as e:
+            if "ai_infra" in str(e):
+                raise ImportError(
+                    f"Cannot import '{name}' from svc_infra.mcp: "
+                    "ai-infra package is required. Install with: pip install ai-infra"
+                ) from e
+            raise
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

svc_infra/mcp/svc_infra_mcp.py

@@ -18,7 +18,7 @@ async def svc_infra_cmd_help() -> dict[Any, Any]:
     - Prepares project env without chdir (so we can 'cd' in the command itself).
     - Tries poetry → console script → python -m svc_infra.cli_shim.
     """
-    return cast(dict[Any, Any], await cli_cmd_help(CLI_PROG))
+    return cast("dict[Any, Any]", await cli_cmd_help(CLI_PROG))
 
 
 # No dedicated 'docs list' function — users can use 'docs --help' to discover topics.
@@ -97,7 +97,7 @@ async def svc_infra_subcmd_help(subcommand: Subcommand) -> dict[Any, Any]:
     """
     tokens = subcommand.value.split()
     if len(tokens) == 1:
-        return cast(dict[Any, Any], await cli_subcmd_help(CLI_PROG, subcommand))
+        return cast("dict[Any, Any]", await cli_subcmd_help(CLI_PROG, subcommand))
 
     root = prepare_env()
     text = await run_from_root(root, CLI_PROG, [*tokens, "--help"])

svc_infra/obs/add.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Any, Callable, Iterable, Optional, Protocol
+from collections.abc import Callable, Iterable
+from typing import Any, Protocol
 
 from svc_infra.obs.settings import ObservabilitySettings
 
@@ -19,9 +20,9 @@ class RouteClassifier(Protocol):
 def add_observability(
     app: Any | None = None,
     *,
-    db_engines: Optional[Iterable[Any]] = None,
+    db_engines: Iterable[Any] | None = None,
     metrics_path: str | None = None,
-    skip_metric_paths: Optional[Iterable[str]] = None,
+    skip_metric_paths: Iterable[str] | None = None,
     route_classifier: RouteClassifier | None = None,
 ) -> Callable[[], None]:
     """

svc_infra/obs/cloud_dash.py

@@ -87,7 +87,7 @@ def _rewrite_rate_windows(d: dict) -> dict:
     if not win:
         return d
 
-    dd = cast(dict[Any, Any], json.loads(json.dumps(d)))
+    dd = cast("dict[Any, Any]", json.loads(json.dumps(d)))
     for p in dd.get("panels", []) or []:
         targets = p.get("targets") or []
         for t in targets:

svc_infra/obs/metrics/__init__.py

@@ -6,7 +6,7 @@ plug in logging or a metrics backend without a hard dependency.
 
 from __future__ import annotations
 
-from typing import Callable, Optional
+from collections.abc import Callable
 
 # Function variables so applications/tests can replace them at runtime.
 on_rate_limit_exceeded: Callable[[str, int, int], None] | None = None
@@ -18,7 +18,7 @@ Args:
     retry_after: seconds until next allowed attempt
 """
 
-on_suspect_payload: Callable[[Optional[str], int], None] | None = None
+on_suspect_payload: Callable[[str | None, int], None] | None = None
 """
 Called when a request exceeds the configured size limit.
 Args:
@@ -36,7 +36,7 @@ def emit_rate_limited(key: str, limit: int, retry_after: int) -> None:
             pass
 
 
-def emit_suspect_payload(path: Optional[str], size: int) -> None:
+def emit_suspect_payload(path: str | None, size: int) -> None:
     if on_suspect_payload:
         try:
             on_suspect_payload(path, size)

svc_infra/obs/metrics/asgi.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 import os
 import time
-from typing import Any, Callable, Iterable, Optional, cast
+from collections.abc import Callable, Iterable
+from typing import Any, cast
 
 from starlette.requests import Request
 from starlette.responses import PlainTextResponse, Response
@@ -97,9 +98,9 @@ def _init_metrics() -> None:
 def _route_template(req: Request) -> str:
     route = getattr(req, "scope", {}).get("route")
     if route and hasattr(route, "path_format"):
-        return cast(str, route.path_format)
+        return cast("str", route.path_format)
     if route and hasattr(route, "path"):
-        return cast(str, route.path)
+        return cast("str", route.path)
     return req.url.path or "/*unmatched*"
 
 
@@ -115,8 +116,8 @@ class PrometheusMiddleware:
         self,
         app: ASGIApp,
         *,
-        skip_paths: Optional[Iterable[str]] = None,
-        route_resolver: Optional[Callable[[Request], str]] = None,
+        skip_paths: Iterable[str] | None = None,
+        route_resolver: Callable[[Request], str] | None = None,
     ):
         self.app = app
         self.skip_paths = tuple(skip_paths or ("/metrics",))
@@ -186,13 +187,9 @@ class PrometheusMiddleware:
                     if _http_requests_total:
                         _http_requests_total.labels(method, route_for_stats, code).inc()
                     if _http_request_duration:
-                        _http_request_duration.labels(route_for_stats, method).observe(
-                            elapsed
-                        )
+                        _http_request_duration.labels(route_for_stats, method).observe(elapsed)
                     if _http_response_size:
-                        _http_response_size.labels(route_for_stats, method).observe(
-                            bytes_sent
-                        )
+                        _http_response_size.labels(route_for_stats, method).observe(bytes_sent)
                 except Exception:
                     pass
                 try:
@@ -241,9 +238,7 @@ def metrics_endpoint():
         return handler
 
 
-def add_prometheus(
-    app, *, path: str = "/metrics", skip_paths: Optional[Iterable[str]] = None
-):
+def add_prometheus(app, *, path: str = "/metrics", skip_paths: Iterable[str] | None = None):
     """Convenience for FastAPI/Starlette apps."""
     # Add middleware
     app.add_middleware(

svc_infra/obs/metrics/base.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import importlib
-from typing import Iterable, Optional
+from collections.abc import Iterable
 
 
 class _MissingPrometheus(Exception):
@@ -31,8 +31,8 @@ def registry():
     import os
 
     prom = _prom_mod()
-    REGISTRY = getattr(prom, "REGISTRY")
-    CollectorRegistry = getattr(prom, "CollectorRegistry")
+    REGISTRY = prom.REGISTRY
+    CollectorRegistry = prom.CollectorRegistry
     multiprocess = getattr(prom, "multiprocess", None)
 
     if os.environ.get("PROMETHEUS_MULTIPROC_DIR") and multiprocess is not None:
@@ -46,14 +46,14 @@ def _mk_metric(
     ctor_name: str,
     name: str,
     doc: str,
-    labels: Optional[Iterable[str]] = None,
+    labels: Iterable[str] | None = None,
     **kwargs,
 ):
     prom = _prom_mod()
-    Counter = getattr(prom, "Counter")
-    Gauge = getattr(prom, "Gauge")
-    Histogram = getattr(prom, "Histogram")
-    Summary = getattr(prom, "Summary")
+    Counter = prom.Counter
+    Gauge = prom.Gauge
+    Histogram = prom.Histogram
+    Summary = prom.Summary
 
     ctors = {
         "Counter": Counter,
@@ -67,11 +67,11 @@ def _mk_metric(
     return metric
 
 
-def counter(name: str, doc: str, labels: Optional[Iterable[str]] = None):
+def counter(name: str, doc: str, labels: Iterable[str] | None = None):
     return _mk_metric("Counter", name, doc, labels)
 
 
-def gauge(name: str, doc: str, labels: Optional[Iterable[str]] = None, **kw):
+def gauge(name: str, doc: str, labels: Iterable[str] | None = None, **kw):
     # e.g. gauge(..., multiprocess_mode="livesum")
     return _mk_metric("Gauge", name, doc, labels, **kw)
 
@@ -79,8 +79,8 @@ def gauge(name: str, doc: str, labels: Optional[Iterable[str]] = None, **kw):
 def histogram(
     name: str,
     doc: str,
-    labels: Optional[Iterable[str]] = None,
-    buckets: Optional[Iterable[float]] = None,
+    labels: Iterable[str] | None = None,
+    buckets: Iterable[float] | None = None,
 ):
     kwargs = {"buckets": list(buckets) if buckets else None}
     # Remove None so prometheus-client uses its defaults
@@ -88,5 +88,5 @@ def histogram(
     return _mk_metric("Histogram", name, doc, labels, **kwargs)
 
 
-def summary(name: str, doc: str, labels: Optional[Iterable[str]] = None):
+def summary(name: str, doc: str, labels: Iterable[str] | None = None):
     return _mk_metric("Summary", name, doc, labels)

svc_infra/obs/metrics/http.py

@@ -51,7 +51,7 @@ def instrument_requests():
             _http_client_total.labels(host, method_u, code).inc()
             _http_client_duration.labels(host, method_u).observe(elapsed)
 
-    setattr(requests.sessions.Session, "request", _wrapped)
+    requests.sessions.Session.request = _wrapped  # type: ignore[method-assign]
 
 
 def instrument_httpx():
@@ -74,9 +74,7 @@ def instrument_httpx():
                 raise
             finally:
                 _http_client_total.labels(host, method, code).inc()
-                _http_client_duration.labels(host, method).observe(
-                    time.perf_counter() - start
-                )
+                _http_client_duration.labels(host, method).observe(time.perf_counter() - start)
 
         return _wrapped
 
@@ -93,9 +91,7 @@ def instrument_httpx():
             raise
         finally:
             _http_client_total.labels(host, method, code).inc()
-            _http_client_duration.labels(host, method).observe(
-                time.perf_counter() - start
-            )
+            _http_client_duration.labels(host, method).observe(time.perf_counter() - start)
 
-    setattr(httpx.Client, "send", _wrap_sync_send(_orig_sync))
-    setattr(httpx.AsyncClient, "send", _wrapped_async)
+    httpx.Client.send = _wrap_sync_send(_orig_sync)  # type: ignore[method-assign]
+    httpx.AsyncClient.send = _wrapped_async  # type: ignore[method-assign]

svc_infra/obs/metrics/sqlalchemy.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Any, Mapping, Optional
+from collections.abc import Mapping
+from typing import Any
 
 from sqlalchemy.engine import Engine
 
@@ -23,20 +24,16 @@ _pool_available = gauge(
     labels=["db"],
     multiprocess_mode="livesum",
 )
-_pool_checked_out_total = counter(
-    "db_pool_checkedout_total", "Total checkouts", labels=["db"]
-)
-_pool_checked_in_total = counter(
-    "db_pool_checkedin_total", "Total checkins", labels=["db"]
-)
+_pool_checked_out_total = counter("db_pool_checkedout_total", "Total checkouts", labels=["db"])
+_pool_checked_in_total = counter("db_pool_checkedin_total", "Total checkins", labels=["db"])
 
 
-def _label(labels: Optional[Mapping[str, str]]) -> str:
+def _label(labels: Mapping[str, str] | None) -> str:
     return (labels or {}).get("db", "default")
 
 
 def bind_sqlalchemy_pool_metrics(
-    engine: Engine | Any, labels: Optional[Mapping[str, str]] = None
+    engine: Engine | Any, labels: Mapping[str, str] | None = None
 ) -> None:
     """Bind event listeners for pool metrics. Works for sync Engine.
     For AsyncEngine pass engine.sync_engine."""
@@ -46,7 +43,7 @@ def bind_sqlalchemy_pool_metrics(
     from sqlalchemy import event
 
     @event.listens_for(sync_engine, "engine_connect")
-    def _(conn, branch):  # noqa
+    def _(conn, branch):
         # Update gauges on engine_connect as a cheap heartbeat
         pool = sync_engine.pool
         try:
@@ -56,7 +53,7 @@ def bind_sqlalchemy_pool_metrics(
             pass
 
     @event.listens_for(sync_engine, "checkout")
-    def _checkout(dbapi_con, con_record, con_proxy):  # noqa
+    def _checkout(dbapi_con, con_record, con_proxy):
         _pool_checked_out_total.labels(label).inc()
         try:
             pool = sync_engine.pool
@@ -66,7 +63,7 @@ def bind_sqlalchemy_pool_metrics(
             pass
 
     @event.listens_for(sync_engine, "checkin")
-    def _checkin(dbapi_con, con_record):  # noqa
+    def _checkin(dbapi_con, con_record):
         _pool_checked_in_total.labels(label).inc()
         try:
             pool = sync_engine.pool

svc_infra/obs/metrics.py

@@ -7,7 +7,7 @@ functions.
 
 from __future__ import annotations
 
-from typing import Callable, Optional
+from collections.abc import Callable
 
 # Function variables so applications/tests can replace them at runtime.
 on_rate_limit_exceeded: Callable[[str, int, int], None] | None = None
@@ -19,7 +19,7 @@ Args:
     retry_after: seconds until next allowed attempt
 """
 
-on_suspect_payload: Callable[[Optional[str], int], None] | None = None
+on_suspect_payload: Callable[[str | None, int], None] | None = None
 """
 Called when a request exceeds the configured size limit.
 Args:
@@ -37,7 +37,7 @@ def emit_rate_limited(key: str, limit: int, retry_after: int) -> None:
             pass
 
 
-def emit_suspect_payload(path: Optional[str], size: int) -> None:
+def emit_suspect_payload(path: str | None, size: int) -> None:
     if on_suspect_payload:
         try:
             on_suspect_payload(path, size)

svc_infra/obs/settings.py

@@ -14,12 +14,8 @@ class ObservabilitySettings(BaseSettings):
       - METRICS_DEFAULT_BUCKETS=comma-separated seconds (optional)
     """
 
-    METRICS_ENABLED: bool = Field(
-        default=True, description="Enable Prometheus metrics exposure"
-    )
-    METRICS_PATH: str = Field(
-        default="/metrics", description="HTTP path for metrics endpoint"
-    )
+    METRICS_ENABLED: bool = Field(default=True, description="Enable Prometheus metrics exposure")
+    METRICS_PATH: str = Field(default="/metrics", description="HTTP path for metrics endpoint")
     METRICS_DEFAULT_BUCKETS: tuple[float, ...] = Field(
         default=(0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.0, 5.0, 10.0),
         description="Default histogram buckets (seconds)",