core/consensus: add new consensus round timer

.github/workflows/golangci-lint.yml

@@ -19,7 +19,7 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v6
         with:
-          version: v1.62.2
+          version: v1.63.4
       - name: notify failure
         if: failure() && github.ref == 'refs/heads/main'
         env:

.pre-commit/run_linter.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-VERSION="1.62.2"
+VERSION="1.63.4"
 
 if ! command -v golangci-lint &> /dev/null
 then
@@ -14,4 +14,4 @@ if [[ $version_check != *"$VERSION"* ]]; then
     echo "golangci-lint version is not $VERSION"
 fi
 
-golangci-lint run
+golangci-lint run --allow-parallel-runners

app/app.go

@@ -94,6 +94,7 @@
 	TestnetConfig           eth2util.Network
 	ProcDirectory           string
 	ConsensusProtocol       string
+	Nickname                string
 
 	TestConfig TestConfig
 }
@@ -257,7 +258,10 @@
 
 	sender := new(p2p.Sender)
 
-	wirePeerInfo(life, tcpNode, peerIDs, cluster.GetInitialMutationHash(), sender, conf.BuilderAPI)
+	if len(conf.Nickname) > 32 {
+		return errors.New("nickname can not exceed 32 characters")
+	}
+	wirePeerInfo(life, tcpNode, peerIDs, cluster.GetInitialMutationHash(), sender, conf.BuilderAPI, conf.Nickname)
 
 	// seenPubkeys channel to send seen public keys from validatorapi to monitoringapi.
 	seenPubkeys := make(chan core.PubKey)
@@ -297,9 +301,9 @@
 }
 
 // wirePeerInfo wires the peerinfo protocol.
-func wirePeerInfo(life *lifecycle.Manager, tcpNode host.Host, peers []peer.ID, lockHash []byte, sender *p2p.Sender, builderEnabled bool) {
+func wirePeerInfo(life *lifecycle.Manager, tcpNode host.Host, peers []peer.ID, lockHash []byte, sender *p2p.Sender, builderEnabled bool, nickname string) {
 	gitHash, _ := version.GitCommit()
-	peerInfo := peerinfo.New(tcpNode, peers, version.Version, lockHash, gitHash, sender.SendReceive, builderEnabled)
+	peerInfo := peerinfo.New(tcpNode, peers, version.Version, lockHash, gitHash, sender.SendReceive, builderEnabled, nickname)
 	life.RegisterStart(lifecycle.AsyncAppCtx, lifecycle.StartPeerInfo, lifecycle.HookFuncCtx(peerInfo.Run))
 }
 

app/eth2wrap/eth2wrap.go

@@ -19,6 +19,7 @@
 	"github.com/obolnetwork/charon/app/errors"
 	"github.com/obolnetwork/charon/app/featureset"
 	"github.com/obolnetwork/charon/app/forkjoin"
+	"github.com/obolnetwork/charon/app/log"
 	"github.com/obolnetwork/charon/app/promauto"
 	"github.com/obolnetwork/charon/app/z"
 )
@@ -57,7 +58,21 @@
 		return nil, errors.New("clients empty")
 	}
 
-	return newMulti(clients), nil
+	// TODO(gsora): remove once the implementation is agreed upon and
+	// wiring is complete.
+	fb := NewFallbackClient(0, [4]byte{}, nil)
+
+	return newMulti(clients, fb), nil
+}
+
+// InstrumentWithFallback returns a new multi instrumented client using the provided clients as backends and fallback
+// respectively.
+func InstrumentWithFallback(fallback *FallbackClient, clients ...Client) (Client, error) {
+	if len(clients) == 0 {
+		return nil, errors.New("clients empty")
+	}
+
+	return newMulti(clients, fallback), nil
 }
 
 // WithSyntheticDuties wraps the provided client adding synthetic duties.
