feat: implement query_metrics

src/llama_stack_client/resources/telemetry.py

@@ -12,6 +12,7 @@
     telemetry_query_traces_params,
     telemetry_get_span_tree_params,
     telemetry_save_spans_to_dataset_params,
+    telemetry_query_metrics_params,
 )
 from .._types import NOT_GIVEN, Body, Query, Headers, NoneType, NotGiven
 from .._utils import maybe_transform, async_maybe_transform
@@ -27,11 +28,15 @@
 from ..types.trace import Trace
 from .._base_client import make_request_options
 from ..types.event_param import EventParam
+
+from ..types.metric_label_matcher_param import MetricLabelMatcherParam
+from ..types.metric_query_type_param import MetricQueryTypeParam
 from ..types.query_condition_param import QueryConditionParam
 from ..types.telemetry_get_span_response import TelemetryGetSpanResponse
 from ..types.telemetry_query_spans_response import TelemetryQuerySpansResponse
 from ..types.telemetry_query_traces_response import TelemetryQueryTracesResponse
 from ..types.telemetry_get_span_tree_response import TelemetryGetSpanTreeResponse
+from ..types.telemetry_query_metrics_response import TelemetryQueryMetricsResponse
 
 __all__ = ["TelemetryResource", "AsyncTelemetryResource"]
 
@@ -377,6 +382,66 @@ def save_spans_to_dataset(
             cast_to=NoneType,
         )
 
