[Testing] Logging improvements, better archival checks, and improved load test scripts (#311)

## Summary

Improve Near chain support, enhance error logging with emojis, and refactor E2E testing infrastructure

### Primary Changes:
- Remove `near` from EVM services and add proper Near-specific QoS configuration with TODO for full implementation
- Upgrade error logging from `Info` to `Error` level across QoS modules with descriptive emoji indicators
- Refactor E2E test execution flow by removing manual pass/fail tracking and improving test output formatting
- Optimize archival balance consensus checking with parallel processing and proper timeout handling

### Secondary changes:
- Add comprehensive TODO list for unsupported services in `services_shannon.yaml`
- Enhance E2E test progress reporting with better visual separators and service summaries
- Improve error messages with service-specific context and endpoint identification
- Add sorting functionality to service summary tables by success rate and latency metrics

Author: Olshansk

config/service_qos_config.go

@@ -385,9 +385,6 @@ var shannonServices = []ServiceQoSConfig{
 	// Moonriver
 	evm.NewEVMServiceQoSConfig("moonriver", "0x505", nil),
 
-	// Near
-	evm.NewEVMServiceQoSConfig("near", "0x18d", nil),
-
 	// opBNB
 	evm.NewEVMServiceQoSConfig("opbnb", "0xcc", nil),
 
@@ -406,6 +403,12 @@ var shannonServices = []ServiceQoSConfig{
 	// Sei
 	evm.NewEVMServiceQoSConfig("sei", "0x531", nil),
 
+	// *** Near EVM Services ***
+
+	// Near
+	// TODO_TECHDEBT: Add support for Near QoS
+	// near.NewNearServiceQoSConfig("near", "0x18d", nil),
+
 	// *** CometBFT Services ***
 
 	// TODO_MVP(@commoddity): Ensure that QoS observations are being applied correctly and that

e2e/config/services_shannon.yaml

@@ -5,6 +5,21 @@
 #   2. Use it as the source of truth for service QoS configs by embedding and YAML unmarshalling
 #   3. Remove the `config/service_qos_config.go` file in favour of using this file
 
+# TODO_TECHDEBT: Add support for the following services:
+# - bitcoin
+# - evmos
+# - near
+# - radix
+# - xrpl_evm_dev
+# - base-testnet
+# - moonriver
+# - sei
+# - svc-poktminer
+# - tron
+# - fraxtal
+# - kava
+# - sui
+
 ####################################################
 # ---------------- Shannon Services -------------- #
 ####################################################
@@ -292,6 +307,18 @@ services:
       transaction_hash: "0xfc30dd922a20302b88108422da4cfc09a82853d896a5f45f4ea777e12136af70"
       call_data: "0x18160ddd"
 
+  # TODO_TECHDEBT: Add support for Near E2E tests
+  # - name: "Shannon - near (Near) Test"
+  #   service_id: "near"
+  #   service_type: "near"
+  #   archival: true
+  #   service_params:
+  #     https://nearblocks.io/txns/4PVpwA42LpaUZ5LPD6fwNd94hjB5ue1ND2WSG4UzQVM8
+  #     contract_address: "usdt.tether-token.near"
+  #     contract_start_block: 74076817
+  #     transaction_hash: "4PVpwA42LpaUZ5LPD6fwNd94hjB5ue1ND2WSG4UzQVM8"
+  #     call_data: "0x18160ddd"
+
   # Shannon - Metis (Archival)
   - name: "Shannon - metis (Metis) Test"
     service_id: "metis"
@@ -563,11 +590,6 @@ services:
   #   service_id: "moonriver"
   #   service_type: "evm"
 
-  # # Shannon - Near
-  # - name: "Shannon - near (Near) Test"
-  #   service_id: "near"
-  #   service_type: "evm"
-
   # # Shannon - Radix
   # - name: "Shannon - radix (Radix) Test"
   #   service_id: "radix"

e2e/config_test.go

@@ -308,9 +308,9 @@ func (c *Config) getTestServices() ([]*TestService, error) {
 		for id := range serviceIdsWithNoTestCases {
 			missingServiceIds = append(missingServiceIds, id)
 		}
-		fmt.Printf("Warning: The following service IDs had no test cases: [%s]\n", strings.Join(missingServiceIds, ", "))
 		servicesFile := fmt.Sprintf(servicesFileTemplate, testProtocol)
-		return nil, fmt.Errorf("Please refer to the `e2e/%s` file to see which services are configured for the `%s` protocol.", servicesFile, testProtocol)
+		fmt.Printf("⚠️ The following service IDs have no E2E / Load test cases and will there be skipped: [%s] ⚠️\n", strings.Join(missingServiceIds, ", "))
+		fmt.Printf("⚠️ Please refer to the `e2e/%s` file to see which services are configured for the `%s` protocol ⚠️\n", servicesFile, testProtocol)
 	}
 
 	return filteredTestCases, nil

e2e/main_test.go

@@ -75,7 +75,6 @@ func Test_PATH_E2E(t *testing.T) {
 	// Log the test service IDs
 	logTestServiceIDs(testServices)
 
-	allPassed := true
 	for _, ts := range testServices {
 		serviceConfig, exists := testServiceConfigs[ts.ServiceID]
 		if !exists {
@@ -116,21 +115,9 @@ func Test_PATH_E2E(t *testing.T) {
 		logTestServiceInfo(ts, serviceGatewayURL, serviceConfig)
 
 		// Run the service test
-		serviceTestFailed := runServiceTest(t, ctx, ts)
-
-		if serviceTestFailed {
-			fmt.Printf("\n%s❌ TEST FAILED: Service %s failed assertions%s\n", RED, ts.ServiceID, RESET)
-			allPassed = false
-		} else {
-			fmt.Printf("\n%s✅ Service %s test passed%s\n", GREEN, ts.ServiceID, RESET)
-		}
+		runServiceTest(t, ctx, ts)
 	}
 
-	if allPassed {
-		fmt.Printf("\n%s✅ Test Success: All %d services passed%s\n", GREEN, len(testServices), RESET)
-	} else {
-		fmt.Printf("\n%s❌ Test Failure: One or more services failed%s\n", RED, RESET)
-	}
 	printServiceSummaries(serviceSummaries)
 }
 
@@ -199,7 +186,8 @@ func logTestStartInfo(gatewayURL string, testServices []*TestService) {
 }
 
 func logTestServiceIDs(testServices []*TestService) {
-	fmt.Printf("\n⛓️  Running tests for service IDs:\n")
+	fmt.Printf("\n\n=======================================================\n")
+	fmt.Printf("⛓️  Will be running tests for service IDs:\n")
 	for _, ts := range testServices {
 		if ts.Archival {
 			fmt.Printf("  🗄️  %s%s%s (Archival)\n", GREEN, ts.ServiceID, RESET)
@@ -210,7 +198,8 @@ func logTestServiceIDs(testServices []*TestService) {
 }
 
 func logTestServiceInfo(ts *TestService, serviceGatewayURL string, serviceConfig ServiceConfig) {
-	fmt.Printf("\n🛠️  Running test: %s%s%s\n", BOLD_BLUE, ts.Name, RESET)
+	fmt.Printf("\n\n=======================================================\n")
+	fmt.Printf("🛠️  Starting test for : %s%s%s\n", BOLD_BLUE, ts.Name, RESET)
 	fmt.Printf("  🖥️  Service Gateway URL: %s%s%s\n", BLUE, serviceGatewayURL, RESET)
 	fmt.Printf("  🏎️  Global Requests per Second: %s%d%s\n", GREEN, serviceConfig.GlobalRPS, RESET)
 	fmt.Printf("  🚗 Total Requests per Method: %s%d%s\n\n", GREEN, serviceConfig.RequestsPerMethod, RESET)

e2e/service_evm_test.go

@@ -123,7 +123,7 @@ func getEVMVegetaTargets(
 
 	blockNumber, err := getEVMBlockNumber(ts, headers, gatewayURL)
 	if err != nil {
-		return nil, fmt.Errorf("failed to get EVM block number: %w", err)
+		return nil, fmt.Errorf("failed to get EVM block number for service '%s': %w", ts.ServiceID, err)
 	}
 	ts.ServiceParams.blockNumber = blockNumber
 
@@ -140,7 +140,7 @@ func getEVMVegetaTargets(
 		// Marshal the request body
 		body, err := json.Marshal(jsonrpcReq)
 		if err != nil {
-			return nil, fmt.Errorf("failed to marshal JSON-RPC request for method %s: %w", method, err)
+			return nil, fmt.Errorf("failed to marshal JSON-RPC request for method '%s' for service '%s': %w", method, ts.ServiceID, err)
 		}
 
 		// Create vegeta target
@@ -161,67 +161,93 @@ func getEVMVegetaTargets(
 // Get Test Block Number helpers - Used for EVM archival services
 // -----------------------------------------------------------------------------
 
-func getEVMBlockNumber(testService *TestService, headers http.Header, gatewayURL string) (string, error) {
+// getEVMBlockNumber returns the block number to use for testing.
+// - If non-archival, returns "latest"
+// - If archival, returns a random block number between the current block and the contract start block
+func getEVMBlockNumber(
+	testService *TestService,
+	headers http.Header,
+	gatewayURL string,
+) (string, error) {
 	if !testService.Archival {
 		return "latest", nil
 	} else {
-		blockNumber, err := setTestBlockNumber(
+		// randomBlockNumber is a block between the:
+		// - Start height: the start block height of the contract used for testing
+		// - End height: the current block height
+		randomBlockNumber, err := getTestBlockNumberForArchivalTest(
 			gatewayURL,
 			headers,
 			testService.ServiceParams.ContractStartBlock,
 		)
 		if err != nil {
-			return "", fmt.Errorf("Could not get archival block number: %w", err)
+			return "", fmt.Errorf("Could not get random block number for archival test: %w", err)
 		}
-		return blockNumber, nil
+		return randomBlockNumber, nil
 	}
 }
 
-// setTestBlockNumber gets an archival block number for testing or fails the test.
+// getTestBlockNumberForArchivalTest gets an archival block number for testing or fails the test.
 // Selected by picking a random block number between the current block and the contract start block.
-func setTestBlockNumber(
+func getTestBlockNumberForArchivalTest(
 	gatewayURL string,
 	headers http.Header,
 	contractStartBlock uint64,
 ) (string, error) {
 	// Get current block height - fail test if this doesn't work
-	currentBlock, err := getCurrentBlockNumber(gatewayURL, headers)
+	currentBlockHeight, err := getCurrentConsensusBlockHeight(gatewayURL, headers)
 	if err != nil {
 		return "", fmt.Errorf("Could not get current block height: %w", err)
 	}
 
 	// Get random historical block number
-	return calculateArchivalBlockNumber(currentBlock, contractStartBlock), nil
+	return calculateArchivalBlockNumber(currentBlockHeight, contractStartBlock), nil
 }
 
-// getCurrentBlockNumber gets current block height with consensus from multiple requests.
-func getCurrentBlockNumber(gatewayURL string, headers http.Header) (uint64, error) {
-	// Track frequency of each block height seen
+// getCurrentConsensusBlockHeight gets current block height with consensus from multiple requests.
+func getCurrentConsensusBlockHeight(gatewayURL string, headers http.Header) (uint64, error) {
 	blockHeights := make(map[uint64]int)
 	maxAttempts := 10
 	requiredAgreement := 3
-	client := &http.Client{Timeout: 5 * time.Second}
+	client := &http.Client{Timeout: 2 * time.Second}
 
-	// Make multiple attempts to get consensus
+	// Make requests to get current block height rapidly in parallel
+	results := make(chan uint64, maxAttempts)
 	for range maxAttempts {
-		blockNum, err := fetchBlockNumber(client, gatewayURL, headers)
-		if err != nil {
-			continue
-		}
+		go func() {
+			if height, err := getCurrentBlockHeight(client, gatewayURL, headers); err == nil {
+				results <- height
+			}
+		}()
+	}
 
-		// Update consensus tracking
-		blockHeights[blockNum]++
-		if blockHeights[blockNum] >= requiredAgreement {
-			return blockNum, nil
+	// Collect results quickly
+	timeout := time.After(5 * time.Second)
+collect:
+	for range maxAttempts {
+		select {
+		case height := <-results:
+			blockHeights[height]++
+			if blockHeights[height] >= requiredAgreement {
+				return height, nil
+			}
+		case <-timeout:
+			break collect
 		}
 	}
 
-	// If we get here, we didn't reach consensus
-	return 0, fmt.Errorf("failed to reach consensus on block height after %d attempts", maxAttempts)
+	// Return the most recent height seen if no consensus
+	var maxHeight uint64
+	for height := range blockHeights {
+		if height > maxHeight {
+			maxHeight = height
+		}
+	}
+	return maxHeight, nil
 }
 
-// fetchBlockNumber makes a single request to get the current block number.
-func fetchBlockNumber(client *http.Client, gatewayURL string, headers http.Header) (uint64, error) {
+// getCurrentBlockHeight makes a single request to get the current block number.
+func getCurrentBlockHeight(client *http.Client, gatewayURL string, headers http.Header) (uint64, error) {
 	// Build and send request
 	req, err := buildBlockNumberRequest(gatewayURL, headers)
 	if err != nil {
@@ -235,19 +261,19 @@ func fetchBlockNumber(client *http.Client, gatewayURL string, headers http.Heade
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		return 0, fmt.Errorf("bad status code: %d", resp.StatusCode)
+		return 0, fmt.Errorf("Error getting current block height: %d", resp.StatusCode)
 	}
 
 	// Parse response
 	var jsonRPC jsonrpc.Response
 	if err := json.NewDecoder(resp.Body).Decode(&jsonRPC); err != nil {
-		return 0, err
+		return 0, fmt.Errorf("Error getting current block height: %w", err)
 	}
 
 	// Process hex string result
 	hexString, ok := jsonRPC.Result.(string)
 	if !ok {
-		return 0, fmt.Errorf("expected string result, got %T", jsonRPC.Result)
+		return 0, fmt.Errorf("Error getting current block height: %T", jsonRPC.Result)
 	}
 
 	// Parse hex (remove "0x" prefix if present)

e2e/service_solana_test.go

@@ -168,41 +168,57 @@ type getEpochInfoResponse struct {
 
 func getSolanaBlockNumber(_ *TestService, headers http.Header, gatewayURL string) (string, error) {
 	// Get the current slot number
-	slotNumber, err := getCurrentSlotNumber(gatewayURL, headers)
+	slotNumber, err := getCurrentConsensusSlotNumber(gatewayURL, headers)
 	if err != nil {
 		return "", fmt.Errorf("Could not get current slot number: %w", err)
 	}
 	return strconv.FormatUint(slotNumber, 10), nil
 }
 
-// getCurrentSlotNumber gets current slot number with consensus from multiple requests.
-func getCurrentSlotNumber(gatewayURL string, headers http.Header) (uint64, error) {
-	// Track frequency of each slot number seen
+// getCurrentConsensusSlotNumber gets current slot number with consensus from multiple requests.
+func getCurrentConsensusSlotNumber(gatewayURL string, headers http.Header) (uint64, error) {
 	slotNumbers := make(map[uint64]int)
 	maxAttempts := 10
 	requiredAgreement := 3
-	client := &http.Client{Timeout: 5 * time.Second}
+	client := &http.Client{Timeout: 2 * time.Second}
 
-	// Make multiple attempts to get consensus
+	// Make requests to get current slot number rapidly in parallel
+	results := make(chan uint64, maxAttempts)
 	for range maxAttempts {
-		slotNum, err := fetchSlotNumber(client, gatewayURL, headers)
-		if err != nil {
-			continue
-		}
+		go func() {
+			if height, err := getCurrentSlotNumber(client, gatewayURL, headers); err == nil {
+				results <- height
+			}
+		}()
+	}
 
-		// Update consensus tracking
-		slotNumbers[slotNum]++
-		if slotNumbers[slotNum] >= requiredAgreement {
-			return slotNum, nil
+	// Collect results quickly
+	timeout := time.After(5 * time.Second)
+collect:
+	for range maxAttempts {
+		select {
+		case height := <-results:
+			slotNumbers[height]++
+			if slotNumbers[height] >= requiredAgreement {
+				return height, nil
+			}
+		case <-timeout:
+			break collect
 		}
 	}
 
-	// If we get here, we didn't reach consensus
-	return 0, fmt.Errorf("failed to reach consensus on slot number after %d attempts", maxAttempts)
+	// Return the most recent height seen if no consensus
+	var maxSlotNumber uint64
+	for slotNumber := range slotNumbers {
+		if slotNumber > maxSlotNumber {
+			maxSlotNumber = slotNumber
+		}
+	}
+	return maxSlotNumber, nil
 }
 
-// fetchSlotNumber makes a single request to get the current slot number using getEpochInfo.
-func fetchSlotNumber(client *http.Client, gatewayURL string, headers http.Header) (uint64, error) {
+// getCurrentSlotNumber makes a single request to get the current slot number using getEpochInfo.
+func getCurrentSlotNumber(client *http.Client, gatewayURL string, headers http.Header) (uint64, error) {
 	// Build and send request
 	req, err := buildEpochInfoRequest(gatewayURL, headers)
 	if err != nil {