holmesgpt 0.14.0a0__py3-none-any.whl → 0.14.1__py3-none-any.whl

holmes/plugins/toolsets/grafana/toolset_grafana_tempo.py

@@ -3,33 +3,34 @@ from typing import Any, Dict, Tuple, cast, List
 
 import yaml  # type: ignore
 
-from holmes.common.env_vars import load_bool
+from holmes.common.env_vars import load_bool, MAX_GRAPH_POINTS
 from holmes.core.tools import (
     StructuredToolResult,
     Tool,
     ToolParameter,
-    ToolResultStatus,
+    StructuredToolResultStatus,
 )
+from holmes.plugins.toolsets.consts import STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION
 from holmes.plugins.toolsets.grafana.base_grafana_toolset import BaseGrafanaToolset
 from holmes.plugins.toolsets.grafana.common import (
     GrafanaTempoConfig,
 )
 from holmes.plugins.toolsets.grafana.grafana_tempo_api import GrafanaTempoAPI
 from holmes.plugins.toolsets.logging_utils.logging_api import (
-    DEFAULT_TIME_SPAN_SECONDS,
+    DEFAULT_GRAPH_TIME_SPAN_SECONDS,
 )
 from holmes.plugins.toolsets.utils import (
     toolset_name_for_one_liner,
     process_timestamps_to_int,
+    standard_start_datetime_tool_param_description,
+    adjust_step_for_max_points,
+    seconds_to_duration_string,
+    duration_string_to_seconds,
 )
 
 TEMPO_LABELS_ADD_PREFIX = load_bool("TEMPO_LABELS_ADD_PREFIX", True)
 TEMPO_API_USE_POST = False  # Use GET method for direct API mapping
 
-ONE_HOUR_IN_SECONDS = 3600
-DEFAULT_TRACES_TIME_SPAN_SECONDS = DEFAULT_TIME_SPAN_SECONDS  # 7 days
-DEFAULT_TAGS_TIME_SPAN_SECONDS = 8 * ONE_HOUR_IN_SECONDS  # 8 hours
-
 
 class BaseGrafanaTempoToolset(BaseGrafanaToolset):
     config_class = GrafanaTempoConfig
@@ -109,213 +110,19 @@ class BaseGrafanaTempoToolset(BaseGrafanaToolset):
 
         return filters
 
