docs: update CHANGELOG with new health and readiness checks, including endpoint modifications and test updates

Author: randygrok

CHANGELOG.md

@@ -14,8 +14,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added comprehensive health endpoint documentation in `docs/learn/config.md#health-endpoints` explaining liveness vs readiness checks, Kubernetes probe configuration, and usage examples ([#2800](https://github.com/evstack/ev-node/pull/2800))
 - Added P2P listening check to `/health/ready` endpoint to verify P2P network is ready to accept connections ([#2800](https://github.com/evstack/ev-node/pull/2800))
 - Added aggregator block production rate check to `/health/ready` endpoint to ensure aggregators are producing blocks within expected timeframe (5x block time) ([#2800](https://github.com/evstack/ev-node/pull/2800))
-- Added `GetReadiness()` method to Go RPC client for checking `/health/ready` endpoint ([#2800](https://github.com/evstack/ev-node/pull/2800))
-- Added `ReadinessStatus` type to Go RPC client with READY/UNREADY/UNKNOWN states ([#2800](https://github.com/evstack/ev-node/pull/2800))
 - Added `readyz()` and `is_ready()` methods to Rust `HealthClient` for checking `/health/ready` endpoint ([#2800](https://github.com/evstack/ev-node/pull/2800))
 - Added `ReadinessStatus` enum to Rust client with Ready/Unready/Unknown states ([#2800](https://github.com/evstack/ev-node/pull/2800))
 
@@ -33,7 +31,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **BREAKING:** Removed `evnode.v1.HealthService` gRPC endpoint in favor of HTTP health endpoints ([#2800](https://github.com/evstack/ev-node/pull/2800))
   - Migration: Use `GET /health/live` instead of `HealthService.Livez()` gRPC call
   - See migration guide: `docs/learn/config.md#health-endpoints`
-  - Affected clients: Go client (`pkg/rpc/client`), Rust client (`client/crates/client`), and any external services using the gRPC health endpoint
+  - Affected clients: Rust client (`client/crates/client`) and any external services using the gRPC health endpoint
 - Removed `proto/evnode/v1/health.proto` and generated protobuf files ([#2800](https://github.com/evstack/ev-node/pull/2800))
 
 ## v1.0.0-beta.9

node/single_sequencer_integration_test.go

@@ -419,19 +419,13 @@ func waitForBlockN(t *testing.T, n uint64, node *FullNode, blockInterval time.Du
 		return got >= n
 	}, timeout[0], blockInterval/2)
 }
-// TestReadinessEndpointWhenBlockProductionStops verifies that the readiness endpoint
-// correctly reports UNREADY state when an aggregator stops producing blocks.
 func TestReadinessEndpointWhenBlockProductionStops(t *testing.T) {
 	require := require.New(t)
 
-	// Set up configuration with specific block time for predictable readiness checks
 	config := getTestConfig(t, 1)
 	config.Node.Aggregator = true
 	config.Node.BlockTime = evconfig.DurationWrapper{Duration: 500 * time.Millisecond}
 	config.Node.MaxPendingHeadersAndData = 2
-
-	// Set DA block time large enough to avoid header submission to DA layer
-	// This will cause block production to stop once MaxPendingHeadersAndData is reached
 	config.DA.BlockTime = evconfig.DurationWrapper{Duration: 100 * time.Second}
 
 	node, cleanup := createNodeWithCleanup(t, config)
@@ -443,32 +437,20 @@ func TestReadinessEndpointWhenBlockProductionStops(t *testing.T) {
 	var runningWg sync.WaitGroup
 	startNodeInBackground(t, []*FullNode{node}, []context.Context{ctx}, &runningWg, 0, nil)
 
-	// Wait for first block to be produced
 	waitForBlockN(t, 1, node, config.Node.BlockTime.Duration)
 
-	// Create RPC client
 	rpcClient := NewRPCClient(config.RPC.Address)
 
-	// Verify readiness is READY while blocks are being produced
 	readiness, err := rpcClient.GetReadiness(ctx)
 	require.NoError(err)
 	require.Equal(client.ReadinessStatus_READY, readiness, "Readiness should be READY while producing blocks")
 
-	// Wait for block production to stop (when MaxPendingHeadersAndData is reached)
 	time.Sleep(time.Duration(config.Node.MaxPendingHeadersAndData+2) * config.Node.BlockTime.Duration)
 
-	// Get the height to confirm blocks stopped
 	height, err := getNodeHeight(node, Store)
 	require.NoError(err)
 	require.LessOrEqual(height, config.Node.MaxPendingHeadersAndData)
 
-	// Readiness check threshold for aggregators:
-	// blockTime = 500ms
-	// maxAllowedDelay = blockTime * 5 = 2500ms = 2.5s
-	// After 2.5s without producing a block, aggregator should be UNREADY
-
-	// Poll for readiness to transition to UNREADY
-	// This is more robust than fixed time.Sleep as it handles timing variations
 	require.Eventually(func() bool {
 		readiness, err := rpcClient.GetReadiness(ctx)
 		if err != nil {
@@ -477,6 +459,5 @@ func TestReadinessEndpointWhenBlockProductionStops(t *testing.T) {
 		return readiness == client.ReadinessStatus_UNREADY
 	}, 10*time.Second, 100*time.Millisecond, "Readiness should be UNREADY after aggregator stops producing blocks (5x block time)")
 
-	// Stop the node and wait for shutdown
 	shutdownAndWait(t, []context.CancelFunc{cancel}, &runningWg, 10*time.Second)
 }

pkg/rpc/client/client.go

@@ -2,10 +2,7 @@ package client
 
 import (
 	"context"
-	"fmt"
-	"io"
 	"net/http"
-	"strings"
 
 	"connectrpc.com/connect"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -14,40 +11,11 @@ import (
 	rpc "github.com/evstack/ev-node/types/pb/evnode/v1/v1connect"
 )
 
-// HealthStatus represents the health status of a node
-type HealthStatus int32
-
-const (
-	// HealthStatus_UNKNOWN represents an unknown health status
-	HealthStatus_UNKNOWN HealthStatus = 0
-	// HealthStatus_PASS represents a healthy node
-	HealthStatus_PASS HealthStatus = 1
-	// HealthStatus_WARN represents a degraded but still serving node
-	HealthStatus_WARN HealthStatus = 2
-	// HealthStatus_FAIL represents a failed node
-	HealthStatus_FAIL HealthStatus = 3
-)
-
-func (h HealthStatus) String() string {
-	switch h {
-	case HealthStatus_PASS:
-		return "PASS"
-	case HealthStatus_WARN:
-		return "WARN"
-	case HealthStatus_FAIL:
-		return "FAIL"
-	default:
-		return "UNKNOWN"
-	}
-}
-
 // Client is the client for StoreService, P2PService, and ConfigService
 type Client struct {
 	storeClient  rpc.StoreServiceClient
 	p2pClient    rpc.P2PServiceClient
 	configClient rpc.ConfigServiceClient
-	baseURL      string
-	httpClient   *http.Client
 }
 
 // NewClient creates a new RPC client
@@ -61,8 +29,6 @@ func NewClient(baseURL string) *Client {
 		storeClient:  storeClient,
 		p2pClient:    p2pClient,
 		configClient: configClient,
-		baseURL:      baseURL,
-		httpClient:   httpClient,
 	}
 }
 
@@ -145,92 +111,6 @@ func (c *Client) GetNetInfo(ctx context.Context) (*pb.NetInfo, error) {
 	return resp.Msg.NetInfo, nil
 }
 
-// GetHealth calls the /health/live HTTP endpoint and returns the HealthStatus
-// This endpoint checks liveness (is the process alive and responsive?).
-// For readiness checks (can the node serve correct data?), use GetReadiness().
-func (c *Client) GetHealth(ctx context.Context) (HealthStatus, error) {
-	healthURL := fmt.Sprintf("%s/health/live", c.baseURL)
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, healthURL, nil)
-	if err != nil {
-		return HealthStatus_UNKNOWN, fmt.Errorf("failed to create health request: %w", err)
-	}
-
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return HealthStatus_UNKNOWN, fmt.Errorf("failed to get health: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return HealthStatus_UNKNOWN, fmt.Errorf("failed to read health response: %w", err)
-	}
-
-	// Parse the text response
-	status := strings.TrimSpace(string(body))
-	switch status {
-	case "OK":
-		return HealthStatus_PASS, nil
-	case "WARN":
-		return HealthStatus_WARN, nil
-	case "FAIL":
-		return HealthStatus_FAIL, nil
-	default:
-		return HealthStatus_UNKNOWN, fmt.Errorf("unknown health status: %s", status)
-	}
-}
-
-// ReadinessStatus represents the readiness state of a node
-type ReadinessStatus int32
-
-const (
-	ReadinessStatus_UNKNOWN ReadinessStatus = 0
-	ReadinessStatus_READY   ReadinessStatus = 1
-	ReadinessStatus_UNREADY ReadinessStatus = 2
-)
-
-func (s ReadinessStatus) String() string {
-	switch s {
-	case ReadinessStatus_READY:
-		return "READY"
-	case ReadinessStatus_UNREADY:
-		return "UNREADY"
-	default:
-		return "UNKNOWN"
-	}
-}
-
-// GetReadiness calls the /health/ready HTTP endpoint and returns the ReadinessStatus
-// This endpoint checks if the node can serve correct data to clients.
-// For liveness checks (is the process alive?), use GetHealth().
-func (c *Client) GetReadiness(ctx context.Context) (ReadinessStatus, error) {
-	readinessURL := fmt.Sprintf("%s/health/ready", c.baseURL)
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, readinessURL, nil)
-	if err != nil {
-		return ReadinessStatus_UNKNOWN, fmt.Errorf("failed to create readiness request: %w", err)
-	}
-
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return ReadinessStatus_UNKNOWN, fmt.Errorf("failed to get readiness: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return ReadinessStatus_UNKNOWN, fmt.Errorf("failed to read readiness response: %w", err)
-	}
-
-	// Parse the text response
-	status := strings.TrimSpace(string(body))
-	if strings.HasPrefix(status, "READY") {
-		return ReadinessStatus_READY, nil
-	} else if strings.HasPrefix(status, "UNREADY") {
-		return ReadinessStatus_UNREADY, nil
-	}
-	return ReadinessStatus_UNKNOWN, fmt.Errorf("unknown readiness status: %s", status)
-}
-
 // GetNamespace returns the namespace configuration for this network
 func (c *Client) GetNamespace(ctx context.Context) (*pb.GetNamespaceResponse, error) {
 	req := connect.NewRequest(&emptypb.Empty{})