forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-20 02:42:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

beacon/light, beacon/blsync: add debug logs

Browse source
This commit is contained in:
Zsolt Felfoldi 2024-04-10 10:05:57 +02:00
parent 411b9ab68b
commit 673975b5fa
5 changed files with 28 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
beacon/blsync/block_sync.go
View file

@ -66,6 +66,7 @@ func (s *beaconBlockSync) Process(requester request.Requester, events []request.
case request.EvResponse, request.EvFail, request.EvTimeout: case request.EvResponse, request.EvFail, request.EvTimeout:
sid, req, resp := event.RequestInfo() sid, req, resp := event.RequestInfo()
blockRoot := common.Hash(req.(sync.ReqBeaconBlock)) blockRoot := common.Hash(req.(sync.ReqBeaconBlock))
log.Debug("Beacon block event", "type", event.Type.Name, "hash", blockRoot)
if resp != nil { if resp != nil {
s.recentBlocks.Add(blockRoot, resp.(*types.BeaconBlock)) s.recentBlocks.Add(blockRoot, resp.(*types.BeaconBlock))
} }

3
beacon/blsync/engineclient.go
View file

@ -62,6 +62,7 @@ func (ec *engineClient) updateLoop(headCh <-chan types.ChainHeadEvent) {
for { for {
select { select {
case <-ec.rootCtx.Done(): case <-ec.rootCtx.Done():
log.Debug("Stopping engine API update loop")
return return
case event := <-headCh: case event := <-headCh:
@ -73,12 +74,14 @@ func (ec *engineClient) updateLoop(headCh <-chan types.ChainHeadEvent) {
fork := ec.config.ForkAtEpoch(event.BeaconHead.Epoch()) fork := ec.config.ForkAtEpoch(event.BeaconHead.Epoch())
forkName := strings.ToLower(fork.Name) forkName := strings.ToLower(fork.Name)
log.Debug("Calling NewPayload", "number", event.Block.NumberU64(), "hash", event.Block.Hash())
if status, err := ec.callNewPayload(forkName, event); err == nil { if status, err := ec.callNewPayload(forkName, event); err == nil {
log.Info("Successful NewPayload", "number", event.Block.NumberU64(), "hash", event.Block.Hash(), "status", status) log.Info("Successful NewPayload", "number", event.Block.NumberU64(), "hash", event.Block.Hash(), "status", status)
} else { } else {
log.Error("Failed NewPayload", "number", event.Block.NumberU64(), "hash", event.Block.Hash(), "error", err) log.Error("Failed NewPayload", "number", event.Block.NumberU64(), "hash", event.Block.Hash(), "error", err)
} }
log.Debug("Calling ForkchoiceUpdated", "head", event.Block.Hash())
if status, err := ec.callForkchoiceUpdated(forkName, event); err == nil { if status, err := ec.callForkchoiceUpdated(forkName, event); err == nil {
log.Info("Successful ForkchoiceUpdated", "head", event.Block.Hash(), "status", status) log.Info("Successful ForkchoiceUpdated", "head", event.Block.Hash(), "status", status)
} else { } else {

1
beacon/light/api/api_server.go
View file

@ -90,6 +90,7 @@ func (s *ApiServer) SendRequest(id request.ID, req request.Request) {
log.Warn("Beacon API request failed", "type", reflect.TypeOf(req), "reqid", id, "err", err) log.Warn("Beacon API request failed", "type", reflect.TypeOf(req), "reqid", id, "err", err)
s.eventCallback(request.Event{Type: request.EvFail, Data: request.RequestResponse{ID: id, Request: req}}) s.eventCallback(request.Event{Type: request.EvFail, Data: request.RequestResponse{ID: id, Request: req}})
} else { } else {
log.Debug("Beacon API request answered", "type", reflect.TypeOf(req), "reqid", id)
s.eventCallback(request.Event{Type: request.EvResponse, Data: request.RequestResponse{ID: id, Request: req, Response: resp}}) s.eventCallback(request.Event{Type: request.EvResponse, Data: request.RequestResponse{ID: id, Request: req, Response: resp}})
} }
}() }()

19
beacon/light/api/light_api.go
View file

@ -32,6 +32,7 @@ import (
"github.com/ethereum/go-ethereum/beacon/types" "github.com/ethereum/go-ethereum/beacon/types"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/log"
) )
var ( var (
@ -459,21 +460,35 @@ func (api *BeaconLightApi) StartHeadListener(listener HeadEventListener) func()
defer wg.Done() defer wg.Done()
// Request initial data. // Request initial data.
log.Debug("Requesting initial head header")
if head, _, _, err := api.GetHeader(common.Hash{}); err == nil { if head, _, _, err := api.GetHeader(common.Hash{}); err == nil {
log.Debug("Successfully retrieved initial head header", "slot", head.Slot, "hash", head.Hash())
listener.OnNewHead(head.Slot, head.Hash()) listener.OnNewHead(head.Slot, head.Hash())
} else {
log.Debug("Failed to retrieve initial head header", "error", err)
} }
log.Debug("Requesting initial optimistic update")
if optimisticUpdate, err := api.GetOptimisticUpdate(); err == nil { if optimisticUpdate, err := api.GetOptimisticUpdate(); err == nil {
log.Debug("Successfully retrieved initial optimistic update", "slot", optimisticUpdate.Attested.Slot, "hash", optimisticUpdate.Attested.Hash())
listener.OnOptimistic(optimisticUpdate) listener.OnOptimistic(optimisticUpdate)
} else {
log.Debug("Failed to retrieve initial optimistic update", "error", err)
} }
log.Debug("Requesting initial finality update")
if finalityUpdate, err := api.GetFinalityUpdate(); err == nil { if finalityUpdate, err := api.GetFinalityUpdate(); err == nil {
log.Debug("Successfully retrieved initial finality update", "slot", finalityUpdate.Finalized.Slot, "hash", finalityUpdate.Finalized.Hash())
listener.OnFinality(finalityUpdate) listener.OnFinality(finalityUpdate)
} else {
log.Debug("Failed to retrieve initial finality update", "error", err)
} }
log.Debug("Starting event stream processing loop")
// Receive the stream. // Receive the stream.
var stream *eventsource.Stream var stream *eventsource.Stream
select { select {
case stream = <-streamCh: case stream = <-streamCh:
case <-ctx.Done(): case <-ctx.Done():
log.Debug("Stopping event stream processing loop")
return return
} }
@ -484,8 +499,10 @@ func (api *BeaconLightApi) StartHeadListener(listener HeadEventListener) func()
case event, ok := <-stream.Events: case event, ok := <-stream.Events:
if !ok { if !ok {
log.Debug("Event stream closed")
return return
} }
log.Debug("New event received from event stream", "type", event.Event())
switch event.Event() { switch event.Event() {
case "head": case "head":
slot, blockRoot, err := decodeHeadEvent([]byte(event.Data())) slot, blockRoot, err := decodeHeadEvent([]byte(event.Data()))
@ -532,6 +549,7 @@ func (api *BeaconLightApi) StartHeadListener(listener HeadEventListener) func()
func (api *BeaconLightApi) startEventStream(ctx context.Context, listener *HeadEventListener) *eventsource.Stream { func (api *BeaconLightApi) startEventStream(ctx context.Context, listener *HeadEventListener) *eventsource.Stream {
for retry := true; retry; retry = ctxSleep(ctx, 5*time.Second) { for retry := true; retry; retry = ctxSleep(ctx, 5*time.Second) {
path := "/eth/v1/events?topics=head&topics=light_client_optimistic_update&topics=light_client_finality_update" path := "/eth/v1/events?topics=head&topics=light_client_optimistic_update&topics=light_client_finality_update"
log.Debug("Sending event subscription request")
req, err := http.NewRequestWithContext(ctx, "GET", api.url+path, nil) req, err := http.NewRequestWithContext(ctx, "GET", api.url+path, nil)
if err != nil { if err != nil {
listener.OnError(fmt.Errorf("error creating event subscription request: %v", err)) listener.OnError(fmt.Errorf("error creating event subscription request: %v", err))
@ -545,6 +563,7 @@ func (api *BeaconLightApi) startEventStream(ctx context.Context, listener *HeadE
listener.OnError(fmt.Errorf("error creating event subscription: %v", err)) listener.OnError(fmt.Errorf("error creating event subscription: %v", err))
continue continue
} }
log.Debug("Successfully created event stream")
return stream return stream
} }
return nil return nil

4
beacon/light/sync/update_sync.go
View file

@ -84,6 +84,7 @@ func (s *CheckpointInit) Process(requester request.Requester, events []request.E
if s.initialized { if s.initialized {
return return
} }
for _, event := range events { for _, event := range events {
switch event.Type { switch event.Type {
case request.EvResponse, request.EvFail, request.EvTimeout: case request.EvResponse, request.EvFail, request.EvTimeout:
@ -132,10 +133,12 @@ func (s *CheckpointInit) Process(requester request.Requester, events []request.E
newState.state = ssPrintStatus newState.state = ssPrintStatus
s.serverState[sid.Server] = newState s.serverState[sid.Server] = newState
} }
case request.EvUnregistered: case request.EvUnregistered:
delete(s.serverState, event.Server) delete(s.serverState, event.Server)
} }
} }
// start a request if possible // start a request if possible
for _, server := range requester.CanSendTo() { for _, server := range requester.CanSendTo() {
switch s.serverState[server].state { switch s.serverState[server].state {
@ -156,6 +159,7 @@ func (s *CheckpointInit) Process(requester request.Requester, events []request.E
s.serverState[server] = newState s.serverState[server] = newState
} }
} }
// print log message if necessary // print log message if necessary
for server, state := range s.serverState { for server, state := range s.serverState {
if state.state != ssPrintStatus { if state.state != ssPrintStatus {