diff --git a/src/llama_stack_client/resources/telemetry.py b/src/llama_stack_client/resources/telemetry.py index 1cec537e..8e753523 100644 --- a/src/llama_stack_client/resources/telemetry.py +++ b/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, ) diff --git a/src/llama_stack_client/types/__init__.py b/src/llama_stack_client/types/__init__.py index 887f1706..5b2bbc4b 100644 --- a/src/llama_stack_client/types/__init__.py +++ b/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 diff --git a/src/llama_stack_client/types/metric_label_matcher_param.py b/src/llama_stack_client/types/metric_label_matcher_param.py new file mode 100644 index 00000000..814ddce1 --- /dev/null +++ b/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 diff --git a/src/llama_stack_client/types/metric_label_operator_param.py b/src/llama_stack_client/types/metric_label_operator_param.py new file mode 100644 index 00000000..76165c83 --- /dev/null +++ b/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 = "!~" diff --git a/src/llama_stack_client/types/metric_query_type_param.py b/src/llama_stack_client/types/metric_query_type_param.py new file mode 100644 index 00000000..25bde912 --- /dev/null +++ b/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" diff --git a/src/llama_stack_client/types/telemetry_query_metrics_params.py b/src/llama_stack_client/types/telemetry_query_metrics_params.py new file mode 100644 index 00000000..65cd026e --- /dev/null +++ b/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""" diff --git a/src/llama_stack_client/types/telemetry_query_metrics_response.py b/src/llama_stack_client/types/telemetry_query_metrics_response.py new file mode 100644 index 00000000..957584ab --- /dev/null +++ b/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]