add log-prefix to p2p pkg (#19529)

AskAlexSharov · web-flow · commit 1fc4ace53426 · 2026-02-28T03:31:08.000Z
diff --git a/p2p/dial.go b/p2p/dial.go
@@ -261,7 +261,7 @@ loop:
 
 		case node := <-nodesCh:
 			if err := d.checkDial(node); err != nil {
-				d.log.Trace("Discarding dial candidate", "id", node.ID(), "ip", node.IP(), "reason", err)
+				d.log.Trace("[p2p] Discarding dial candidate", "id", node.ID(), "ip", node.IP(), "reason", err)
 			} else {
 				d.startDial(newDialTask(node, dynDialedConn))
 			}
@@ -295,7 +295,7 @@ loop:
 		case node := <-d.addStaticCh:
 			id := node.ID()
 			_, exists := d.static[id]
-			d.log.Trace("Adding static node", "id", id, "ip", node.IP(), "added", !exists)
+			d.log.Trace("[p2p] Adding static node", "id", id, "ip", node.IP(), "added", !exists)
 			if exists {
 				continue loop
 			}
@@ -308,7 +308,7 @@ loop:
 		case node := <-d.remStaticCh:
 			id := node.ID()
 			task := d.static[id]
-			d.log.Trace("Removing static node", "id", id, "ok", task != nil)
+			d.log.Trace("[p2p] Removing static node", "id", id, "ok", task != nil)
 			if task != nil {
 				delete(d.static, id)
 				if task.staticPoolIndex >= 0 {
@@ -464,7 +464,7 @@ func (d *dialScheduler) removeFromStaticPool(idx int) {
 // startDial runs the given dial task in a separate goroutine.
 func (d *dialScheduler) startDial(task *dialTask) {
 	node := task.dest()
-	d.log.Trace("Starting p2p dial", "id", node.ID(), "ip", node.IP(), "flag", task.flags)
+	d.log.Trace("[p2p] Starting p2p dial", "id", node.ID(), "ip", node.IP(), "flag", task.flags)
 	hkey := string(node.ID().Bytes())
 	d.history.add(hkey, d.clock.Now().Add(dialHistoryExpiration))
 	d.dialing[node.ID()] = task
@@ -543,13 +543,13 @@ func (t *dialTask) resolve(d *dialScheduler) bool {
 		if t.resolveDelay > maxResolveDelay {
 			t.resolveDelay = maxResolveDelay
 		}
-		d.log.Warn("Resolving node failed", "id", t.dest().ID(), "newdelay", t.resolveDelay)
+		d.log.Warn("[p2p] Resolving node failed", "id", t.dest().ID(), "newdelay", t.resolveDelay)
 		return false
 	}
 	// The node was found.
 	t.resolveDelay = initialResolveDelay
 	t.destPtr.Store(resolved)
-	d.log.Trace("Resolved node", "id", resolved.ID(), "addr", &net.TCPAddr{IP: resolved.IP(), Port: resolved.TCP()})
+	d.log.Trace("[p2p] Resolved node", "id", resolved.ID(), "addr", &net.TCPAddr{IP: resolved.IP(), Port: resolved.TCP()})
 	return true
 }
 
@@ -558,7 +558,7 @@ func (t *dialTask) dial(d *dialScheduler, dest *enode.Node) error {
 	fd, err := d.dialer.Dial(d.ctx, dest)
 	if err != nil {
 		cleanErr := cleanupDialErr(err)
-		d.log.Trace("Dial error", "id", dest.ID(), "addr", nodeAddr(dest), "conn", t.flags, "err", cleanErr)
+		d.log.Trace("[p2p] Dial error", "id", dest.ID(), "addr", nodeAddr(dest), "conn", t.flags, "err", cleanErr)
 
 		d.mutex.Lock()
 		d.errors[cleanErr.Error()] = d.errors[cleanErr.Error()] + 1
diff --git a/p2p/discover/lookup.go b/p2p/discover/lookup.go
@@ -138,7 +138,7 @@ func (it *lookup) query(n *enode.Node, reply chan<- []*enode.Node) {
 		success := len(r) > 0
 		it.tab.trackRequest(n, success, r)
 		if err != nil {
-			it.tab.log.Trace("FINDNODE failed", "id", n.ID(), "err", err)
+			it.tab.log.Trace("[p2p] FINDNODE failed", "id", n.ID(), "err", err)
 		}
 	}
 	reply <- r
diff --git a/p2p/discover/ntp.go b/p2p/discover/ntp.go
@@ -44,10 +44,10 @@ func checkClockDrift() {
 		return
 	}
 	if drift < -driftThreshold || drift > driftThreshold {
-		log.Warn(fmt.Sprintf("System clock seems off by %v, which can prevent network connectivity", drift))
-		log.Warn("Please enable network time synchronisation in system settings.")
+		log.Warn(fmt.Sprintf("[p2p] System clock seems off by %v, which can prevent network connectivity", drift))
+		log.Warn("[p2p] Please enable network time synchronisation in system settings.")
 	} else {
-		log.Debug("NTP sanity check done", "drift", drift)
+		log.Debug("[p2p] NTP sanity check done", "drift", drift)
 	}
 }
 
diff --git a/p2p/discover/table.go b/p2p/discover/table.go
@@ -211,7 +211,7 @@ func (tab *Table) setFallbackNodes(nodes []*enode.Node) error {
 			return fmt.Errorf("bad bootstrap node %q: %v", n, err)
 		}
 		if tab.cfg.NetRestrict != nil && !tab.cfg.NetRestrict.ContainsAddr(n.IPAddr()) {
-			tab.log.Error("Bootstrap node filtered by netrestrict", "id", n.ID(), "ip", n.IPAddr())
+			tab.log.Error("[p2p] Bootstrap node filtered by netrestrict", "id", n.ID(), "ip", n.IPAddr())
 			continue
 		}
 		nursery = append(nursery, n)
@@ -453,7 +453,7 @@ func (tab *Table) loadSeedNodes() {
 		if tab.log.Enabled(context.Background(), log.LvlTrace) {
 			age := time.Since(tab.db.LastPongReceived(seed.ID(), seed.IPAddr()))
 			addr, _ := seed.UDPEndpoint()
-			tab.log.Trace("Found seed node in database", "id", seed.ID(), "addr", addr, "age", age)
+			tab.log.Trace("[p2p] Found seed node in database", "id", seed.ID(), "addr", addr, "age", age)
 		}
 		tab.mutex.Lock()
 		tab.handleAddNode(addNodeOp{node: seed, isInbound: false})
@@ -487,11 +487,11 @@ func (tab *Table) addIP(b *bucket, ip netip.Addr) bool {
 		return true
 	}
 	if !tab.ips.AddAddr(ip) {
-		tab.log.Debug("IP exceeds table limit", "ip", ip)
+		tab.log.Debug("[p2p] IP exceeds table limit", "ip", ip)
 		return false
 	}
 	if !b.ips.AddAddr(ip) {
-		tab.log.Debug("IP exceeds bucket limit", "ip", ip)
+		tab.log.Debug("[p2p] IP exceeds bucket limit", "ip", ip)
 		tab.ips.RemoveAddr(ip)
 		return false
 	}
@@ -603,15 +603,15 @@ func (tab *Table) deleteInBucket(b *bucket, id enode.ID) *tableNode {
 
 	// Add replacement.
 	if len(b.replacements) == 0 {
-		tab.log.Debug("Removed dead node", "b", b.index, "id", n.ID(), "ip", n.IPAddr())
+		tab.log.Debug("[p2p] Removed dead node", "b", b.index, "id", n.ID(), "ip", n.IPAddr())
 		return nil
 	}
 	rindex := tab.rand.Intn(len(b.replacements))
 	rep := b.replacements[rindex]
 	b.replacements = slices.Delete(b.replacements, rindex, rindex+1)
 	b.entries = append(b.entries, rep)
 	tab.nodeAdded(b, rep)
-	tab.log.Debug("Replaced dead node", "b", b.index, "id", n.ID(), "ip", n.IPAddr(), "r", rep.ID(), "rip", rep.IPAddr())
+	tab.log.Debug("[p2p] Replaced dead node", "b", b.index, "id", n.ID(), "ip", n.IPAddr(), "r", rep.ID(), "rip", rep.IPAddr())
 	return rep
 }
 
diff --git a/p2p/discover/table_reval.go b/p2p/discover/table_reval.go
@@ -124,7 +124,7 @@ func (tab *Table) doRevalidate(resp revalidationResponse, node *enode.Node) {
 	if remoteSeq > node.Seq() {
 		newrec, err := tab.net.RequestENR(node)
 		if err != nil {
-			tab.log.Debug("ENR request failed", "id", node.ID(), "err", err)
+			tab.log.Debug("[p2p] ENR request failed", "id", node.ID(), "err", err)
 		} else {
 			resp.newRecord = newrec
 		}
diff --git a/p2p/discover/v4_udp.go b/p2p/discover/v4_udp.go
@@ -336,7 +336,7 @@ func (t *UDPv4) findnode(toid enode.ID, toAddrPort netip.AddrPort, target v4wire
 			nreceived++
 			n, err := t.nodeFromRPC(toAddrPort, rn)
 			if err != nil {
-				t.log.Trace("Invalid neighbor node received", "ip", rn.IP, "addr", toAddrPort, "err", err)
+				t.log.Trace("[p2p] Invalid neighbor node received", "ip", rn.IP, "addr", toAddrPort, "err", err)
 				continue
 			}
 			nodes = append(nodes, n)
@@ -535,7 +535,7 @@ func (t *UDPv4) send(toaddr netip.AddrPort, toid enode.ID, req v4wire.Packet) ([
 
 func (t *UDPv4) write(toaddr netip.AddrPort, toid enode.ID, what string, packet []byte) error {
 	_, err := t.conn.WriteToUDPAddrPort(packet, toaddr)
-	t.log.Trace(">> "+what, "id", toid, "addr", toaddr, "err", err)
+	t.log.Trace("[p2p] >> "+what, "id", toid, "addr", toaddr, "err", err)
 	return err
 }
 
@@ -551,17 +551,17 @@ func (t *UDPv4) readLoop(unhandled chan<- ReadPacket) {
 		nbytes, from, err := t.conn.ReadFromUDPAddrPort(buf)
 		if netutil.IsTemporaryError(err) {
 			// Ignore temporary read errors.
-			t.log.Debug("Temporary UDP read error", "err", err)
+			t.log.Debug("[p2p] Temporary UDP read error", "err", err)
 			continue
 		} else if err != nil {
 			// Shut down the loop for permanent errors.
 			if !errors.Is(err, io.EOF) {
-				t.log.Debug("UDP read error", "err", err)
+				t.log.Debug("[p2p] UDP read error", "err", err)
 			}
 			return
 		}
 		if err := t.handlePacket(from, buf[:nbytes]); err != nil && unhandled == nil {
-			t.log.Debug("Bad discv4 packet", "addr", from, "err", err)
+			t.log.Debug("[p2p] Bad discv4 packet", "addr", from, "err", err)
 		} else if err != nil && unhandled != nil {
 			select {
 			case unhandled <- ReadPacket{buf[:nbytes], from}:
@@ -586,7 +586,7 @@ func (t *UDPv4) handlePacket(from netip.AddrPort, buf []byte) error {
 	if packet.preverify != nil {
 		err = packet.preverify(packet, from, fromID, fromKey)
 	}
-	t.log.Trace("<< "+packet.Name(), "id", fromID, "addr", from, "err", err)
+	t.log.Trace("[p2p] << "+packet.Name(), "id", fromID, "addr", from, "err", err)
 	if err == nil && packet.handle != nil {
 		packet.handle(packet, from, fromID, hash)
 	}
diff --git a/p2p/discover/v5_talk.go b/p2p/discover/v5_talk.go
@@ -103,7 +103,7 @@ func (t *talkSystem) handleRequest(id enode.ID, addr netip.AddrPort, req *v5wire
 	case <-timeout.C:
 		// Couldn't get it in time, drop the request.
 		if time.Since(t.lastLog) > 5*time.Second {
-			log.Warn("Dropping TALKREQ due to overload", "ndrop", t.dropCount)
+			log.Warn("[p2p] Dropping TALKREQ due to overload", "ndrop", t.dropCount)
 			t.lastLog = time.Now()
 			t.dropCount++
 		}
diff --git a/p2p/discover/v5_udp.go b/p2p/discover/v5_udp.go
@@ -459,7 +459,7 @@ func (t *UDPv5) waitForNodes(c *callV5, distances []uint) ([]*enode.Node, error)
 			for _, record := range response.Nodes {
 				node, err := t.verifyResponseNode(c, record, distances, seen)
 				if err != nil {
-					t.log.Debug("Invalid record in "+response.Name(), "id", c.node.ID(), "err", err)
+					t.log.Debug("[p2p] Invalid record in "+response.Name(), "id", c.node.ID(), "err", err)
 					continue
 				}
 				nodes = append(nodes, node)
@@ -695,12 +695,12 @@ func (t *UDPv5) send(toID enode.ID, toAddr netip.AddrPort, packet v5wire.Packet,
 	enc, nonce, err := t.codec.Encode(toID, addr, packet, c)
 	if err != nil {
 		t.logcontext = append(t.logcontext, "err", err)
-		t.log.Warn(">> "+packet.Name(), t.logcontext...)
+		t.log.Warn("[p2p] >> "+packet.Name(), t.logcontext...)
 		return nonce, err
 	}
 
 	_, err = t.conn.WriteToUDPAddrPort(enc, toAddr)
-	t.log.Trace(">> "+packet.Name(), t.logcontext...)
+	t.log.Trace("[p2p] >> "+packet.Name(), t.logcontext...)
 	return nonce, err
 }
 
@@ -713,12 +713,12 @@ func (t *UDPv5) readLoop() {
 		nbytes, from, err := t.conn.ReadFromUDPAddrPort(buf)
 		if netutil.IsTemporaryError(err) {
 			// Ignore temporary read errors.
-			t.log.Debug("Temporary UDP read error", "err", err)
+			t.log.Debug("[p2p] Temporary UDP read error", "err", err)
 			continue
 		} else if err != nil {
 			// Shut down the loop for permanent errors.
 			if !errors.Is(err, io.EOF) {
-				t.log.Debug("UDP read error", "err", err)
+				t.log.Debug("[p2p] UDP read error", "err", err)
 			}
 			return
 		}
@@ -753,7 +753,7 @@ func (t *UDPv5) handlePacket(rawpacket []byte, fromAddr netip.AddrPort) error {
 			t.unhandled <- up
 			return nil
 		}
-		t.log.Trace("Bad discv5 packet", "id", fromID, "addr", addr, "err", err)
+		t.log.Trace("[p2p] Bad discv5 packet", "id", fromID, "addr", addr, "err", err)
 		return err
 	}
 	if fromNode != nil {
@@ -764,7 +764,7 @@ func (t *UDPv5) handlePacket(rawpacket []byte, fromAddr netip.AddrPort) error {
 		// WHOAREYOU logged separately to report errors.
 		t.logcontext = append(t.logcontext[:0], "id", fromID, "addr", addr)
 		t.logcontext = packet.AppendLogInfo(t.logcontext)
-		t.log.Trace("<< "+packet.Name(), t.logcontext...)
+		t.log.Trace("[p2p] << "+packet.Name(), t.logcontext...)
 	}
 	t.handle(packet, fromID, fromAddr)
 	return nil
@@ -875,7 +875,7 @@ func (t *UDPv5) handleWhoareyou(p *v5wire.Whoareyou, fromID enode.ID, fromAddr n
 		return
 	}
 	// Resend the call that was answered by WHOAREYOU.
-	t.log.Trace("<< "+p.Name(), "id", c.node.ID(), "addr", fromAddr)
+	t.log.Trace("[p2p] << "+p.Name(), "id", c.node.ID(), "addr", fromAddr)
 	c.handshakeCount++
 	c.challenge = p
 	p.Node = c.node
diff --git a/p2p/dnsdisc/client.go b/p2p/dnsdisc/client.go
@@ -104,7 +104,7 @@ func NewClient(cfg Config) *Client {
 
 	entries, err := lru.New[string, entry](cfg.CacheLimit)
 	if err != nil {
-		log.Warn("can't create lru", "err", err)
+		log.Warn("[p2p] can't create lru", "err", err)
 	}
 	return &Client{
 		cfg:       cfg,
diff --git a/p2p/enode/localnode.go b/p2p/enode/localnode.go
@@ -301,7 +301,7 @@ func (ln *LocalNode) sign() {
 		panic(fmt.Errorf("enode: can't verify local record: %v", err))
 	}
 	ln.cur.Store(n)
-	log.Trace("New local node record", "seq", ln.seq, "id", n.ID(), "ip", n.IPAddr(), "udp", n.UDP(), "tcp", n.TCP())
+	log.Trace("[p2p] New local node record", "seq", ln.seq, "id", n.ID(), "ip", n.IPAddr(), "udp", n.UDP(), "tcp", n.TCP())
 }
 
 func (ln *LocalNode) bumpSeq() {
diff --git a/p2p/enode/nodedb.go b/p2p/enode/nodedb.go
@@ -388,7 +388,7 @@ func (db *DB) deleteRange(prefix []byte) {
 		}
 		return nil
 	}); err != nil {
-		log.Warn("nodeDB.deleteRange failed", "err", err)
+		log.Warn("[p2p] nodeDB.deleteRange failed", "err", err)
 	}
 }
 
@@ -484,7 +484,7 @@ func (db *DB) expireNodes() {
 		}
 		return nil
 	}); err != nil {
-		log.Warn("nodeDB.expireNodes failed", "err", err)
+		log.Warn("[p2p] nodeDB.expireNodes failed", "err", err)
 	}
 	for _, td := range toDelete {
 		db.deleteRange(td)
@@ -634,7 +634,7 @@ func (db *DB) QuerySeeds(n int, maxAge time.Duration) []*Node {
 		}
 		return nil
 	}); err != nil && !errors.Is(err, context.Canceled) {
-		log.Warn("nodeDB.QuerySeeds failed", "err", err)
+		log.Warn("[p2p] nodeDB.QuerySeeds failed", "err", err)
 	}
 	return nodes
 }
diff --git a/p2p/forkid/forkid.go b/p2p/forkid/forkid.go
@@ -193,7 +193,7 @@ func newFilter(heightForks, timeForks []uint64, genesis common.Hash, headHeight,
 			// No exact, subset or superset match. We are on differing chains, reject.
 			return ErrLocalIncompatibleOrStale
 		}
-		log.Error("Impossible fork ID validation", "id", id)
+		log.Error("[p2p] Impossible fork ID validation", "id", id)
 		return nil // Something's very wrong, accept rather than reject
 	}
 }
diff --git a/p2p/peer.go b/p2p/peer.go
@@ -341,7 +341,7 @@ func (p *Peer) handle(msg Msg) error {
 		// We don't need to discard because the connection will be closed after it.
 		reason, err := DisconnectMessagePayloadDecode(msg.Payload)
 		if err != nil {
-			p.log.Debug("Peer.handle: failed to rlp.Decode msg.Payload", "err", err)
+			p.log.Debug("[p2p] Peer.handle: failed to rlp.Decode msg.Payload", "err", err)
 		}
 		return reason
 	case msg.Code < baseProtocolLength:
@@ -417,7 +417,7 @@ func (p *Peer) startProtocols(writeStart <-chan struct{}, writeErr chan<- error)
 		if p.events != nil {
 			rw = newMsgEventer(rw, p.events, p.ID(), proto.Name, p.RemoteAddr().String(), p.LocalAddr().String())
 		}
-		p.log.Trace(fmt.Sprintf("Starting protocol %s/%d", proto.Name, proto.Version))
+		p.log.Trace(fmt.Sprintf("[p2p] Starting protocol %s/%d", proto.Name, proto.Version))
 		go func() {
 			defer dbg.LogPanic()
 			defer p.wg.Done()
diff --git a/p2p/protocols/eth/handlers.go b/p2p/protocols/eth/handlers.go
@@ -102,7 +102,7 @@ func AnswerGetBlockHeadersQuery(db kv.Tx, query *GetBlockHeadersPacket, blockRea
 			if next <= current {
 				//infos, _ := json.MarshalIndent(peer.Peer.Info(), "", "  ")
 				//log.Warn("GetBlockHeaders skip overflow attack", "current", current, "skip", query.Skip, "next", next, "attacker", infos)
-				log.Warn("GetBlockHeaders skip overflow attack", "current", current, "skip", query.Skip, "next", next)
+				log.Warn("[p2p] GetBlockHeaders skip overflow attack", "current", current, "skip", query.Skip, "next", next)
 				unknown = true
 			} else {
 				header, err := blockReader.HeaderByNumber(context.Background(), db, query.Origin.Number)
diff --git a/p2p/sentry/sentry_grpc_server.go b/p2p/sentry/sentry_grpc_server.go
@@ -727,7 +727,7 @@ func grpcSentryServer(ctx context.Context, sentryAddr string, ss *GrpcServer, he
 	ss.logger.Info("Starting Sentry gRPC server", "on", sentryAddr)
 	listenConfig := net.ListenConfig{
 		Control: func(network, address string, _ syscall.RawConn) error {
-			log.Info("Sentry gRPC received connection", "via", network, "from", address)
+			log.Info("[p2p] Sentry gRPC received connection", "via", network, "from", address)
 			return nil
 		},
 	}
diff --git a/p2p/sentry/sentry_multi_client/broadcast.go b/p2p/sentry/sentry_multi_client/broadcast.go
diff --git a/p2p/server.go b/p2p/server.go

Original file line number	Diff line number	Diff line change
`@@ -138,7 +138,7 @@ func (it lookup) query(n enode.Node, reply chan<- []*enode.Node) {`
`138`	`138`	`success := len(r) > 0`
`139`	`139`	`it.tab.trackRequest(n, success, r)`
`140`	`140`	`if err != nil {`
`141`		`- it.tab.log.Trace("FINDNODE failed", "id", n.ID(), "err", err)`
	`141`	`+ it.tab.log.Trace("[p2p] FINDNODE failed", "id", n.ID(), "err", err)`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`	`reply <- r`
Original file line number	Diff line number	Diff line change
`@@ -44,10 +44,10 @@ func checkClockDrift() {`
`44`	`44`	`return`
`45`	`45`	`}`
`46`	`46`	`if drift < -driftThreshold \|\| drift > driftThreshold {`
`47`		`- log.Warn(fmt.Sprintf("System clock seems off by %v, which can prevent network connectivity", drift))`
`48`		`- log.Warn("Please enable network time synchronisation in system settings.")`
	`47`	`+ log.Warn(fmt.Sprintf("[p2p] System clock seems off by %v, which can prevent network connectivity", drift))`
	`48`	`+ log.Warn("[p2p] Please enable network time synchronisation in system settings.")`
`49`	`49`	`} else {`
`50`		`- log.Debug("NTP sanity check done", "drift", drift)`
	`50`	`+ log.Debug("[p2p] NTP sanity check done", "drift", drift)`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ func (tab Table) doRevalidate(resp revalidationResponse, node enode.Node) {`
`124`	`124`	`if remoteSeq > node.Seq() {`
`125`	`125`	`newrec, err := tab.net.RequestENR(node)`
`126`	`126`	`if err != nil {`
`127`		`- tab.log.Debug("ENR request failed", "id", node.ID(), "err", err)`
	`127`	`+ tab.log.Debug("[p2p] ENR request failed", "id", node.ID(), "err", err)`
`128`	`128`	`} else {`
`129`	`129`	`resp.newRecord = newrec`
`130`	`130`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ func (t talkSystem) handleRequest(id enode.ID, addr netip.AddrPort, req v5wire`
`103`	`103`	`case <-timeout.C:`
`104`	`104`	`// Couldn't get it in time, drop the request.`
`105`	`105`	`if time.Since(t.lastLog) > 5*time.Second {`
`106`		`- log.Warn("Dropping TALKREQ due to overload", "ndrop", t.dropCount)`
	`106`	`+ log.Warn("[p2p] Dropping TALKREQ due to overload", "ndrop", t.dropCount)`
`107`	`107`	`t.lastLog = time.Now()`
`108`	`108`	`t.dropCount++`
`109`	`109`	`}`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ func NewClient(cfg Config) *Client {`
`104`	`104`
`105`	`105`	`entries, err := lru.New[string, entry](cfg.CacheLimit)`
`106`	`106`	`if err != nil {`
`107`		`- log.Warn("can't create lru", "err", err)`
	`107`	`+ log.Warn("[p2p] can't create lru", "err", err)`
`108`	`108`	`}`
`109`	`109`	`return &Client{`
`110`	`110`	`cfg: cfg,`
Original file line number	Diff line number	Diff line change
`@@ -301,7 +301,7 @@ func (ln *LocalNode) sign() {`
`301`	`301`	`panic(fmt.Errorf("enode: can't verify local record: %v", err))`
`302`	`302`	`}`
`303`	`303`	`ln.cur.Store(n)`
`304`		`- log.Trace("New local node record", "seq", ln.seq, "id", n.ID(), "ip", n.IPAddr(), "udp", n.UDP(), "tcp", n.TCP())`
	`304`	`+ log.Trace("[p2p] New local node record", "seq", ln.seq, "id", n.ID(), "ip", n.IPAddr(), "udp", n.UDP(), "tcp", n.TCP())`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`func (ln *LocalNode) bumpSeq() {`