-
-def validate_params(params: Dict[str, Any], expected_params: List[str]):
-    for param in expected_params:
-        if param in params and params[param] not in (None, "", [], {}):
-            return None
-
-    return f"At least one of the following argument is expected but none were set: {expected_params}"
-
-
-# class GetTempoTraces(Tool):
-#     def __init__(self, toolset: BaseGrafanaTempoToolset):
-#         super().__init__(
-#             name="fetch_tempo_traces",
-#             description="""Lists Tempo traces. At least one of `service_name`, `pod_name` or `deployment_name` argument is required.""",
-#             parameters={
-#                 "min_duration": ToolParameter(
-#                     description="The minimum duration of traces to fetch, e.g., '5s' for 5 seconds.",
-#                     type="string",
-#                     required=True,
-#                 ),
-#                 "service_name": ToolParameter(
-#                     description="Filter traces by service name",
-#                     type="string",
-#                     required=False,
-#                 ),
-#                 "pod_name": ToolParameter(
-#                     description="Filter traces by pod name",
-#                     type="string",
-#                     required=False,
-#                 ),
-#                 "namespace_name": ToolParameter(
-#                     description="Filter traces by namespace",
-#                     type="string",
-#                     required=False,
-#                 ),
-#                 "deployment_name": ToolParameter(
-#                     description="Filter traces by deployment name",
-#                     type="string",
-#                     required=False,
-#                 ),
-#                 "node_name": ToolParameter(
-#                     description="Filter traces by node",
-#                     type="string",
-#                     required=False,
-#                 ),
-#                 "start_datetime": ToolParameter(
-#                     description=f"The beginning time boundary for the trace search period. String in RFC3339 format. If a negative integer, the number of seconds relative to the end_timestamp. Defaults to -{DEFAULT_TRACES_TIME_SPAN_SECONDS}",
-#                     type="string",
-#                     required=False,
-#                 ),
-#                 "end_datetime": ToolParameter(
-#                     description="The ending time boundary for the trace search period. String in RFC3339 format. Defaults to NOW().",
-#                     type="string",
-#                     required=False,
-#                 ),
-#                 "limit": ToolParameter(
-#                     description="Maximum number of traces to return. Defaults to 50",
-#                     type="string",
-#                     required=False,
-#                 ),
-#                 "sort": ToolParameter(
-#                     description="One of 'descending', 'ascending' or 'none' for no sorting. Defaults to descending",
-#                     type="string",
-#                     required=False,
-#                 ),
-#             },
-#         )
-#         self._toolset = toolset
-#
-#     def _invoke(self, params: Dict, user_approved: bool = False) -> StructuredToolResult:
-#         # Create API instance
-#         api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
-#
-#         invalid_params_error = validate_params(
-#             params, ["service_name", "pod_name", "deployment_name"]
-#         )
-#         if invalid_params_error:
-#             return StructuredToolResult(
-#                 status=ToolResultStatus.ERROR,
-#                 error=invalid_params_error,
-#                 params=params,
-#             )
-#
-#         start, end = process_timestamps_to_int(
-#             params.get("start_datetime"),
-#             params.get("end_datetime"),
-#             default_time_span_seconds=DEFAULT_TRACES_TIME_SPAN_SECONDS,
-#         )
-#
-#         filters = self._toolset.build_k8s_filters(params, use_exact_match=True)
-#
-#         filters.append(f'duration>{get_param_or_raise(params, "min_duration")}')
-#
-#         query = " && ".join(filters)
-#         query = f"{{{query}}}"
-#
-#         traces = api.search_traces_by_query(
-#             q=query,
-#             start=start,
-#             end=end,
-#             limit=params.get("limit", 50),
-#         )
-#         return StructuredToolResult(
-#             status=ToolResultStatus.SUCCESS,
-#             data=format_traces_list(traces),
-#             params=params,
-#             invocation=query,
-#         )
-#
-#     def get_parameterized_one_liner(self, params: Dict) -> str:
-#         return f"{toolset_name_for_one_liner(self._toolset.name)}: Fetched Tempo Traces (min_duration={params.get('min_duration')})"
-
-
-# class GetTempoTags(Tool):
-#     def __init__(self, toolset: BaseGrafanaTempoToolset):
-#         super().__init__(
-#             name="fetch_tempo_tags",
-#             description="List the tags available in Tempo",
-#             parameters={
-#                 "start_datetime": ToolParameter(
-#                     description=f"The beginning time boundary for the search period. String in RFC3339 format. If a negative integer, the number of seconds relative to the end_timestamp. Defaults to -{DEFAULT_TAGS_TIME_SPAN_SECONDS}",
-#                     type="string",
-#                     required=False,
-#                 ),
-#                 "end_datetime": ToolParameter(
-#                     description="The ending time boundary for the search period. String in RFC3339 format. Defaults to NOW().",
-#                     type="string",
-#                     required=False,
-#                 ),
-#             },
-#         )
-#         self._toolset = toolset
-#
-#     def _invoke(self, params: Dict, user_approved: bool = False) -> StructuredToolResult:
-#         # Create API instance
-#         api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
-#
-#         start, end = process_timestamps_to_int(
-#             start=params.get("start_datetime"),
-#             end=params.get("end_datetime"),
-#             default_time_span_seconds=DEFAULT_TAGS_TIME_SPAN_SECONDS,
-#         )
-#
-#         try:
-#             data = api.search_tag_names_v2(start=start, end=end)
-#             return StructuredToolResult(
-#                 status=ToolResultStatus.SUCCESS,
-#                 data=yaml.dump(data.get("scopes")),
-#                 params=params,
-#             )
-#         except Exception as e:
-#             return StructuredToolResult(
-#                 status=ToolResultStatus.ERROR,
-#                 error=f"Failed to retrieve tags: {str(e)}",
-#                 params=params,
-#             )
-#
-#     def get_parameterized_one_liner(self, params: Dict) -> str:
-#         return f"{toolset_name_for_one_liner(self._toolset.name)}: Fetched Tempo tags"
-#
-
-
-# class GetTempoTraceById(Tool):
-#     def __init__(self, toolset: BaseGrafanaTempoToolset):
-#         super().__init__(
-#             name="fetch_tempo_trace_by_id",
-#             description="""Retrieves detailed information about a Tempo trace using its trace ID. Use this to investigate a trace.""",
-#             parameters={
-#                 "trace_id": ToolParameter(
-#                     description="The unique trace ID to fetch.",
-#                     type="string",
-#                     required=True,
-#                 ),
-#             },
-#         )
-#         self._toolset = toolset
-#
-#     def _invoke(self, params: Dict, user_approved: bool = False) -> StructuredToolResult:
-#         # Create API instance
-#         api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
-#
-#         labels_mapping = self._toolset.grafana_config.labels
-#         labels = list(labels_mapping.model_dump().values())
-#
-#         # Get raw trace data
-#         trace_data = api.query_trace_by_id_v2(
-#             trace_id=get_param_or_raise(params, "trace_id")
-#         )
-#
-#         # Process the trace data (new API returns raw data)
-#         formatted_trace = process_trace(trace_data, labels)
-#
-#         return StructuredToolResult(
-#             status=ToolResultStatus.SUCCESS,
-#             data=formatted_trace,
-#             params=params,
-#         )
-#
-#     def get_parameterized_one_liner(self, params: Dict) -> str:
-#         return f"{toolset_name_for_one_liner(self._toolset.name)}: Fetched Tempo Trace (trace_id={params.get('trace_id')})"
-#
+    @staticmethod
+    def adjust_start_end_time(params: Dict) -> Tuple[int, int]:
+        return process_timestamps_to_int(
+            start=params.get("start"),
+            end=params.get("end"),
+            default_time_span_seconds=DEFAULT_GRAPH_TIME_SPAN_SECONDS,
+        )
 
 
 class FetchTracesSimpleComparison(Tool):
     def __init__(self, toolset: BaseGrafanaTempoToolset):
         super().__init__(
-            name="fetch_tempo_traces_comparative_sample",
+            name="tempo_fetch_traces_comparative_sample",
             description="""Fetches statistics and representative samples of fast, slow, and typical traces for performance analysis. Requires either a `base_query` OR at least one of `service_name`, `pod_name`, `namespace_name`, `deployment_name`, `node_name`.
 
 Important: call this tool first when investigating performance issues via traces. This tool provides comprehensive analysis for identifying patterns.
@@ -351,7 +158,11 @@ Examples:
                     required=False,
                 ),
                 "base_query": ToolParameter(
-                    description="Custom TraceQL filter",
+                    description=(
+                        "Custom TraceQL filter. Supports span/resource attributes, "
+                        "duration, and aggregates (count(), avg(), min(), max(), sum()). "
+                        "Examples: '{span.http.status_code>=400}', '{duration>100ms}'"
+                    ),
                     type="string",
                     required=False,
                 ),
@@ -360,13 +171,15 @@ Examples:
                     type="integer",
                     required=False,
                 ),
-                "start_datetime": ToolParameter(
-                    description=f"The beginning time boundary for the trace search period. String in RFC3339 format. If a negative integer, the number of seconds relative to the end_timestamp. Defaults to -{DEFAULT_TRACES_TIME_SPAN_SECONDS}",
+                "start": ToolParameter(
+                    description=standard_start_datetime_tool_param_description(
+                        DEFAULT_GRAPH_TIME_SPAN_SECONDS
+                    ),
                     type="string",
                     required=False,
                 ),
-                "end_datetime": ToolParameter(
-                    description="The ending time boundary for the trace search period. String in RFC3339 format. Defaults to NOW().",
+                "end": ToolParameter(
+                    description=STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION,
                     type="string",
                     required=False,
                 ),
@@ -374,6 +187,14 @@ Examples:
         )
         self._toolset = toolset
 
+    @staticmethod
+    def validate_params(params: Dict[str, Any], expected_params: List[str]):
+        for param in expected_params:
+            if param in params and params[param] not in (None, "", [], {}):
+                return None
+
+        return f"At least one of the following argument is expected but none were set: {expected_params}"
+
     def _invoke(
         self, params: dict, user_approved: bool = False
     ) -> StructuredToolResult:
@@ -386,7 +207,7 @@ Examples:
                 filters = self._toolset.build_k8s_filters(params, use_exact_match=False)
 
                 # Validate that at least one parameter was provided
-                invalid_params_error = validate_params(
+                invalid_params_error = FetchTracesSimpleComparison.validate_params(
                     params,
                     [
                         "service_name",
@@ -398,7 +219,7 @@ Examples:
                 )
                 if invalid_params_error:
                     return StructuredToolResult(
-                        status=ToolResultStatus.ERROR,
+                        status=StructuredToolResultStatus.ERROR,
                         error=invalid_params_error,
                         params=params,
                     )
@@ -407,11 +228,7 @@ Examples:
 
             sample_count = params.get("sample_count", 3)
 
-            start, end = process_timestamps_to_int(
-                params.get("start_datetime"),
-                params.get("end_datetime"),
-                default_time_span_seconds=DEFAULT_TRACES_TIME_SPAN_SECONDS,
-            )
+            start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
 
             # Create API instance
             api = GrafanaTempoAPI(
@@ -441,7 +258,7 @@ Examples:
             traces = all_traces_response.get("traces", [])
             if not traces:
                 return StructuredToolResult(
-                    status=ToolResultStatus.SUCCESS,
+                    status=StructuredToolResultStatus.SUCCESS,
                     data="No traces found matching the query",
                     params=params,
                 )
@@ -518,14 +335,14 @@ Examples:
 
             # Return as YAML for readability
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=yaml.dump(result, default_flow_style=False, sort_keys=False),
                 params=params,
             )
 
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=f"Error fetching traces: {str(e)}",
                 params=params,
             )
@@ -534,21 +351,39 @@ Examples:
         return f"{toolset_name_for_one_liner(self._toolset.name)}: Simple Tempo Traces Comparison"
 
 
-# New tools matching GrafanaTempoAPI methods
-
-
 class SearchTracesByQuery(Tool):
     def __init__(self, toolset: BaseGrafanaTempoToolset):
         super().__init__(
-            name="search_traces_by_query",
+            name="tempo_search_traces_by_query",
             description=(
                 "Search for traces using TraceQL query language. "
-                "Uses the Tempo API endpoint: GET /api/search with 'q' parameter. "
-                'TraceQL allows complex filtering like: {resource.service.name="api"} && {span.http.status_code=500}'
+                "Uses the Tempo API endpoint: GET /api/search with 'q' parameter.\n\n"
+                "TraceQL can select traces based on:\n"
+                "- Span and resource attributes\n"
+                "- Timing and duration\n"
+                "- Aggregate functions:\n"
+                "  • count() - Count number of spans\n"
+                "  • avg(attribute) - Calculate average\n"
+                "  • min(attribute) - Find minimum value\n"
+                "  • max(attribute) - Find maximum value\n"
+                "  • sum(attribute) - Sum values\n\n"
+                "Examples:\n"
+                '- Specific operation: {resource.service.name = "frontend" && name = "POST /api/orders"}\n'
+                '- Error traces: {resource.service.name="frontend" && name = "POST /api/orders" && status = error}\n'
+                '- HTTP errors: {resource.service.name="frontend" && name = "POST /api/orders" && span.http.status_code >= 500}\n'
+                '- Multi-service: {span.service.name="frontend" && name = "GET /api/products/{id}"} && {span.db.system="postgresql"}\n'
+                "- With aggregates: { status = error } | by(resource.service.name) | count() > 1"
             ),
             parameters={
                 "q": ToolParameter(
-                    description="TraceQL query (e.g., '{resource.service.name=\"api\" && span.http.status_code=500}')",
+                    description=(
+                        "TraceQL query. Supports filtering by span/resource attributes, "
+                        "duration, and aggregate functions (count(), avg(), min(), max(), sum()). "
+                        "Examples: '{resource.service.name = \"frontend\"}', "
+                        '\'{resource.service.name="frontend" && name = "POST /api/orders" && status = error}\', '
+                        '\'{resource.service.name="frontend" && name = "POST /api/orders" && span.http.status_code >= 500}\', '
+                        "'{} | count() > 10'"
+                    ),
                     type="string",
                     required=True,
                 ),
@@ -558,13 +393,15 @@ class SearchTracesByQuery(Tool):
                     required=False,
                 ),
                 "start": ToolParameter(
-                    description="Start time in Unix epoch seconds",
-                    type="integer",
+                    description=standard_start_datetime_tool_param_description(
+                        DEFAULT_GRAPH_TIME_SPAN_SECONDS
+                    ),
+                    type="string",
                     required=False,
                 ),
                 "end": ToolParameter(
-                    description="End time in Unix epoch seconds",
-                    type="integer",
+                    description=STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION,
+                    type="string",
                     required=False,
                 ),
                 "spss": ToolParameter(
@@ -581,22 +418,24 @@ class SearchTracesByQuery(Tool):
     ) -> StructuredToolResult:
         api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
 
+        start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
+
         try:
             result = api.search_traces_by_query(
                 q=params["q"],
                 limit=params.get("limit"),
-                start=params.get("start"),
-                end=params.get("end"),
+                start=start,
+                end=end,
                 spss=params.get("spss"),
             )
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=yaml.dump(result, default_flow_style=False),
                 params=params,
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=str(e),
                 params=params,
             )
@@ -608,15 +447,15 @@ class SearchTracesByQuery(Tool):
 class SearchTracesByTags(Tool):
     def __init__(self, toolset: BaseGrafanaTempoToolset):
         super().__init__(
-            name="search_traces_by_tags",
+            name="tempo_search_traces_by_tags",
             description=(
                 "Search for traces using logfmt-encoded tags. "
                 "Uses the Tempo API endpoint: GET /api/search with 'tags' parameter. "
-                'Example: resource.service.name="api" http.status_code="500"'
+                'Example: service.name="api" http.status_code="500"'
             ),
             parameters={
                 "tags": ToolParameter(
-                    description='Logfmt-encoded span/process attributes (e.g., \'resource.service.name="api" http.status_code="500"\')',
+                    description='Logfmt-encoded span/process attributes (e.g., \'service.name="api" http.status_code="500"\')',
                     type="string",
                     required=True,
                 ),
@@ -636,13 +475,15 @@ class SearchTracesByTags(Tool):
                     required=False,
                 ),
                 "start": ToolParameter(
-                    description="Start time in Unix epoch seconds",
-                    type="integer",
+                    description=standard_start_datetime_tool_param_description(
+                        DEFAULT_GRAPH_TIME_SPAN_SECONDS
+                    ),
+                    type="string",
                     required=False,
                 ),
                 "end": ToolParameter(
-                    description="End time in Unix epoch seconds",
-                    type="integer",
+                    description=STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION,
+                    type="string",
                     required=False,
                 ),
                 "spss": ToolParameter(
@@ -659,24 +500,26 @@ class SearchTracesByTags(Tool):
     ) -> StructuredToolResult:
         api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
 
+        start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
+
         try:
             result = api.search_traces_by_tags(
                 tags=params["tags"],
                 min_duration=params.get("min_duration"),
                 max_duration=params.get("max_duration"),
                 limit=params.get("limit"),
-                start=params.get("start"),
-                end=params.get("end"),
+                start=start,
+                end=end,
                 spss=params.get("spss"),
             )
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=yaml.dump(result, default_flow_style=False),
                 params=params,
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=str(e),
                 params=params,
             )
@@ -688,7 +531,7 @@ class SearchTracesByTags(Tool):
 class QueryTraceById(Tool):
     def __init__(self, toolset: BaseGrafanaTempoToolset):
         super().__init__(
-            name="query_trace_by_id",
+            name="tempo_query_trace_by_id",
             description=(
                 "Retrieve detailed trace information by trace ID. "
                 "Uses the Tempo API endpoint: GET /api/v2/traces/{trace_id}. "
@@ -701,13 +544,15 @@ class QueryTraceById(Tool):
                     required=True,
                 ),
                 "start": ToolParameter(
-                    description="Optional start time in Unix epoch seconds",
-                    type="integer",
+                    description=standard_start_datetime_tool_param_description(
+                        DEFAULT_GRAPH_TIME_SPAN_SECONDS
+                    ),
+                    type="string",
                     required=False,
                 ),
                 "end": ToolParameter(
-                    description="Optional end time in Unix epoch seconds",
-                    type="integer",
+                    description=STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION,
+                    type="string",
                     required=False,
                 ),
             },
@@ -719,22 +564,24 @@ class QueryTraceById(Tool):
     ) -> StructuredToolResult:
         api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
 
+        start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
+
         try:
             trace_data = api.query_trace_by_id_v2(
                 trace_id=params["trace_id"],
-                start=params.get("start"),
-                end=params.get("end"),
+                start=start,
+                end=end,
             )
 
             # Return raw trace data as YAML for readability
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=yaml.dump(trace_data, default_flow_style=False),
                 params=params,
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=str(e),
                 params=params,
             )
@@ -746,7 +593,7 @@ class QueryTraceById(Tool):
 class SearchTagNames(Tool):
     def __init__(self, toolset: BaseGrafanaTempoToolset):
         super().__init__(
-            name="search_tag_names",
+            name="tempo_search_tag_names",
             description=(
                 "Discover available tag names across traces. "
                 "Uses the Tempo API endpoint: GET /api/v2/search/tags. "
@@ -764,13 +611,15 @@ class SearchTagNames(Tool):
                     required=False,
                 ),
                 "start": ToolParameter(
-                    description="Start time in Unix epoch seconds",
-                    type="integer",
+                    description=standard_start_datetime_tool_param_description(
+                        DEFAULT_GRAPH_TIME_SPAN_SECONDS
+                    ),
+                    type="string",
                     required=False,
                 ),
                 "end": ToolParameter(
-                    description="End time in Unix epoch seconds",
-                    type="integer",
+                    description=STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION,
+                    type="string",
                     required=False,
                 ),
                 "limit": ToolParameter(
@@ -792,23 +641,25 @@ class SearchTagNames(Tool):
     ) -> StructuredToolResult:
         api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
 
+        start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
+
         try:
             result = api.search_tag_names_v2(
                 scope=params.get("scope"),
                 q=params.get("q"),
-                start=params.get("start"),
-                end=params.get("end"),
+                start=start,
+                end=end,
                 limit=params.get("limit"),
                 max_stale_values=params.get("max_stale_values"),
             )
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=yaml.dump(result, default_flow_style=False),
                 params=params,
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=str(e),
                 params=params,
             )
@@ -820,7 +671,7 @@ class SearchTagNames(Tool):
 class SearchTagValues(Tool):
     def __init__(self, toolset: BaseGrafanaTempoToolset):
         super().__init__(
-            name="search_tag_values",
+            name="tempo_search_tag_values",
             description=(
                 "Get all values for a specific tag. "
                 "Uses the Tempo API endpoint: GET /api/v2/search/tag/{tag}/values. "
@@ -838,13 +689,15 @@ class SearchTagValues(Tool):
                     required=False,
                 ),
                 "start": ToolParameter(
-                    description="Start time in Unix epoch seconds",
-                    type="integer",
+                    description=standard_start_datetime_tool_param_description(
+                        DEFAULT_GRAPH_TIME_SPAN_SECONDS
+                    ),
+                    type="string",
                     required=False,
                 ),
                 "end": ToolParameter(
-                    description="End time in Unix epoch seconds",
-                    type="integer",
+                    description=STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION,
+                    type="string",
                     required=False,
                 ),
                 "limit": ToolParameter(
@@ -866,23 +719,25 @@ class SearchTagValues(Tool):
     ) -> StructuredToolResult:
         api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
 
+        start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
+
         try:
             result = api.search_tag_values_v2(
                 tag=params["tag"],
                 q=params.get("q"),
-                start=params.get("start"),
-                end=params.get("end"),
+                start=start,
+                end=end,
                 limit=params.get("limit"),
                 max_stale_values=params.get("max_stale_values"),
             )
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=yaml.dump(result, default_flow_style=False),
                 params=params,
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=str(e),
                 params=params,
             )
@@ -894,7 +749,7 @@ class SearchTagValues(Tool):
 class QueryMetricsInstant(Tool):
     def __init__(self, toolset: BaseGrafanaTempoToolset):
         super().__init__(
-            name="query_metrics_instant",
+            name="tempo_query_metrics_instant",
             description=(
                 "Compute a single TraceQL metric value across time range. "
                 "Uses the Tempo API endpoint: GET /api/metrics/query. "
@@ -924,17 +779,14 @@ class QueryMetricsInstant(Tool):
                     required=True,
                 ),
                 "start": ToolParameter(
-                    description="Start time (Unix seconds/nanoseconds/RFC3339)",
+                    description=standard_start_datetime_tool_param_description(
+                        DEFAULT_GRAPH_TIME_SPAN_SECONDS
+                    ),
                     type="string",
                     required=False,
                 ),
                 "end": ToolParameter(
-                    description="End time (Unix seconds/nanoseconds/RFC3339)",
-                    type="string",
-                    required=False,
-                ),
-                "since": ToolParameter(
-                    description="Duration string (e.g., '1h', '30m')",
+                    description=STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION,
                     type="string",
                     required=False,
                 ),
@@ -947,21 +799,22 @@ class QueryMetricsInstant(Tool):
     ) -> StructuredToolResult:
         api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
 
+        start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
+
         try:
             result = api.query_metrics_instant(
                 q=params["q"],
-                start=params.get("start"),
-                end=params.get("end"),
-                since=params.get("since"),
+                start=start,
+                end=end,
             )
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=yaml.dump(result, default_flow_style=False),
                 params=params,
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=str(e),
                 params=params,
             )
@@ -975,7 +828,7 @@ class QueryMetricsInstant(Tool):
 class QueryMetricsRange(Tool):
     def __init__(self, toolset: BaseGrafanaTempoToolset):
         super().__init__(
-            name="query_metrics_range",
+            name="tempo_query_metrics_range",
             description=(
                 "Get time series data from TraceQL metrics queries. "
                 "Uses the Tempo API endpoint: GET /api/metrics/query_range. "
@@ -1007,17 +860,14 @@ class QueryMetricsRange(Tool):
                     required=False,
                 ),
                 "start": ToolParameter(
-                    description="Start time (Unix seconds/nanoseconds/RFC3339)",
+                    description=standard_start_datetime_tool_param_description(
+                        DEFAULT_GRAPH_TIME_SPAN_SECONDS
+                    ),
                     type="string",
                     required=False,
                 ),
                 "end": ToolParameter(
-                    description="End time (Unix seconds/nanoseconds/RFC3339)",
-                    type="string",
-                    required=False,
-                ),
-                "since": ToolParameter(
-                    description="Duration string (e.g., '3h', '1d')",
+                    description=STANDARD_END_DATETIME_TOOL_PARAM_DESCRIPTION,
                     type="string",
                     required=False,
                 ),
@@ -1035,23 +885,34 @@ class QueryMetricsRange(Tool):
     ) -> StructuredToolResult:
         api = GrafanaTempoAPI(self._toolset.grafana_config, use_post=TEMPO_API_USE_POST)
 
+        start, end = BaseGrafanaTempoToolset.adjust_start_end_time(params)
+
+        # Calculate appropriate step
+        step_param = params.get("step")
+        step_seconds = duration_string_to_seconds(step_param) if step_param else None
+        adjusted_step = adjust_step_for_max_points(
+            end - start,
+            int(MAX_GRAPH_POINTS),
+            step_seconds,
+        )
+        step = seconds_to_duration_string(adjusted_step)
+
         try:
             result = api.query_metrics_range(
                 q=params["q"],
-                step=params.get("step"),
-                start=params.get("start"),
-                end=params.get("end"),
-                since=params.get("since"),
+                step=step,
+                start=start,
+                end=end,
                 exemplars=params.get("exemplars"),
             )
             return StructuredToolResult(
-                status=ToolResultStatus.SUCCESS,
+                status=StructuredToolResultStatus.SUCCESS,
                 data=yaml.dump(result, default_flow_style=False),
                 params=params,
             )
         except Exception as e:
             return StructuredToolResult(
-                status=ToolResultStatus.ERROR,
+                status=StructuredToolResultStatus.ERROR,
                 error=str(e),
                 params=params,
             )
@@ -1069,9 +930,6 @@ class GrafanaTempoToolset(BaseGrafanaTempoToolset):
             docs_url="https://holmesgpt.dev/data-sources/builtin-toolsets/grafanatempo/",
             tools=[
                 FetchTracesSimpleComparison(self),
-                # GetTempoTraces(self),
-                # GetTempoTraceById(self),
-                # GetTempoTags(self),
                 SearchTracesByQuery(self),
                 SearchTracesByTags(self),
                 QueryTraceById(self),