+    def query_metrics(
+        self,
+        *,
+        metric_name: str,
+        start_time: int,
+        end_time: int | None = None,
+        granularity: str | None = None,
+        query_type: MetricQueryTypeParam = MetricQueryTypeParam.RANGE,
+        label_matchers: Iterable[MetricLabelMatcherParam] | None = None,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> TelemetryQueryMetricsResponse:
+        """
+        Query metrics.
+
+        Args:
+          metric_name: The name of the metric to query
+
+          start_time: The start time for the query (Unix timestamp)
+
+          end_time: (Optional) The end time for the query (Unix timestamp)
+
+          granularity: (Optional) The granularity of the query (e.g., '1d', '1h')
+
+          query_type: (Optional) The type of metric query to perform
+
+          label_matchers: (Optional) Label matchers to filter the metrics
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return self._post(
+            f"/v1/telemetry/metrics/{metric_name}",
+            body=maybe_transform(
+                {
+                    "start_time": start_time,
+                    "end_time": end_time,
+                    "granularity": granularity,
+                    "query_type": query_type.value if query_type else None,
+                    "label_matchers": label_matchers,
+                },
+                telemetry_query_metrics_params.TelemetryQueryMetricsParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                post_parser=DataWrapper[TelemetryQueryMetricsResponse]._unwrapper,
+            ),
+            cast_to=cast(Type[TelemetryQueryMetricsResponse], DataWrapper[TelemetryQueryMetricsResponse]),
+        )
+
 
 class AsyncTelemetryResource(AsyncAPIResource):
     @cached_property
@@ -560,6 +625,68 @@ async def log_event(
             ),
             cast_to=NoneType,
         )
+
+
+    async def query_metrics(
+        self,
+        *,
+        metric_name: str,
+        start_time: int,
+        end_time: int | None = None,
+        granularity: str | None = None,
+        query_type: MetricQueryTypeParam = MetricQueryTypeParam.RANGE,
+        label_matchers: Iterable[MetricLabelMatcherParam] | None = None,
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN,
+    ) -> TelemetryQueryMetricsResponse:
+        """
+        Query metrics.
+
+        Args:
+          metric_name: The name of the metric to query
+
+          start_time: The start time for the query (Unix timestamp)
+
+          end_time: (Optional) The end time for the query (Unix timestamp)
+
+          granularity: (Optional) The granularity of the query (e.g., '1d', '1h')
+
+          query_type: (Optional) The type of metric query to perform
+
+          label_matchers: (Optional) Label matchers to filter the metrics
+
+          extra_headers: Send extra headers
+
+          extra_query: Add additional query parameters to the request
+
+          extra_body: Add additional JSON properties to the request
+
+          timeout: Override the client-level default timeout for this request, in seconds
+        """
+        return await self._post(
+            f"/v1/telemetry/metrics/{metric_name}",
+            body=await async_maybe_transform(
+                {
+                    "start_time": start_time,
+                    "end_time": end_time,
+                    "granularity": granularity,
+                    "query_type": query_type.value if query_type else None,
+                    "label_matchers": label_matchers,
+                },
+                telemetry_query_metrics_params.TelemetryQueryMetricsParams,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+                post_parser=DataWrapper[TelemetryQueryMetricsResponse]._unwrapper,
+            ),
+            cast_to=cast(Type[TelemetryQueryMetricsResponse], DataWrapper[TelemetryQueryMetricsResponse]),
+        )
+
 
     async def query_spans(
         self,
@@ -742,6 +869,9 @@ def __init__(self, telemetry: TelemetryResource) -> None:
         self.query_traces = to_raw_response_wrapper(
             telemetry.query_traces,
         )
+        self.query_metrics = to_raw_response_wrapper(
+            telemetry.query_metrics,
+        )
         self.save_spans_to_dataset = to_raw_response_wrapper(
             telemetry.save_spans_to_dataset,
         )
@@ -769,6 +899,9 @@ def __init__(self, telemetry: AsyncTelemetryResource) -> None:
         self.query_traces = async_to_raw_response_wrapper(
             telemetry.query_traces,
         )
+        self.query_metrics = async_to_raw_response_wrapper(
+            telemetry.query_metrics,
+        )
         self.save_spans_to_dataset = async_to_raw_response_wrapper(
             telemetry.save_spans_to_dataset,
         )
@@ -796,6 +929,9 @@ def __init__(self, telemetry: TelemetryResource) -> None:
         self.query_traces = to_streamed_response_wrapper(
             telemetry.query_traces,
         )
+        self.query_metrics = to_streamed_response_wrapper(
+            telemetry.query_metrics,
+        )
         self.save_spans_to_dataset = to_streamed_response_wrapper(
             telemetry.save_spans_to_dataset,
         )
@@ -823,6 +959,9 @@ def __init__(self, telemetry: AsyncTelemetryResource) -> None:
         self.query_traces = async_to_streamed_response_wrapper(
             telemetry.query_traces,
         )
+        self.query_metrics = async_to_streamed_response_wrapper(
+            telemetry.query_metrics,
+        )
         self.save_spans_to_dataset = async_to_streamed_response_wrapper(
             telemetry.save_spans_to_dataset,
         )

src/llama_stack_client/types/__init__.py

@@ -139,6 +139,8 @@
 from .vector_db_register_response import VectorDBRegisterResponse as VectorDBRegisterResponse
 from .vector_db_retrieve_response import VectorDBRetrieveResponse as VectorDBRetrieveResponse
 from .scoring_score_batch_response import ScoringScoreBatchResponse as ScoringScoreBatchResponse
+from .telemetry_query_metrics_params import TelemetryQueryMetricsParams as TelemetryQueryMetricsParams
+from .telemetry_query_metrics_response import TelemetryQueryMetricsResponse as TelemetryQueryMetricsResponse
 from .telemetry_query_spans_params import TelemetryQuerySpansParams as TelemetryQuerySpansParams
 from .vector_store_delete_response import VectorStoreDeleteResponse as VectorStoreDeleteResponse
 from .vector_store_search_response import VectorStoreSearchResponse as VectorStoreSearchResponse

src/llama_stack_client/types/metric_label_matcher_param.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import Union, Iterable
+from typing_extensions import TypedDict
+
+from .metric_label_operator_param import MetricLabelOperator
+
+__all__ = ["MetricLabelMatcherParam"]
+
+class MetricLabelMatcherParam(TypedDict, total=False):
+    """A matcher for filtering metrics by label values.
+    :param name: The name of the label to match
+    :param value: The value to match against
+    :param operator: The comparison operator to use for matching
+    """
+
+    name: str
+    value: str
+    operator: MetricLabelOperator = MetricLabelOperator.EQUALS

src/llama_stack_client/types/metric_label_operator_param.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+class MetricLabelOperator(Enum):
+    """Operators for matching metric labels.
+    :cvar EQUALS: Label value must equal the specified value
+    :cvar NOT_EQUALS: Label value must not equal the specified value
+    :cvar REGEX_MATCH: Label value must match the specified regular expression
+    :cvar REGEX_NOT_MATCH: Label value must not match the specified regular expression
+    """
+
+    EQUALS = "="
+    NOT_EQUALS = "!="
+    REGEX_MATCH = "=~"
+    REGEX_NOT_MATCH = "!~"

src/llama_stack_client/types/metric_query_type_param.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class MetricQueryTypeParam(Enum):
+    """The type of metric query to perform.
+    :cvar RANGE: Query metrics over a time range
+    :cvar INSTANT: Query metrics at a specific point in time
+    """
+
+    RANGE = "range"
+    INSTANT = "instant"

src/llama_stack_client/types/telemetry_query_metrics_params.py

@@ -0,0 +1,31 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable
+from typing_extensions import Literal, Required, TypedDict
+
+from .metric_label_matcher_param import MetricLabelMatcherParam
+from .metric_query_type_param import MetricQueryTypeParam
+
+__all__ = ["TelemetryQueryMetricsParams"]
+
+
+class TelemetryQueryMetricsParams(TypedDict, total=False):
+    metric_name: Required[str]
+    """The name of the metric to query"""
+
+    start_time: Required[int]
+    """The start time for the query (Unix timestamp)"""
+
+    end_time: int
+    """(Optional) The end time for the query (Unix timestamp)"""
+
+    granularity: str
+    """(Optional) The granularity of the query (e.g., '1d', '1h')"""
+
+    query_type: MetricQueryTypeParam
+    """(Optional) The type of metric query to perform"""
+
+    label_matchers: Iterable[MetricLabelMatcherParam]
+    """(Optional) Label matchers to filter the metrics"""

src/llama_stack_client/types/telemetry_query_metrics_response.py

@@ -0,0 +1,55 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Dict, List, Union, Optional
+from datetime import datetime
+from typing_extensions import TypeAlias
+
+from .._models import BaseModel
+
+__all__ = ["TelemetryQueryMetricsResponse", "MetricSeries", "MetricLabel", "MetricDataPoint"]
+
+
+class MetricLabel(BaseModel):
+    """A label associated with a metric.
+    :param name: The name of the label
+    :param value: The value of the label
+    """
+
+    name: str
+    """The name of the label"""
+
+    value: str
+    """The value of the label"""
+
+
+class MetricDataPoint(BaseModel):
+    """A single data point in a metric time series.
+    :param timestamp: Unix timestamp when the metric value was recorded
+    :param value: The numeric value of the metric at this timestamp
+    """
+
+    timestamp: int
+    """Unix timestamp when the metric value was recorded"""
+
+    value: float
+    """The numeric value of the metric at this timestamp"""
+
+
+class MetricSeries(BaseModel):
+    """A time series of metric data points.
+    :param metric: The name of the metric
+    :param labels: List of labels associated with this metric series
+    :param values: List of data points in chronological order
+    """
+
+    metric: str
+    """The name of the metric"""
+
+    labels: List[MetricLabel]
+    """List of labels associated with this metric series"""
+
+    values: List[MetricDataPoint]
+    """List of data points in chronological order"""
+
+
+TelemetryQueryMetricsResponse: TypeAlias = List[MetricSeries]