[Metrics] Improve relay metrics reliability with early initialization (#1780)

## Summary

Improve relay metrics reliability by initializing variables early and
using deferred metrics recording to ensure consistent data collection.

### Primary Changes:
- Initialize `supplierOperatorAddress` and `serviceId` with default
values before relay request unmarshalling
- Move metrics recording to deferred function to guarantee execution
regardless of function exit path
- Ensure `RelaysTotal` and relay duration metrics are always captured,
even on early error returns

### Secondary changes:
- Updated error reply handling to include default `ServiceId` for
consistent metric labeling
- Improved variable scope and reuse for better code organization

## Issue:

Problem: Relay metrics could be inconsistently recorded when requests
failed early in processing, leading to gaps in monitoring data and
unreliable dashboards.

## Type of change

Select one or more from the following:

- [ ] Bug fix
- [ ] New feature, functionality or library
- [x] Code health or cleanup
- [ ] Documentation
- [ ] Other (specify)

## Sanity Checklist

- [ ] I have updated the GitHub Issue Metadata: `assignees`,
`reviewers`, `labels`, `project`, `iteration` and `milestone`
- [ ] For docs: `make docusaurus_start`
- [ ] For small changes: `make go_develop_and_test` and `make test_e2e`
- [ ] For major changes: `devnet-test-e2e` label to run E2E tests in CI
- [ ] For migration changes: `make test_e2e_oneshot`
- [ ] 'TODO's, configurations and other docs

---------

Co-authored-by: Claude <[email protected]>

Author: red-0ne

pkg/relayer/proxy/error_reply.go

@@ -39,7 +39,9 @@ func (sync *relayMinerHTTPServer) replyWithError(
 	if relayRequest == nil {
 		relayRequest = &types.RelayRequest{
 			Meta: types.RelayRequestMetadata{
-				SessionHeader: &sessiontypes.SessionHeader{},
+				SessionHeader: &sessiontypes.SessionHeader{
+					ServiceId: UnknownServiceID,
+				},
 			},
 		}
 	}

pkg/relayer/proxy/proxy.go

@@ -17,6 +17,15 @@ import (
 
 var _ relayer.RelayerProxy = (*relayerProxy)(nil)
 
+// UnknownServiceID and UnknownSupplierOperatorAddress are the default values used
+// as a fallback when the actual service ID or supplier operator cannot be determined.
+// This occurs during error scenarios before relay request validation, ensuring
+// metrics labels and error responses always have a valid service ID value.
+const (
+	UnknownServiceID               = "unknown_service_id"
+	UnknownSupplierOperatorAddress = "unknown_supplier_operator_address"
+)
+
 // relayerProxy is the main relayer proxy that takes relay requests of supported
 // services from the client and proxies them to the supported backend services.
 // It is responsible for notifying the miner about the relays that have been

pkg/relayer/proxy/sync.go

@@ -50,6 +50,29 @@ func (server *relayMinerHTTPServer) serveSyncRequest(
 	startBlock := server.blockClient.LastBlock(ctx)
 	startHeight := startBlock.Height()
 
+	// Initialize with default values for metrics:
+	// - We don't know the actual supplierOperatorAddress and serviceId until the relay request is unmarshalled.
+	// - If we fail before unmarshalling, these defaults ensure:
+	//   - Metric labels are always populated (never empty)
+	//   - Downstream monitoring and dashboards remain consistent
+	supplierOperatorAddress := UnknownSupplierOperatorAddress
+	serviceId := UnknownServiceID
+
+	// Defer metrics to guarantee they are always recorded:
+	// - Ensures RelaysTotal and relay duration are captured regardless of how/when the function returns
+	// - Even on early error returns, metrics are updated with the best-known values
+	// - Prevents accidental metric omission due to premature exit
+	defer func(startTime time.Time, statusCode *int) {
+		// Increment the relays counter.
+		relayer.RelaysTotal.With(
+			"service_id", serviceId,
+			"supplier_operator_address", supplierOperatorAddress,
+		).Add(1)
+
+		// Capture the relay request duration metric.
+		relayer.CaptureRelayDuration(serviceId, startTime, *statusCode)
+	}(requestStartTime, &statusCode)
+
 	logger.ProbabilisticDebugInfo(polylog.ProbabilisticDebugInfoProb).Msgf(
 		"📊 Chain head at height %d (block hash: %X) at relay request start",
 		startHeight,
@@ -72,7 +95,8 @@ func (server *relayMinerHTTPServer) serveSyncRequest(
 	}
 
 	meta := relayRequest.Meta
-	serviceId := meta.SessionHeader.ServiceId
+	supplierOperatorAddress = meta.SupplierOperatorAddress
+	serviceId = meta.SessionHeader.ServiceId
 
 	blockHeight := server.blockClient.LastBlock(ctx).Height()
 
@@ -83,19 +107,19 @@ func (server *relayMinerHTTPServer) serveSyncRequest(
 		"session_end_height", meta.SessionHeader.SessionEndBlockHeight,
 		"service_id", serviceId,
 		"application_address", meta.SessionHeader.ApplicationAddress,
-		"supplier_operator_address", meta.SupplierOperatorAddress,
+		"supplier_operator_address", supplierOperatorAddress,
 		"request_start_time", requestStartTime.String(),
 	)
 
 	// Check if the request's selected supplier is available for relaying.
 	availableSuppliers := server.relayAuthenticator.GetSupplierOperatorAddresses()
 
-	if !slices.Contains(availableSuppliers, meta.SupplierOperatorAddress) {
+	if !slices.Contains(availableSuppliers, supplierOperatorAddress) {
 		logger.Warn().
 			Msgf(
 				"❌ The request's selected supplier with operator_address (%q) is not available for relaying! "+
 					"This could be a network or configuration issue. Available suppliers: [%s] 🚦",
-				meta.SupplierOperatorAddress,
+				supplierOperatorAddress,
 				strings.Join(availableSuppliers, ", "),
 			)
 		return relayRequest, ErrRelayerProxySupplierNotReachable
@@ -218,16 +242,6 @@ func (server *relayMinerHTTPServer) serveSyncRequest(
 		"service_config_type", serviceConfigTypeLog,
 	)
 
-	// Increment the relays counter.
-	relayer.RelaysTotal.With(
-		"service_id", serviceId,
-		"supplier_operator_address", meta.SupplierOperatorAddress,
-	).Add(1)
-	defer func(startTime time.Time, statusCode *int) {
-		// Capture the relay request duration metric.
-		relayer.CaptureRelayDuration(serviceId, startTime, *statusCode)
-	}(requestStartTime, &statusCode)
-
 	relayer.RelayRequestSizeBytes.With("service_id", serviceId).
 		Observe(float64(relayRequest.Size()))
 
@@ -360,7 +374,7 @@ func (server *relayMinerHTTPServer) serveSyncRequest(
 	// Build the relay response using the original service's response.
 	// Use relayRequest.Meta.SessionHeader on the relayResponse session header since it
 	// was verified to be valid and has to be the same as the relayResponse session header.
-	relayResponse, err := server.newRelayResponse(responseBz, meta.SessionHeader, meta.SupplierOperatorAddress)
+	relayResponse, err := server.newRelayResponse(responseBz, meta.SessionHeader, supplierOperatorAddress)
 	if err != nil {
 		logger.Error().Err(err).Msg("❌ Failed building the relay response")
 		// The client should not have knowledge about the RelayMiner's issues with