Metrics tool supports bandwidth usage (#34)

Author: metonym

README.md

@@ -220,7 +220,7 @@ feedback or would like to report a bug or feature request, please [create a GitH
 
 - **get_metrics** - Get performance metrics for any Render resource (services, Postgres databases, key-value stores). Metrics may be empty if the metric is not valid for the given resource
   - `resourceId`: The ID of the resource to get metrics for (service ID, Postgres ID, or key-value store ID) (string, required)
-  - `metricTypes`: Which metrics to fetch (array of strings, required). Accepted values: 'cpu_usage', 'cpu_limit', 'cpu_target', 'memory_usage', 'memory_limit', 'memory_target', 'http_request_count', 'active_connections', 'instance_count', 'http_latency'. CPU usage/limits/targets, memory usage/limits/targets, and instance count metrics are available for all resources. HTTP request counts and response time metrics are only available for services. Active connection metrics are only available for databases and key-value stores. Limits show resource constraints, targets show autoscaling thresholds
+  - `metricTypes`: Which metrics to fetch (array of strings, required). Accepted values: 'cpu_usage', 'cpu_limit', 'cpu_target', 'memory_usage', 'memory_limit', 'memory_target', 'http_request_count', 'active_connections', 'instance_count', 'http_latency', 'bandwidth_usage'. CPU usage/limits/targets, memory usage/limits/targets, and instance count metrics are available for all resources. HTTP request counts and response time metrics, and bandwidth usage metrics are only available for services. Active connection metrics are only available for databases and key-value stores. Limits show resource constraints, targets show autoscaling thresholds
   - `startTime`: Start time for metrics query in RFC3339 format (e.g., '2024-01-01T12:00:00Z'), defaults to 1 hour ago. The start time must be within the last 30 days (string, optional)
   - `endTime`: End time for metrics query in RFC3339 format (e.g., '2024-01-01T13:00:00Z'), defaults to the current time. The end time must be within the last 30 days (string, optional)
   - `resolution`: Time resolution for data points in seconds. Lower values provide more granular data. Higher values provide more aggregated data points. API defaults to 60 seconds if not provided, minimum 30 seconds (number, optional)

pkg/metrics/repo.go

@@ -21,6 +21,7 @@ type MetricsClient interface {
 	GetCpuTargetWithResponse(ctx context.Context, params *client.GetCpuTargetParams, reqEditors ...client.RequestEditorFn) (*client.GetCpuTargetResponse, error)
 	GetMemoryLimitWithResponse(ctx context.Context, params *client.GetMemoryLimitParams, reqEditors ...client.RequestEditorFn) (*client.GetMemoryLimitResponse, error)
 	GetMemoryTargetWithResponse(ctx context.Context, params *client.GetMemoryTargetParams, reqEditors ...client.RequestEditorFn) (*client.GetMemoryTargetResponse, error)
+	GetBandwidthWithResponse(ctx context.Context, params *client.GetBandwidthParams, reqEditors ...client.RequestEditorFn) (*client.GetBandwidthResponse, error)
 }
 
 type Repo struct {
@@ -44,6 +45,7 @@ const (
 	MetricTypeCPUTarget         MetricType = "cpu_target"
 	MetricTypeMemoryLimit       MetricType = "memory_limit"
 	MetricTypeMemoryTarget      MetricType = "memory_target"
+	MetricTypeBandwidthUsage    MetricType = "bandwidth_usage"
 )
 
 type MetricsRequest struct {
@@ -124,6 +126,8 @@ func (r *Repo) fetchMetric(ctx context.Context, resourceId string, metricType Me
 		data, err = r.getMemoryLimit(ctx, resourceId, req)
 	case MetricTypeMemoryTarget:
 		data, err = r.getMemoryTarget(ctx, resourceId, req)
+	case MetricTypeBandwidthUsage:
+		data, err = r.getBandwidthUsage(ctx, resourceId, req)
 	default:
 		return MetricData{}, fmt.Errorf("unsupported metric type: %s", metricType)
 	}
@@ -483,3 +487,29 @@ func (r *Repo) getMemoryTarget(ctx context.Context, resourceId string, req Metri
 
 	return *resp.JSON200, nil
 }
+
+func (r *Repo) getBandwidthUsage(ctx context.Context, resourceId string, req MetricsRequest) (metricstypes.TimeSeriesCollection, error) {
+	params := &client.GetBandwidthParams{
+		StartTime: req.StartTime,
+		EndTime:   req.EndTime,
+	}
+
+	// Set resource parameter - use ServiceResourceQueryParam for bandwidth
+	serviceResource := metricstypes.ServiceResourceQueryParam(resourceId)
+	params.Resource = &serviceResource
+
+	resp, err := r.client.GetBandwidthWithResponse(ctx, params)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get bandwidth usage metrics: %w", err)
+	}
+
+	if resp.StatusCode() != 200 {
+		return nil, fmt.Errorf("bandwidth usage metrics API returned status %d", resp.StatusCode())
+	}
+
+	if resp.JSON200 == nil {
+		return metricstypes.TimeSeriesCollection{}, nil
+	}
+
+	return *resp.JSON200, nil
+}

pkg/metrics/test_helpers.go

@@ -72,6 +72,11 @@ func (m *MockClientWithResponses) GetMemoryTargetWithResponse(ctx context.Contex
 	return args.Get(0).(*client.GetMemoryTargetResponse), args.Error(1)
 }
 
+func (m *MockClientWithResponses) GetBandwidthWithResponse(ctx context.Context, params *client.GetBandwidthParams, reqEditors ...client.RequestEditorFn) (*client.GetBandwidthResponse, error) {
+	args := m.Called(ctx, params, reqEditors)
+	return args.Get(0).(*client.GetBandwidthResponse), args.Error(1)
+}
+
 // MetricsTestSuite provides shared setup and utilities for metrics tests
 type MetricsTestSuite struct {
 	suite.Suite
@@ -232,6 +237,17 @@ func NewMockMemoryTargetResponse(value float32) *client.GetMemoryTargetResponse
 	}
 }
 
+func NewMockBandwidthResponse(value float32) *client.GetBandwidthResponse {
+	return &client.GetBandwidthResponse{
+		HTTPResponse: &http.Response{StatusCode: 200},
+		JSON200: &metricstypes.TimeSeriesCollection{{
+			Unit:   "bytes",
+			Labels: []metricstypes.Label{{Field: "instance", Value: "srv-123-abc"}},
+			Values: []metricstypes.TimeSeriesValue{{Timestamp: testTimestamp, Value: value}},
+		}},
+	}
+}
+
 func NewMockErrorResponse(statusCode int) *http.Response {
 	return &http.Response{StatusCode: statusCode}
 }

pkg/metrics/tools.go

@@ -26,7 +26,7 @@ func getMetrics(metricsRepo *Repo) server.ServerTool {
 	return server.ServerTool{
 		Tool: mcp.NewTool("get_metrics",
 			mcp.WithDescription("Get performance metrics for any Render resource (services, Postgres databases, key-value stores). "+
-				"Supports CPU usage/limits/targets, memory usage/limits/targets, service instance counts, HTTP request counts and response time metrics, database active connection counts for debugging, capacity planning, and performance optimization. "+
+				"Supports CPU usage/limits/targets, memory usage/limits/targets, service instance counts, HTTP request counts and response time metrics, bandwidth usage metrics, database active connection counts for debugging, capacity planning, and performance optimization. "+
 				"Returns time-series data with timestamps and values for the specified time range. "+
 				"HTTP metrics support filtering by host and path for more granular analysis. "+
 				"Limits and targets help understand resource constraints and autoscaling thresholds. "+
@@ -44,7 +44,7 @@ func getMetrics(metricsRepo *Repo) server.ServerTool {
 				mcp.Required(),
 				mcp.Description("Which metrics to fetch. "+
 					"CPU usage/limits/targets, memory usage/limits/targets, and instance count metrics are available for all resources. "+
-					"HTTP request counts and response time metrics are only available for services. "+
+					"HTTP request counts and response time metrics, and bandwidth usage metrics are only available for services. "+
 					"Active connection metrics are only available for databases and key-value stores. "+
 					"Limits show resource constraints, targets show autoscaling thresholds."),
 				mcp.Items(map[string]interface{}{
@@ -55,6 +55,7 @@ func getMetrics(metricsRepo *Repo) server.ServerTool {
 						string(MetricTypeInstanceCount), string(MetricTypeHTTPLatency),
 						string(MetricTypeCPULimit), string(MetricTypeCPUTarget),
 						string(MetricTypeMemoryLimit), string(MetricTypeMemoryTarget),
+						string(MetricTypeBandwidthUsage),
 					},
 				}),
 			),
@@ -133,10 +134,10 @@ func getMetrics(metricsRepo *Repo) server.ServerTool {
 
 				metricType := MetricType(mtStr)
 				switch metricType {
-				case MetricTypeCPUUsage, MetricTypeMemoryUsage, MetricTypeHTTPRequestCount, MetricTypeActiveConnections, MetricTypeInstanceCount, MetricTypeHTTPLatency, MetricTypeCPULimit, MetricTypeCPUTarget, MetricTypeMemoryLimit, MetricTypeMemoryTarget:
+				case MetricTypeCPUUsage, MetricTypeMemoryUsage, MetricTypeHTTPRequestCount, MetricTypeActiveConnections, MetricTypeInstanceCount, MetricTypeHTTPLatency, MetricTypeCPULimit, MetricTypeCPUTarget, MetricTypeMemoryLimit, MetricTypeMemoryTarget, MetricTypeBandwidthUsage:
 					metricTypes = append(metricTypes, metricType)
 				default:
-					return mcp.NewToolResultError(fmt.Sprintf("invalid metric type: %s. Must be one of: cpu_usage, memory_usage, http_request_count, active_connections, instance_count, http_latency, cpu_limit, cpu_target, memory_limit, memory_target", mtStr)), nil
+					return mcp.NewToolResultError(fmt.Sprintf("invalid metric type: %s. Must be one of: cpu_usage, memory_usage, http_request_count, active_connections, instance_count, http_latency, cpu_limit, cpu_target, memory_limit, memory_target, bandwidth_usage", mtStr)), nil
 				}
 			}
 

pkg/metrics/tools_test.go

@@ -121,6 +121,15 @@ func (s *MetricsIntegrationSuite) TestSuccessfulMetricsFetching() {
 			},
 			value: 1073741824,
 		},
+		{
+			name:       "Bandwidth usage success",
+			metricType: MetricTypeBandwidthUsage,
+			setupMock: func() {
+				s.mockClient.On("GetBandwidthWithResponse", mock.Anything, mock.Anything, mock.Anything).
+					Return(NewMockBandwidthResponse(1048576), nil)
+			},
+			value: 1048576,
+		},
 	}
 
 	for _, tt := range tests {