hyperfluid 0.1.0__py3-none-any.whl

hyperfluid/api/monitoring.py

@@ -0,0 +1,1080 @@
+# this file is @generated
+"""Monitoring API."""
+
+from __future__ import annotations
+
+import functools
+import typing as t
+from uuid import UUID
+
+from .. import models as _models
+from ..models import (
+    LogLevel,
+    LogStream,
+    MetricsRange,
+    NextflowPodRole,
+    ResourceLogsResponse,
+    ResourceMetricsResponse,
+    SearchMode,
+)
+from ..serialization import UNSET, Unset
+from ._response import async_to_raw_response_wrapper, to_raw_response_wrapper
+from .common import (
+    ApiBaseAsync,
+    ApiBaseSync,
+    ApiRequest,
+    Timeout,
+    decode_response,
+    encode_path_param,
+    serialize_query_params,
+)
+from .monitoring_bifrost import (
+    AsyncMonitoringBifrost,
+    AsyncMonitoringBifrostWithRawResponse,
+    MonitoringBifrost,
+    MonitoringBifrostWithRawResponse,
+)
+from .monitoring_compute_docks import (
+    AsyncMonitoringComputeDocks,
+    AsyncMonitoringComputeDocksWithRawResponse,
+    MonitoringComputeDocks,
+    MonitoringComputeDocksWithRawResponse,
+)
+from .monitoring_container_apps import (
+    AsyncMonitoringContainerApps,
+    AsyncMonitoringContainerAppsWithRawResponse,
+    MonitoringContainerApps,
+    MonitoringContainerAppsWithRawResponse,
+)
+from .monitoring_data_docks import (
+    AsyncMonitoringDataDocks,
+    AsyncMonitoringDataDocksWithRawResponse,
+    MonitoringDataDocks,
+    MonitoringDataDocksWithRawResponse,
+)
+from .monitoring_dev_workstations import (
+    AsyncMonitoringDevWorkstations,
+    AsyncMonitoringDevWorkstationsWithRawResponse,
+    MonitoringDevWorkstations,
+    MonitoringDevWorkstationsWithRawResponse,
+)
+from .monitoring_harbors import (
+    AsyncMonitoringHarbors,
+    AsyncMonitoringHarborsWithRawResponse,
+    MonitoringHarbors,
+    MonitoringHarborsWithRawResponse,
+)
+from .monitoring_hf_key_value_caches import (
+    AsyncMonitoringHfKeyValueCaches,
+    AsyncMonitoringHfKeyValueCachesWithRawResponse,
+    MonitoringHfKeyValueCaches,
+    MonitoringHfKeyValueCachesWithRawResponse,
+)
+from .monitoring_kafka_services import (
+    AsyncMonitoringKafkaServices,
+    AsyncMonitoringKafkaServicesWithRawResponse,
+    MonitoringKafkaServices,
+    MonitoringKafkaServicesWithRawResponse,
+)
+from .monitoring_managed_postgresqls import (
+    AsyncMonitoringManagedPostgresqls,
+    AsyncMonitoringManagedPostgresqlsWithRawResponse,
+    MonitoringManagedPostgresqls,
+    MonitoringManagedPostgresqlsWithRawResponse,
+)
+from .monitoring_model_servings import (
+    AsyncMonitoringModelServings,
+    AsyncMonitoringModelServingsWithRawResponse,
+    MonitoringModelServings,
+    MonitoringModelServingsWithRawResponse,
+)
+
+
+class AsyncMonitoring(ApiBaseAsync):
+    """Monitoring API, for asyncio."""
+
+    @property
+    def with_raw_response(self) -> AsyncMonitoringWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return AsyncMonitoringWithRawResponse(self)
+
+    @functools.cached_property
+    def bifrost(self) -> AsyncMonitoringBifrost:
+        """The bifrost API."""
+        return AsyncMonitoringBifrost(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def compute_docks(self) -> AsyncMonitoringComputeDocks:
+        """The compute docks API."""
+        return AsyncMonitoringComputeDocks(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def container_apps(self) -> AsyncMonitoringContainerApps:
+        """The container apps API."""
+        return AsyncMonitoringContainerApps(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def data_docks(self) -> AsyncMonitoringDataDocks:
+        """The data docks API."""
+        return AsyncMonitoringDataDocks(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def dev_workstations(self) -> AsyncMonitoringDevWorkstations:
+        """The dev workstations API."""
+        return AsyncMonitoringDevWorkstations(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def harbors(self) -> AsyncMonitoringHarbors:
+        """The harbors API."""
+        return AsyncMonitoringHarbors(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def hf_key_value_caches(self) -> AsyncMonitoringHfKeyValueCaches:
+        """The hf key value caches API."""
+        return AsyncMonitoringHfKeyValueCaches(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def kafka_services(self) -> AsyncMonitoringKafkaServices:
+        """The kafka services API."""
+        return AsyncMonitoringKafkaServices(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def managed_postgresqls(self) -> AsyncMonitoringManagedPostgresqls:
+        """The managed postgresqls API."""
+        return AsyncMonitoringManagedPostgresqls(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def model_servings(self) -> AsyncMonitoringModelServings:
+        """The model servings API."""
+        return AsyncMonitoringModelServings(self._cfg, self._httpx_client)
+
+    async def list_ai_agent_metrics(
+        self,
+        organization_id: UUID,
+        agent_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceMetricsResponse:
+        """Get metrics for an AI agent — the routing pod and every capability it dispatches to.
+
+        One target covering several pods on purpose: an agent is a routing pod plus one per
+        capability, and a dashboard showing only the router would describe the part that does
+        the least. The series are named after the agent and its capabilities rather than after
+        pods, so the legend reads like the Capabilities tab.
+
+        There is deliberately no matching `/logs` route: an agent's log lines carry the tool
+        names, dispatch decisions and preamble fragments that are our machinery rather than
+        anything the person who owns the agent can act on."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/ai-agents/{agent_id}/metrics",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "agent_id": encode_path_param(
+                        "agent_id", agent_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceMetricsResponse)
+
+    async def list_airflow_logs(
+        self,
+        organization_id: UUID,
+        instance_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        search: str | None = None,
+        search_mode: SearchMode | None = None,
+        pod: str | None = None,
+        container: str | None = None,
+        stream: LogStream | None = None,
+        level: LogLevel | None = None,
+        start: int | None = None,
+        end: int | None = None,
+        limit: int | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceLogsResponse:
+        """Get historical logs for an Airflow environment's component pods
+        (api-server/scheduler/dag-processor/triggerer/db-migrate). Task pods are
+        out of scope — see `MonitoringTarget::AirflowEnvironment`.
+
+        :param search: Optional free-text search term, matched against the log message. Embedded as an escaped, case-insensitive LogsQL regex filter — never raw query syntax. Interpreted according to `search_mode`.
+        :param search_mode: How to interpret `search`: `text` (default, case-insensitive substring) or `regex` (a validated RE2 pattern). Ignored when `search` is empty.
+        :param pod: Optional exact `kubernetes.pod_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param container: Optional exact `kubernetes.container_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param stream: Optional CRI stream filter (`stdout` | `stderr`). Maps to a static exact `stream:="…"` LogsQL filter.
+        :param level: Optional severity filter. Maps to a static case-insensitive prefix-token LogsQL clause over the unstructured message text (heuristic — see ADR-0020; false positives accepted).
+        :param start: Optional custom window start (unix epoch SECONDS). When BOTH `start` and `end` are provided they define the query window and `range` is ignored; otherwise `range` applies. The effective (possibly org-retention-clamped) window is echoed back in the response `start`/`end` fields.
+        :param end: Optional custom window end (unix epoch SECONDS). See `start`. May be slightly in the future (client clock slack); it is clamped to "now".
+        :param limit: Maximum number of entries to return (clamped to 1..=1000, default 500)."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/airflows/{instance_id}/logs",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "instance_id": encode_path_param(
+                        "instance_id", instance_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                        "search": search,
+                        "search_mode": search_mode,
+                        "pod": pod,
+                        "container": container,
+                        "stream": stream,
+                        "level": level,
+                        "start": start,
+                        "end": end,
+                        "limit": limit,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceLogsResponse)
+
+    async def list_logs(
+        self,
+        organization_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        search: str | None = None,
+        search_mode: SearchMode | None = None,
+        pod: str | None = None,
+        container: str | None = None,
+        stream: LogStream | None = None,
+        level: LogLevel | None = None,
+        start: int | None = None,
+        end: int | None = None,
+        limit: int | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceLogsResponse:
+        """Get org-level logs across all of the organization's namespaces.
+
+        Restricted to organization editors/admins: viewers keep the per-resource
+        logs tabs, but the org-wide view spans every namespace (including the CNPG
+        pods) and is refused outright for non-editors instead of redacted.
+
+        :param search: Optional free-text search term, matched against the log message. Embedded as an escaped, case-insensitive LogsQL regex filter — never raw query syntax. Interpreted according to `search_mode`.
+        :param search_mode: How to interpret `search`: `text` (default, case-insensitive substring) or `regex` (a validated RE2 pattern). Ignored when `search` is empty.
+        :param pod: Optional exact `kubernetes.pod_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param container: Optional exact `kubernetes.container_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param stream: Optional CRI stream filter (`stdout` | `stderr`). Maps to a static exact `stream:="…"` LogsQL filter.
+        :param level: Optional severity filter. Maps to a static case-insensitive prefix-token LogsQL clause over the unstructured message text (heuristic — see ADR-0020; false positives accepted).
+        :param start: Optional custom window start (unix epoch SECONDS). When BOTH `start` and `end` are provided they define the query window and `range` is ignored; otherwise `range` applies. The effective (possibly org-retention-clamped) window is echoed back in the response `start`/`end` fields.
+        :param end: Optional custom window end (unix epoch SECONDS). See `start`. May be slightly in the future (client clock slack); it is clamped to "now".
+        :param limit: Maximum number of entries to return (clamped to 1..=1000, default 500)."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/logs",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                        "search": search,
+                        "search_mode": search_mode,
+                        "pod": pod,
+                        "container": container,
+                        "stream": stream,
+                        "level": level,
+                        "start": start,
+                        "end": end,
+                        "limit": limit,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceLogsResponse)
+
+    async def list_nextflow_run_logs(
+        self,
+        organization_id: UUID,
+        nextflow_id: UUID,
+        run_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        search: str | None = None,
+        search_mode: SearchMode | None = None,
+        pod: str | None = None,
+        container: str | None = None,
+        stream: LogStream | None = None,
+        level: LogLevel | None = None,
+        start: int | None = None,
+        end: int | None = None,
+        limit: int | None = None,
+        role: NextflowPodRole | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceLogsResponse:
+        """Get the logs of one Nextflow run: its head, its task pods (including the
+        ones Nextflow already deleted) and its cleanup Job.
+
+        A run whose head has not been scheduled yet (no task namespace on its CR)
+        answers **200 with an empty entry list**, so the Logs tab shows its empty
+        state instead of an error while the run is queued.
+
+        :param search: Optional free-text search term, matched against the log message. Embedded as an escaped, case-insensitive LogsQL regex filter — never raw query syntax. Interpreted according to `search_mode`.
+        :param search_mode: How to interpret `search`: `text` (default, case-insensitive substring) or `regex` (a validated RE2 pattern). Ignored when `search` is empty.
+        :param pod: Optional exact `kubernetes.pod_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param container: Optional exact `kubernetes.container_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param stream: Optional CRI stream filter (`stdout` | `stderr`). Maps to a static exact `stream:="…"` LogsQL filter.
+        :param level: Optional severity filter. Maps to a static case-insensitive prefix-token LogsQL clause over the unstructured message text (heuristic — see ADR-0020; false positives accepted).
+        :param start: Optional custom window start (unix epoch SECONDS). When BOTH `start` and `end` are provided they define the query window and `range` is ignored; otherwise `range` applies. The effective (possibly org-retention-clamped) window is echoed back in the response `start`/`end` fields.
+        :param end: Optional custom window end (unix epoch SECONDS). See `start`. May be slightly in the future (client clock slack); it is clamped to "now".
+        :param limit: Maximum number of entries to return (clamped to 1..=1000, default 500).
+        :param role: Only the pods of this role: `head` (the `nextflow run` console output), `task` or `cleanup`. Omitted: every pod of the run."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/nextflows/{nextflow_id}/runs/{run_id}/logs",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "nextflow_id": encode_path_param(
+                        "nextflow_id", nextflow_id, "simple", False
+                    ),
+                    "run_id": encode_path_param("run_id", run_id, "simple", False),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                        "search": search,
+                        "search_mode": search_mode,
+                        "pod": pod,
+                        "container": container,
+                        "stream": stream,
+                        "level": level,
+                        "start": start,
+                        "end": end,
+                        "limit": limit,
+                        "role": role,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceLogsResponse)
+
+    async def retrieve_overview(
+        self,
+        organization_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceMetricsResponse:
+        """Get org-level monitoring overview."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/overview",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceMetricsResponse)
+
+    async def list_scheduled_query_metrics(
+        self,
+        organization_id: UUID,
+        query_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceMetricsResponse:
+        """Get metrics for a scheduled query.
+
+        One panel, the query's consecutive failed scheduled runs. A query without
+        a live schedule answers 200 with an empty series: nothing pushes a streak
+        for it."""
+        response = await self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/scheduled-queries/{query_id}/metrics",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "query_id": encode_path_param(
+                        "query_id", query_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceMetricsResponse)
+
+
+class AsyncMonitoringWithRawResponse:
+    """The methods of :class:`AsyncMonitoring`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: AsyncMonitoring) -> None:
+        self._resource = resource
+        self.list_ai_agent_metrics = async_to_raw_response_wrapper(
+            resource.list_ai_agent_metrics
+        )
+        self.list_airflow_logs = async_to_raw_response_wrapper(
+            resource.list_airflow_logs
+        )
+        self.list_logs = async_to_raw_response_wrapper(resource.list_logs)
+        self.list_nextflow_run_logs = async_to_raw_response_wrapper(
+            resource.list_nextflow_run_logs
+        )
+        self.retrieve_overview = async_to_raw_response_wrapper(
+            resource.retrieve_overview
+        )
+        self.list_scheduled_query_metrics = async_to_raw_response_wrapper(
+            resource.list_scheduled_query_metrics
+        )
+
+    @property
+    def bifrost(self) -> AsyncMonitoringBifrostWithRawResponse:
+        """The bifrost API."""
+        return AsyncMonitoringBifrostWithRawResponse(self._resource.bifrost)
+
+    @property
+    def compute_docks(self) -> AsyncMonitoringComputeDocksWithRawResponse:
+        """The compute docks API."""
+        return AsyncMonitoringComputeDocksWithRawResponse(self._resource.compute_docks)
+
+    @property
+    def container_apps(self) -> AsyncMonitoringContainerAppsWithRawResponse:
+        """The container apps API."""
+        return AsyncMonitoringContainerAppsWithRawResponse(
+            self._resource.container_apps
+        )
+
+    @property
+    def data_docks(self) -> AsyncMonitoringDataDocksWithRawResponse:
+        """The data docks API."""
+        return AsyncMonitoringDataDocksWithRawResponse(self._resource.data_docks)
+
+    @property
+    def dev_workstations(self) -> AsyncMonitoringDevWorkstationsWithRawResponse:
+        """The dev workstations API."""
+        return AsyncMonitoringDevWorkstationsWithRawResponse(
+            self._resource.dev_workstations
+        )
+
+    @property
+    def harbors(self) -> AsyncMonitoringHarborsWithRawResponse:
+        """The harbors API."""
+        return AsyncMonitoringHarborsWithRawResponse(self._resource.harbors)
+
+    @property
+    def hf_key_value_caches(self) -> AsyncMonitoringHfKeyValueCachesWithRawResponse:
+        """The hf key value caches API."""
+        return AsyncMonitoringHfKeyValueCachesWithRawResponse(
+            self._resource.hf_key_value_caches
+        )
+
+    @property
+    def kafka_services(self) -> AsyncMonitoringKafkaServicesWithRawResponse:
+        """The kafka services API."""
+        return AsyncMonitoringKafkaServicesWithRawResponse(
+            self._resource.kafka_services
+        )
+
+    @property
+    def managed_postgresqls(self) -> AsyncMonitoringManagedPostgresqlsWithRawResponse:
+        """The managed postgresqls API."""
+        return AsyncMonitoringManagedPostgresqlsWithRawResponse(
+            self._resource.managed_postgresqls
+        )
+
+    @property
+    def model_servings(self) -> AsyncMonitoringModelServingsWithRawResponse:
+        """The model servings API."""
+        return AsyncMonitoringModelServingsWithRawResponse(
+            self._resource.model_servings
+        )
+
+
+class Monitoring(ApiBaseSync):
+    """Monitoring API."""
+
+    @property
+    def with_raw_response(self) -> MonitoringWithRawResponse:
+        """These methods, returning an :class:`APIResponse` with the status and headers."""
+        return MonitoringWithRawResponse(self)
+
+    @functools.cached_property
+    def bifrost(self) -> MonitoringBifrost:
+        """The bifrost API."""
+        return MonitoringBifrost(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def compute_docks(self) -> MonitoringComputeDocks:
+        """The compute docks API."""
+        return MonitoringComputeDocks(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def container_apps(self) -> MonitoringContainerApps:
+        """The container apps API."""
+        return MonitoringContainerApps(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def data_docks(self) -> MonitoringDataDocks:
+        """The data docks API."""
+        return MonitoringDataDocks(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def dev_workstations(self) -> MonitoringDevWorkstations:
+        """The dev workstations API."""
+        return MonitoringDevWorkstations(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def harbors(self) -> MonitoringHarbors:
+        """The harbors API."""
+        return MonitoringHarbors(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def hf_key_value_caches(self) -> MonitoringHfKeyValueCaches:
+        """The hf key value caches API."""
+        return MonitoringHfKeyValueCaches(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def kafka_services(self) -> MonitoringKafkaServices:
+        """The kafka services API."""
+        return MonitoringKafkaServices(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def managed_postgresqls(self) -> MonitoringManagedPostgresqls:
+        """The managed postgresqls API."""
+        return MonitoringManagedPostgresqls(self._cfg, self._httpx_client)
+
+    @functools.cached_property
+    def model_servings(self) -> MonitoringModelServings:
+        """The model servings API."""
+        return MonitoringModelServings(self._cfg, self._httpx_client)
+
+    def list_ai_agent_metrics(
+        self,
+        organization_id: UUID,
+        agent_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceMetricsResponse:
+        """Get metrics for an AI agent — the routing pod and every capability it dispatches to.
+
+        One target covering several pods on purpose: an agent is a routing pod plus one per
+        capability, and a dashboard showing only the router would describe the part that does
+        the least. The series are named after the agent and its capabilities rather than after
+        pods, so the legend reads like the Capabilities tab.
+
+        There is deliberately no matching `/logs` route: an agent's log lines carry the tool
+        names, dispatch decisions and preamble fragments that are our machinery rather than
+        anything the person who owns the agent can act on."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/ai-agents/{agent_id}/metrics",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "agent_id": encode_path_param(
+                        "agent_id", agent_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceMetricsResponse)
+
+    def list_airflow_logs(
+        self,
+        organization_id: UUID,
+        instance_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        search: str | None = None,
+        search_mode: SearchMode | None = None,
+        pod: str | None = None,
+        container: str | None = None,
+        stream: LogStream | None = None,
+        level: LogLevel | None = None,
+        start: int | None = None,
+        end: int | None = None,
+        limit: int | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceLogsResponse:
+        """Get historical logs for an Airflow environment's component pods
+        (api-server/scheduler/dag-processor/triggerer/db-migrate). Task pods are
+        out of scope — see `MonitoringTarget::AirflowEnvironment`.
+
+        :param search: Optional free-text search term, matched against the log message. Embedded as an escaped, case-insensitive LogsQL regex filter — never raw query syntax. Interpreted according to `search_mode`.
+        :param search_mode: How to interpret `search`: `text` (default, case-insensitive substring) or `regex` (a validated RE2 pattern). Ignored when `search` is empty.
+        :param pod: Optional exact `kubernetes.pod_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param container: Optional exact `kubernetes.container_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param stream: Optional CRI stream filter (`stdout` | `stderr`). Maps to a static exact `stream:="…"` LogsQL filter.
+        :param level: Optional severity filter. Maps to a static case-insensitive prefix-token LogsQL clause over the unstructured message text (heuristic — see ADR-0020; false positives accepted).
+        :param start: Optional custom window start (unix epoch SECONDS). When BOTH `start` and `end` are provided they define the query window and `range` is ignored; otherwise `range` applies. The effective (possibly org-retention-clamped) window is echoed back in the response `start`/`end` fields.
+        :param end: Optional custom window end (unix epoch SECONDS). See `start`. May be slightly in the future (client clock slack); it is clamped to "now".
+        :param limit: Maximum number of entries to return (clamped to 1..=1000, default 500)."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/airflows/{instance_id}/logs",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "instance_id": encode_path_param(
+                        "instance_id", instance_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                        "search": search,
+                        "search_mode": search_mode,
+                        "pod": pod,
+                        "container": container,
+                        "stream": stream,
+                        "level": level,
+                        "start": start,
+                        "end": end,
+                        "limit": limit,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceLogsResponse)
+
+    def list_logs(
+        self,
+        organization_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        search: str | None = None,
+        search_mode: SearchMode | None = None,
+        pod: str | None = None,
+        container: str | None = None,
+        stream: LogStream | None = None,
+        level: LogLevel | None = None,
+        start: int | None = None,
+        end: int | None = None,
+        limit: int | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceLogsResponse:
+        """Get org-level logs across all of the organization's namespaces.
+
+        Restricted to organization editors/admins: viewers keep the per-resource
+        logs tabs, but the org-wide view spans every namespace (including the CNPG
+        pods) and is refused outright for non-editors instead of redacted.
+
+        :param search: Optional free-text search term, matched against the log message. Embedded as an escaped, case-insensitive LogsQL regex filter — never raw query syntax. Interpreted according to `search_mode`.
+        :param search_mode: How to interpret `search`: `text` (default, case-insensitive substring) or `regex` (a validated RE2 pattern). Ignored when `search` is empty.
+        :param pod: Optional exact `kubernetes.pod_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param container: Optional exact `kubernetes.container_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param stream: Optional CRI stream filter (`stdout` | `stderr`). Maps to a static exact `stream:="…"` LogsQL filter.
+        :param level: Optional severity filter. Maps to a static case-insensitive prefix-token LogsQL clause over the unstructured message text (heuristic — see ADR-0020; false positives accepted).
+        :param start: Optional custom window start (unix epoch SECONDS). When BOTH `start` and `end` are provided they define the query window and `range` is ignored; otherwise `range` applies. The effective (possibly org-retention-clamped) window is echoed back in the response `start`/`end` fields.
+        :param end: Optional custom window end (unix epoch SECONDS). See `start`. May be slightly in the future (client clock slack); it is clamped to "now".
+        :param limit: Maximum number of entries to return (clamped to 1..=1000, default 500)."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/logs",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                        "search": search,
+                        "search_mode": search_mode,
+                        "pod": pod,
+                        "container": container,
+                        "stream": stream,
+                        "level": level,
+                        "start": start,
+                        "end": end,
+                        "limit": limit,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceLogsResponse)
+
+    def list_nextflow_run_logs(
+        self,
+        organization_id: UUID,
+        nextflow_id: UUID,
+        run_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        search: str | None = None,
+        search_mode: SearchMode | None = None,
+        pod: str | None = None,
+        container: str | None = None,
+        stream: LogStream | None = None,
+        level: LogLevel | None = None,
+        start: int | None = None,
+        end: int | None = None,
+        limit: int | None = None,
+        role: NextflowPodRole | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceLogsResponse:
+        """Get the logs of one Nextflow run: its head, its task pods (including the
+        ones Nextflow already deleted) and its cleanup Job.
+
+        A run whose head has not been scheduled yet (no task namespace on its CR)
+        answers **200 with an empty entry list**, so the Logs tab shows its empty
+        state instead of an error while the run is queued.
+
+        :param search: Optional free-text search term, matched against the log message. Embedded as an escaped, case-insensitive LogsQL regex filter — never raw query syntax. Interpreted according to `search_mode`.
+        :param search_mode: How to interpret `search`: `text` (default, case-insensitive substring) or `regex` (a validated RE2 pattern). Ignored when `search` is empty.
+        :param pod: Optional exact `kubernetes.pod_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param container: Optional exact `kubernetes.container_name` source filter (one entry from the `sources` facet). Validated as a plausible k8s name and embedded as an exact `:=` filter.
+        :param stream: Optional CRI stream filter (`stdout` | `stderr`). Maps to a static exact `stream:="…"` LogsQL filter.
+        :param level: Optional severity filter. Maps to a static case-insensitive prefix-token LogsQL clause over the unstructured message text (heuristic — see ADR-0020; false positives accepted).
+        :param start: Optional custom window start (unix epoch SECONDS). When BOTH `start` and `end` are provided they define the query window and `range` is ignored; otherwise `range` applies. The effective (possibly org-retention-clamped) window is echoed back in the response `start`/`end` fields.
+        :param end: Optional custom window end (unix epoch SECONDS). See `start`. May be slightly in the future (client clock slack); it is clamped to "now".
+        :param limit: Maximum number of entries to return (clamped to 1..=1000, default 500).
+        :param role: Only the pods of this role: `head` (the `nextflow run` console output), `task` or `cleanup`. Omitted: every pod of the run."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/nextflows/{nextflow_id}/runs/{run_id}/logs",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "nextflow_id": encode_path_param(
+                        "nextflow_id", nextflow_id, "simple", False
+                    ),
+                    "run_id": encode_path_param("run_id", run_id, "simple", False),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                        "search": search,
+                        "search_mode": search_mode,
+                        "pod": pod,
+                        "container": container,
+                        "stream": stream,
+                        "level": level,
+                        "start": start,
+                        "end": end,
+                        "limit": limit,
+                        "role": role,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceLogsResponse)
+
+    def retrieve_overview(
+        self,
+        organization_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceMetricsResponse:
+        """Get org-level monitoring overview."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/overview",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceMetricsResponse)
+
+    def list_scheduled_query_metrics(
+        self,
+        organization_id: UUID,
+        query_id: UUID,
+        *,
+        range: MetricsRange | None = None,
+        extra_headers: t.Mapping[str, str] | None = None,
+        extra_query: t.Mapping[str, object] | None = None,
+        extra_body: t.Mapping[str, object] | None = None,
+        timeout: Timeout | Unset = UNSET,
+        max_retries: int | None = None,
+    ) -> ResourceMetricsResponse:
+        """Get metrics for a scheduled query.
+
+        One panel, the query's consecutive failed scheduled runs. A query without
+        a live schedule answers 200 with an empty series: nothing pushes a streak
+        for it."""
+        response = self._request(
+            ApiRequest(
+                method="get",
+                path="/api/v1/organizations/{organization_id}/monitoring/scheduled-queries/{query_id}/metrics",
+                path_params={
+                    "organization_id": encode_path_param(
+                        "organization_id", organization_id, "simple", False
+                    ),
+                    "query_id": encode_path_param(
+                        "query_id", query_id, "simple", False
+                    ),
+                },
+                query_params=serialize_query_params(
+                    {
+                        "range": range,
+                    },
+                ),
+                error_types={
+                    "default": _models.ApiErrorBody,
+                },
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                max_retries=max_retries,
+            )
+        )
+        return decode_response(response, ResourceMetricsResponse)
+
+
+class MonitoringWithRawResponse:
+    """The methods of :class:`Monitoring`, returning an :class:`APIResponse`."""
+
+    def __init__(self, resource: Monitoring) -> None:
+        self._resource = resource
+        self.list_ai_agent_metrics = to_raw_response_wrapper(
+            resource.list_ai_agent_metrics
+        )
+        self.list_airflow_logs = to_raw_response_wrapper(resource.list_airflow_logs)
+        self.list_logs = to_raw_response_wrapper(resource.list_logs)
+        self.list_nextflow_run_logs = to_raw_response_wrapper(
+            resource.list_nextflow_run_logs
+        )
+        self.retrieve_overview = to_raw_response_wrapper(resource.retrieve_overview)
+        self.list_scheduled_query_metrics = to_raw_response_wrapper(
+            resource.list_scheduled_query_metrics
+        )
+
+    @property
+    def bifrost(self) -> MonitoringBifrostWithRawResponse:
+        """The bifrost API."""
+        return MonitoringBifrostWithRawResponse(self._resource.bifrost)
+
+    @property
+    def compute_docks(self) -> MonitoringComputeDocksWithRawResponse:
+        """The compute docks API."""
+        return MonitoringComputeDocksWithRawResponse(self._resource.compute_docks)
+
+    @property
+    def container_apps(self) -> MonitoringContainerAppsWithRawResponse:
+        """The container apps API."""
+        return MonitoringContainerAppsWithRawResponse(self._resource.container_apps)
+
+    @property
+    def data_docks(self) -> MonitoringDataDocksWithRawResponse:
+        """The data docks API."""
+        return MonitoringDataDocksWithRawResponse(self._resource.data_docks)
+
+    @property
+    def dev_workstations(self) -> MonitoringDevWorkstationsWithRawResponse:
+        """The dev workstations API."""
+        return MonitoringDevWorkstationsWithRawResponse(self._resource.dev_workstations)
+
+    @property
+    def harbors(self) -> MonitoringHarborsWithRawResponse:
+        """The harbors API."""
+        return MonitoringHarborsWithRawResponse(self._resource.harbors)
+
+    @property
+    def hf_key_value_caches(self) -> MonitoringHfKeyValueCachesWithRawResponse:
+        """The hf key value caches API."""
+        return MonitoringHfKeyValueCachesWithRawResponse(
+            self._resource.hf_key_value_caches
+        )
+
+    @property
+    def kafka_services(self) -> MonitoringKafkaServicesWithRawResponse:
+        """The kafka services API."""
+        return MonitoringKafkaServicesWithRawResponse(self._resource.kafka_services)
+
+    @property
+    def managed_postgresqls(self) -> MonitoringManagedPostgresqlsWithRawResponse:
+        """The managed postgresqls API."""
+        return MonitoringManagedPostgresqlsWithRawResponse(
+            self._resource.managed_postgresqls
+        )
+
+    @property
+    def model_servings(self) -> MonitoringModelServingsWithRawResponse:
+        """The model servings API."""
+        return MonitoringModelServingsWithRawResponse(self._resource.model_servings)