@@ -71,43 +86,58 @@
 
 // NewMultiHTTP returns a new instrumented multi eth2 http client.
 func NewMultiHTTP(timeout time.Duration, forkVersion [4]byte, addresses ...string) (Client, error) {
+	return Instrument(newClients(timeout, forkVersion, addresses)...)
+}
+
+// newClients returns a slice of Client initialized with the provided settings.
+func newClients(timeout time.Duration, forkVersion [4]byte, addresses []string) []Client {
 	var clients []Client
 	for _, address := range addresses {
-		parameters := []eth2http.Parameter{
-			eth2http.WithLogLevel(zeroLogInfo),
-			eth2http.WithAddress(address),
-			eth2http.WithTimeout(timeout),
-			eth2http.WithAllowDelayedStart(true),
-			eth2http.WithEnforceJSON(featureset.Enabled(featureset.JSONRequests)),
-		}
+		clients = append(clients, newBeaconClient(timeout, forkVersion, address))
+	}
 
-		cl := newLazy(func(ctx context.Context) (Client, error) {
-			eth2Svc, err := eth2http.New(ctx, parameters...)
-			if err != nil {
-				return nil, wrapError(ctx, err, "new eth2 client", z.Str("address", address))
-			}
-			eth2Http, ok := eth2Svc.(*eth2http.Service)
-			if !ok {
-				return nil, errors.New("invalid eth2 http service")
-			}
+	return clients
+}
 
-			adaptedCl := AdaptEth2HTTP(eth2Http, timeout)
-			adaptedCl.SetForkVersion(forkVersion)
+// newBeaconClient returns a Client with the provided settings.
+func newBeaconClient(timeout time.Duration, forkVersion [4]byte, address string) Client {
+	parameters := []eth2http.Parameter{
+		eth2http.WithLogLevel(zeroLogInfo),
+		eth2http.WithAddress(address),
+		eth2http.WithTimeout(timeout),
+		eth2http.WithAllowDelayedStart(true),
+		eth2http.WithEnforceJSON(featureset.Enabled(featureset.JSONRequests)),
+	}
 
-			return adaptedCl, nil
-		})
+	cl := newLazy(func(ctx context.Context) (Client, error) {
+		eth2Svc, err := eth2http.New(ctx, parameters...)
+		if err != nil {
+			return nil, wrapError(ctx, err, "new eth2 client", z.Str("address", address))
+		}
+		eth2Http, ok := eth2Svc.(*eth2http.Service)
+		if !ok {
+			return nil, errors.New("invalid eth2 http service")
+		}
 
-		clients = append(clients, cl)
-	}
+		adaptedCl := AdaptEth2HTTP(eth2Http, timeout)
+		adaptedCl.SetForkVersion(forkVersion)
+
+		return adaptedCl, nil
+	})
 
-	return Instrument(clients...)
+	return cl
+}
+
+type provideArgs struct {
+	client   Client
+	fallback *FallbackClient
 }
 
 // provide calls the work function with each client in parallel, returning the
 // first successful result or first error.
 // The bestIdxFunc is called with the index of the client returning a successful response.
-func provide[O any](ctx context.Context, clients []Client,
-	work forkjoin.Work[Client, O], isSuccessFunc func(O) bool, bestSelector *bestSelector,
+func provide[O any](ctx context.Context, clients []Client, fallback *FallbackClient,
+	work forkjoin.Work[provideArgs, O], isSuccessFunc func(O) bool, bestSelector *bestSelector,
 ) (O, error) {
 	if isSuccessFunc == nil {
 		isSuccessFunc = func(O) bool { return true }
@@ -118,12 +148,15 @@
 		forkjoin.WithWorkers(len(clients)),
 	)
 	for _, client := range clients {
-		fork(client)
+		fork(provideArgs{
+			client:   client,
+			fallback: fallback,
+		})
 	}
 	defer cancel()
 
 	var (
-		nokResp    forkjoin.Result[Client, O]
+		nokResp    forkjoin.Result[provideArgs, O]
 		hasNokResp bool
 		zero       O
 	)
@@ -132,7 +165,7 @@
 			return zero, ctx.Err()
 		} else if res.Err == nil && isSuccessFunc(res.Output) {
 			if bestSelector != nil {
-				bestSelector.Increment(res.Input.Address())
+				bestSelector.Increment(res.Input.client.Address())
 			}
 
 			return res.Output, nil
@@ -154,25 +187,37 @@
 type empty struct{}
 
 // submit proxies provide, but returns nil instead of a successful result.
-func submit(ctx context.Context, clients []Client, work func(context.Context, Client) error, selector *bestSelector) error {
-	_, err := provide(ctx, clients,
-		func(ctx context.Context, cl Client) (empty, error) {
-			return empty{}, work(ctx, cl)
+func submit(ctx context.Context, clients []Client, fallback *FallbackClient, work func(context.Context, provideArgs) error, selector *bestSelector) error {
+	_, err := provide(ctx, clients, fallback,
+		func(ctx context.Context, args provideArgs) (empty, error) {
+			return empty{}, work(ctx, args)
 		},
 		nil, selector,
 	)
 
 	return err
 }
 
-// latency measures endpoint latency.
+// latency measures endpoint latency and writes metrics and logs results.
 // Usage:
 //
 //	defer latency("endpoint")()
-func latency(endpoint string) func() {
+func latency(ctx context.Context, endpoint string, enableLogs bool) func() {
+	if enableLogs {
+		log.Debug(ctx, "Calling beacon node endpoint...", z.Str("endpoint", endpoint))
+	}
 	t0 := time.Now()
+
 	return func() {
-		latencyHist.WithLabelValues(endpoint).Observe(time.Since(t0).Seconds())
+		rtt := time.Since(t0)
+		latencyHist.WithLabelValues(endpoint).Observe(rtt.Seconds())
+		if enableLogs {
+			log.Debug(ctx, "Beacon node call finished", z.Str("endpoint", endpoint))
+		}
+		// If BN call took more than 1 second, send WARN log
+		if rtt > time.Second {
+			log.Warn(ctx, "Beacon node call took longer than expected", nil, z.Str("endpoint", endpoint), z.Str("rtt", rtt.String()))
+		}
 	}
 }