dashboard: peer metering using custom event stream

dashboard/assets/components/Dashboard.jsx

@@ -92,10 +92,8 @@ const defaultContent: () => Content = () => ({
 	network: {
 		peers: {
 			bundles: {},
-			removedKnownIP:   [],
-			removedKnownID:   [],
-			removedUnknownIP: [],
 		},
+		diff: [],
 	},
 	system: {
 		activeMemory:   [],
@@ -127,9 +125,7 @@ const updaters = {
 	home:    null,
 	chain:   null,
 	txpool:  null,
-	network: {
+	network: peerInserter(200),
-		peers: peerInserter,
-	},
 	system:  {
 		activeMemory:   appender(200),
 		virtualMemory:  appender(200),

dashboard/assets/components/Network.jsx

@@ -23,59 +23,86 @@ import TableHead from '@material-ui/core/TableHead';
 import TableBody from '@material-ui/core/TableBody';
 import TableRow from '@material-ui/core/TableRow';
 import TableCell from '@material-ui/core/TableCell';
-import type {Network as NetworkType, Peers} from '../types/content';
+import type {Network as NetworkType, PeerEvent} from '../types/content';
 
 // inserter is a state updater function for the main component, which handles the peers.
-export const inserter = (update: Peers, prev: Peers) => {
+export const inserter = (sampleLimit: number) => (update: NetworkType, prev: NetworkType) => {
-	console.log(update);
+	if (update.peers && update.peers.bundles) {
-	return prev;
+		prev.peers = update.peers;
-	Object.keys(update.bundles).forEach((ip) => {
+	}
-		if (!update[ip]) {
+	if (Array.isArray(update.diff)) {
+		update.diff.forEach((event: PeerEvent) => {
+			if (event.removeIP) {
+				if (event.removeID && prev.peers.bundles[event.removeIP]) {
+					delete prev.peers.bundles[event.removeIP].knownPeers[event.removeID];
+				}
+				delete prev.peers.bundles[event.removeIP];
 				return;
 			}
-		if (!prev[ip]) {
+			if (!event.ip) {
-			prev[ip] = update[ip];
+				console.error('Peer event without IP', event);
 				return;
 			}
-		if (update[ip].location) {
+			if (!prev.peers.bundles[event.ip]) {
-			prev[ip].location = update[ip].location;
+				prev.peers.bundles[event.ip] = {
+					location:     {},
+					knownPeers:   {},
+					unknownPeers: [],
+				};
 			}
-		if (!update[ip].peers) {
+			const bundle = prev.peers.bundles[event.ip];
-			return;
+			if (event.location) {
+				bundle.location = event.location;
 			}
-		Object.entries(update[ip].peers).forEach(([id, u]) => {
+			if (!event.id) {
-			if (!prev[ip].peers[id]) {
+				bundle.unknownPeers.push({
-				prev[ip].peers[id] = u;
+					connected:    event.connected,
-				return;
+					disconnected: event.disconnected,
-			}
-			const p: Peer = prev[ip].peers[id];
-			if (u.connected) {
-				if (!Array.isArray(p.connected)) {
-					p.connected = [];
-				}
-				p.connected = [...p.connected, ...u.connected];
-			}
-			if (u.disconnected) {
-				if (!Array.isArray(p.disconnected)) {
-					p.disconnected = [];
-				}
-				p.disconnected = [...p.disconnected, ...u.disconnected];
-			}
-			if (Array.isArray(u.ingress)) {
-				if (!Array.isArray(p.ingress)) {
-					p.ingress = [];
-				}
-				p.ingress = [...p.ingress, ...u.ingress].slice(-200);
-			}
-			if (Array.isArray(u.egress)) {
-				if (!Array.isArray(p.egress)) {
-					p.egress = [];
-				}
-				p.egress = [...p.egress, ...u.egress].slice(-200);
-			}
-			prev[ip].peers[id] = p;
 				});
+				return;
+			}
+			if (!bundle.knownPeers[event.id]) {
+				bundle.knownPeers[event.id] = {
+					connected:    [],
+					disconnected: [],
+					ingress:      [],
+					egress:       [],
+				};
+			}
+			const peer = bundle.knownPeers[event.id];
+			if (event.connected) {
+				peer.connected.push(event.connected);
+			}
+			if (event.disconnected) {
+				peer.disconnected.push(event.disconnected);
+			}
+			if (Array.isArray(event.ingress) && Array.isArray(event.egress)) {
+				if (event.ingress.length !== event.egress.length) {
+					console.error('Different traffic sample length', event);
+					return;
+				}
+				if (peer.ingress.length > 0) {
+					if (peer.ingress[peer.ingress.length - 1].value < event.ingress[0].value) {
+						event.ingress[0].value -= peer.ingress[peer.ingress.length - 1].value;
+						event.egress[0].value -= peer.egress[peer.egress.length - 1].value;
+					}
+				}
+				for (let i = 1; i < event.ingress.length; i++) {
+					event.ingress[i].value -= event.ingress[i - 1].value;
+					event.egress[i].value -= event.egress[i - 1].value;
+				}
+				peer.ingress.splice(peer.ingress.length, 0, ...event.ingress);
+				peer.egress.splice(peer.egress.length, 0, ...event.egress);
+				if (peer.ingress.length > sampleLimit) {
+					peer.ingress.splice(0, peer.ingress.length - sampleLimit);
+				}
+				if (peer.egress.length > sampleLimit) {
+					peer.egress.splice(0, peer.egress.length - sampleLimit);
+				}
+				// console.log(event.ingress, prev.peers.bundles[event.ip].knownPeers[event.id].ingress);
+			}
 		});
+	}
 	return prev;
 };
 
@@ -112,7 +139,8 @@ class Network extends Component<Props, State> {
 					<TableRow>
 						<TableCell>IP</TableCell>
 						<TableCell>Location</TableCell>
-						<TableCell>Peer ID</TableCell>
+						<TableCell>Unknown</TableCell>
+						<TableCell>Node ID</TableCell>
 						<TableCell>Ingress</TableCell>
 						<TableCell>Egress</TableCell>
 						<TableCell>Connected</TableCell>
@@ -120,7 +148,7 @@ class Network extends Component<Props, State> {
 					</TableRow>
 				</TableHead>
 				<TableBody>
-					{Object.entries(this.props.content.peers).map(([ip, bundle]) => { console.log(ip, bundle); return (
+					{Object.entries(this.props.content.peers.bundles).map(([ip, bundle]) => (
 						<TableRow key={ip}>
 							<TableCell>{ip}</TableCell>
 							<TableCell>
@@ -130,22 +158,25 @@ class Network extends Component<Props, State> {
 								})() : ''}
 							</TableCell>
 							<TableCell>
-								{bundle.peers && Object.keys(bundle.peers).map(id => id.substring(0, 10)).join(' ')}
+								{bundle.unknownPeers && Object.values(bundle.unknownPeers).map(peer => peer.connected && peer.disconnected && `${this.formatTime(peer.connected)}~${this.formatTime(peer.disconnected)}`).join(', ')}
 							</TableCell>
 							<TableCell>
-								{bundle.peers && Object.values(bundle.peers).map(peer => peer.ingress && peer.ingress.map(sample => sample.value).join(' ')).join(', ')}
+								{bundle.knownPeers && Object.keys(bundle.knownPeers).map(id => id.substring(0, 10)).join(' ')}
 							</TableCell>
 							<TableCell>
-								{bundle.peers && Object.values(bundle.peers).map(peer => peer.egress && peer.egress.map(sample => sample.value).join(' ')).join(', ')}
+								{bundle.knownPeers && Object.values(bundle.knownPeers).map(peer => peer.ingress && peer.ingress.map(sample => sample.value).join(' ')).join(', ')}
 							</TableCell>
 							<TableCell>
-								{bundle.peers && Object.values(bundle.peers).map(peer => peer.connected && peer.connected.map(time => this.formatTime(time)).join(' ')).join(', ')}
+								{bundle.knownPeers && Object.values(bundle.knownPeers).map(peer => peer.egress && peer.egress.map(sample => sample.value).join(' ')).join(', ')}
 							</TableCell>
 							<TableCell>
-								{bundle.peers && Object.values(bundle.peers).map(peer => peer.disconnected && peer.disconnected.map(time => this.formatTime(time)).join(' ')).join(', ')}
+								{bundle.knownPeers && Object.values(bundle.knownPeers).map(peer => peer.connected && peer.connected.map(time => this.formatTime(time)).join(' ')).join(', ')}
+							</TableCell>
+							<TableCell>
+								{bundle.knownPeers && Object.values(bundle.knownPeers).map(peer => peer.disconnected && peer.disconnected.map(time => this.formatTime(time)).join(' ')).join(', ')}
 							</TableCell>
 						</TableRow>
-					)})}
+					))}
 				</TableBody>
 			</Table>
 		);

dashboard/assets/types/content.jsx

@@ -52,13 +52,23 @@ export type TxPool = {
 
 export type Network = {
 	peers: Peers,
+	diff:  Array<PeerEvent>
+};
+
+export type PeerEvent = {
+	ip:           string,
+	id:           string,
+	removeIP:     string,
+	removeID:     string,
+	location:     GeoLocation,
+	connected:    Date,
+	disconnected: Date,
+	ingress:      ChartEntries,
+	egress:       ChartEntries,
 };
 
 export type Peers = {
 	bundles: {[string]: PeerBundle},
-	removedKnownIP:   Array<string>,
-	removedKnownID:   Array<string>,
-	removedUnknownIP: Array<string>,
 };
 
 export type PeerBundle = {
@@ -68,15 +78,10 @@ export type PeerBundle = {
 };
 
 export type KnownPeer = {
-	active:   boolean,
+	connected:    Array<Date>,
-	sessions: Array<PeerSession>
+	disconnected: Array<Date>,
-};
+	ingress:      Array<ChartEntries>,
-
+	egress:       Array<ChartEntries>,
-export type PeerSession = {
-	connected:    Date,
-	disconnected: Date,
-	ingress:      ChartEntries,
-	egress:       ChartEntries,
 };
 
 export type UnknownPeer = {

dashboard/dashboard.go

@@ -42,7 +42,7 @@ import (
 )
 
 const (
-	sampleLimit = 3 // Maximum number of data samples
+	sampleLimit = 200 // Maximum number of data samples
 )
 
 // Dashboard contains the dashboard internals.

dashboard/geoip.go

@@ -86,9 +86,9 @@ func (db *GeoDB) Lookup(ip net.IP) *GeoDBInfo {
 	return result
 }
 
+// Location retrieves the geographical location of the given IP address.
 func (db *GeoDB) Location (ip string) *GeoLocation {
 	location := db.Lookup(net.ParseIP(ip))
-	//location := new(GeoDBInfo)
 	return &GeoLocation{
 		Country:   location.Country.Names.English,
 		City:      location.City.Names.English,

dashboard/message.go

@@ -18,7 +18,6 @@ package dashboard
 
 import (
 	"encoding/json"
-	"github.com/ethereum/go-ethereum/log"
 	"time"
 )
 
@@ -56,210 +55,11 @@ type TxPoolMessage struct {
 	/* TODO (kurkomisi) */
 }
 
-// NetworkMessage contains information about the peers organized based on the IP address.
+// NetworkMessage contains information about the peers
+// organized based on their IP address and node ID.
 type NetworkMessage struct {
-	Peers *PeersMessage `json:"peers,omitempty"`
+	Peers *PeerContainer `json:"peers,omitempty"` // Peer tree.
-}
+	Diff  []*PeerEvent   `json:"diff,omitempty"`  // Events that change the peer tree.
-
-type PeersMessage struct {
-	Bundles          map[string]*PeerBundle `json:"bundles,omitempty"`
-	RemovedKnownIP   []string               `json:"removedKnownIP,omitempty"`
-	RemovedKnownID   []string               `json:"removedKnownID,omitempty"`
-	RemovedUnknownIP []string               `json:"removedUnknownIP,omitempty"`
-}
-
-func NewPeersMessage() *PeersMessage {
-	return &PeersMessage{
-		Bundles: make(map[string]*PeerBundle),
-	}
-}
-
-func (m *PeersMessage) hasBundle(ip string) bool {
-	_, ok := m.Bundles[ip]
-	return ok
-}
-
-func (m *PeersMessage) hasKnownPeer(ip, id string) bool {
-	if m.hasBundle(ip) {
-		return m.Bundles[ip].has(id)
-	}
-	return false
-}
-
-func (m *PeersMessage) initBundle(ip string) bool {
-	if !m.hasBundle(ip) {
-		m.Bundles[ip] = &PeerBundle{
-			KnownPeers: make(map[string]*KnownPeer),
-		}
-		return true
-	}
-	return false
-}
-
-func (m *PeersMessage) initKnownPeer(ip, id string) (bundle, peer bool) {
-	return m.initBundle(ip), m.Bundles[ip].initKnownPeer(id)
-}
-
-func (m *PeersMessage) getOrInitBundle(ip string) *PeerBundle {
-	m.initBundle(ip)
-	return m.Bundles[ip]
-}
-
-func (m *PeersMessage) getOrInitKnownPeer(ip, id string) *KnownPeer {
-	return m.getOrInitBundle(ip).getOrInitKnownPeer(id)
-}
-
-func (m *PeersMessage) removeKnownPeer(ip, id string) {
-	if b, ok := m.Bundles[ip]; ok {
-		b.removeKnownPeer(id)
-		if len(b.KnownPeers) < 1 && len(b.UnknownPeers) < 1 {
-			delete(m.Bundles, ip)
-		}
-	}
-}
-
-func (m *PeersMessage) removeUnknownPeer(ip string) {
-	if b, ok := m.Bundles[ip]; ok {
-		if len(b.UnknownPeers) > 0 {
-			b.UnknownPeers = b.UnknownPeers[1:]
-		}
-		if len(b.KnownPeers) < 1 && len(b.UnknownPeers) < 1 {
-			delete(m.Bundles, ip)
-		}
-	}
-}
-
-func (m *PeersMessage) clear() {
-	for _, bundle := range m.Bundles {
-		bundle.Location = nil
-		for _, peer := range bundle.KnownPeers {
-			peer.clear()
-		}
-		bundle.UnknownPeers = bundle.UnknownPeers[:0]
-	}
-	m.RemovedKnownIP = m.RemovedKnownIP[:0]
-	m.RemovedKnownID = m.RemovedKnownID[:0]
-	m.RemovedUnknownIP = m.RemovedUnknownIP[:0]
-}
-
-type PeerBundle struct {
-	Location     *GeoLocation          `json:"location,omitempty"` // Geographical location based on IP
-	KnownPeers   map[string]*KnownPeer `json:"knownPeers,omitempty"`
-	UnknownPeers []*UnknownPeer        `json:"unknownPeers,omitempty"`
-}
-
-func (b *PeerBundle) has(id string) bool {
-	_, ok := b.KnownPeers[id]
-	return ok
-}
-
-func (b *PeerBundle) initKnownPeer(id string) bool {
-	if !b.has(id) {
-		b.KnownPeers[id] = new(KnownPeer)
-		return true
-	}
-	return false
-}
-
-func (b *PeerBundle) getOrInitKnownPeer(id string) *KnownPeer {
-	b.initKnownPeer(id)
-	return b.KnownPeers[id]
-}
-
-func (b *PeerBundle) removeKnownPeer(id string) bool {
-	if b.has(id) {
-		b.KnownPeers[id].clear()
-		delete(b.KnownPeers, id)
-		return true
-	}
-	return false
-}
-
-type KnownPeer struct {
-	Active      bool           `json:"active"`
-	Sessions    []*PeerSession `json:"sessions,omitempty"`
-	sampleCount int
-}
-
-func (peer *KnownPeer) append(session *PeerSession) {
-	if session == nil {
-		return
-	}
-	ingress, egress := session.Ingress, session.Egress
-	// Truncate the traffic arrays if they have more samples than the limit.
-	if first := len(ingress) - sampleLimit; first > 0 {
-		ingress = ingress[first:]
-	}
-	// If the length of the ingress and the egress arrays are different,
-	// cut the first part of the longer one. i.e. make sure they have the
-	// same length.
-	if first := len(ingress) - len(egress); first > 0 {
-		ingress = ingress[first:]
-	} else if first < 0 {
-		egress = egress[-first:]
-	}
-	if len(peer.Sessions) < 1 {
-		// If this is the first session.
-		peer.Sessions = append(peer.Sessions, session)
-		peer.sampleCount = len(ingress)
-		return
-	}
-	// Cut the old samples from the beginning if the
-	// count with the new samples exceeds the limit.
-	for l := sampleLimit + len(ingress) - peer.sampleCount; l > 0; l-- {
-		for len(peer.Sessions) > 0 && len(peer.Sessions[0].Ingress) < 1 {
-			peer.Sessions = peer.Sessions[1:]
-		}
-		if len(peer.Sessions) < 1 {
-			// This can only happen, when the sample count is greater than the
-			// sample limit. Theoretically impossible.
-			log.Warn("Empty session array with sample count greater than 0")
-			return
-		}
-		first := peer.Sessions[0]
-		first.Ingress = first.Ingress[1:]
-		first.Egress = first.Egress[1:]
-		peer.sampleCount--
-	}
-	peer.sampleCount += len(ingress)
-	if session.Connected != nil {
-		peer.Sessions = append(peer.Sessions, session)
-		return
-	}
-	last := peer.Sessions[len(peer.Sessions)-1]
-	last.Disconnected = session.Disconnected
-	last.Ingress = append(last.Ingress, ingress...)
-	last.Egress = append(last.Egress, egress...)
-}
-
-func (peer *KnownPeer) upgrade(p *KnownPeer) {
-	peer.Active = p.Active
-	for _, session := range p.Sessions {
-		peer.append(session)
-	}
-}
-
-func (peer *KnownPeer) clear() {
-	for _, s := range peer.Sessions {
-		s.Connected = nil
-		s.Disconnected = nil
-		s.Ingress = nil
-		s.Egress = nil
-	}
-	peer.Sessions = peer.Sessions[:0]
-	peer.sampleCount = 0
-}
-
-type PeerSession struct {
-	Connected    *time.Time   `json:"connected,omitempty"`
-	Disconnected *time.Time   `json:"disconnected,omitempty"`
-	Ingress      ChartEntries `json:"ingress,omitempty"`
-	Egress       ChartEntries `json:"egress,omitempty"`
-}
-
-type UnknownPeer struct {
-	Connected    time.Time `json:"connected"`
-	Disconnected time.Time `json:"disconnected"`
 }
 
 // SystemMessage contains the metered system data samples.

dashboard/peers.go

@@ -18,12 +18,8 @@ package dashboard
 
 import (
 	"container/list"
-	"encoding/json"
-	"fmt"
 	"github.com/ethereum/go-ethereum/metrics"
-	"github.com/mohae/deepcopy"
 	"strings"
-	"sync"
 	"time"
 
 	"github.com/ethereum/go-ethereum/log"
@@ -31,146 +27,344 @@ import (
 )
 
 const (
-	eventBufferLimit = 128
+	eventBufferLimit = 128                  // Maximum number of events of buffered peer events.
-	knownPeerLimit   = 3 //p2p.MeteredPeerLimit
+	knownPeerLimit   = p2p.MeteredPeerLimit // Maximum number of stored peers, which successfully made the handshake.
-	unknownPeerLimit = 3 //p2p.MeteredPeerLimit
+	unknownPeerLimit = p2p.MeteredPeerLimit // Maximum number of stored peers, which failed to make the handshake.
+
+	// eventLimit is the maximum number of the dashboard's custom peer events,
+	// that are collected between two metering period and sent to the clients
+	// as one message.
+	// TODO (kurkomisi): Limit the number of events.
+	eventLimit = knownPeerLimit << 2
 )
 
-type knownPeerDiff struct {
+// PeerContainer contains information about the node's peers. This data structure
-	*KnownPeer
+// maintains the metered peer data based on the different behaviours of the peers.
-	activeListElement *list.Element
+//
-	listElement       *list.Element // Pointer to the peer element in the list.
+// Every peer has an IP address, and the peers that manage to make the handshake
-	ip, id            string
+// (known peers) have node IDs too. There can appear more peers with the same IP,
-}
+// therefore the peer maintainer data structure is a tree consisting of a map of
+// maps, where the first key groups the peers by IP, while the second one groups
+// them by the node ID. The peers failing before the handshake (unknown peers)
+// only have IP addresses, so their connection attempts are stored as part of the
+// value of the outer map.
+//
+// Another criteria is to limit the number of metered peers so that
+// they don't fill the memory. The selection order is based on the
+// peers activity: the peers that are inactive for the longest time
+// are thrown first. For the selection a fifo list is used which is
+// linked to the bottom of the peer tree in a way that every activity
+// of the peer pushes the peer to the end of the list, so the inactive
+// ones come to the front. When a peer has some activity, it is removed
+// from and reinserted into the list. When the length of the list reaches
+// the limit, the first element is removed from the list, as well as from
+// the tree.
+//
+// The active peers that are still connected have priority over the disconnected
+// ones, therefore the list is extended by a separator, which is a pointer to a
+// list element. The separator separates the active peers from the inactive ones,
+// and it is the entry for the list. If the peer that is to be inserted is active,
+// it goes after the separator, otherwise it goes before. This way the active peers
+// never move to the front before the inactive ones.
+//
+// The peers that don't manage to make handshake are not inserted into the list,
+// only their connection attempts are appended to the array belonging to their IP.
+// In order to keep the fifo principle, a super array contains the order of the
+// attempts, and when the overall count reaches the limit, the earliest attempt is
+// removed from the beginning of its array.
+//
+// This data structure makes it possible to marshal the peer
+// history simply by passing it to the JSON marshaler.
+type PeerContainer struct {
+	// Bundles is the outer map using the peer's IP address as key.
+	Bundles map[string]*PeerBundle `json:"bundles,omitempty"`
 
-type peerDiff struct {
+	// activeSeparator is a pointer to the last inactive peer element, splitting
-	*PeersMessage
+	// the list into an inactive and an active part, and forming the entry for
-	root     *PeersMessage
+	// the peer list.
-	rootLock *sync.RWMutex
+	activeSeparator *list.Element
 
-	knownActivePeerList   *list.List
+	// knownPeers contains the peers that managed to make handshake.
-	knownInactivePeerList *list.List
+	knownPeers *list.List
+
+	// unknownPeers is the super array containing the IP addresses, from which
+	// the peers attempted to connect then failed before/during the handshake.
+	// Its values are appended in chronological order, which means that the
+	// oldest attempt is at the beginning of the array. When the first element
+	// is removed, the first element of the related bundle's attempt array is
+	// removed too, ensuring that always the latest attempts are stored.
 	unknownPeers []string
 
+	// geodb is the geoip database used to retrieve the peers' geographical location.
 	geodb *GeoDB
+
+	// refresh is the refresh rate used to generate the
+	// initial auxiliary traffic samples' time stamps.
 	refresh time.Duration
 }
 
-func newPeerDiff(root *PeersMessage, rootLock *sync.RWMutex, geodb *GeoDB, refresh time.Duration) *peerDiff {
+// NewPeerContainer returns a new instance of the peer container.
-	return &peerDiff{
+func NewPeerContainer(geodb *GeoDB, refresh time.Duration) *PeerContainer {
-		PeersMessage:          NewPeersMessage(),
+	return &PeerContainer{
-		root:                  root,
+		Bundles:      make(map[string]*PeerBundle),
-		rootLock:              rootLock,
+		knownPeers:   list.New(),
-		knownActivePeerList:   list.New(),
-		knownInactivePeerList: list.New(),
 		unknownPeers: make([]string, 0, unknownPeerLimit),
 		geodb:        geodb,
 		refresh:      refresh,
 	}
 }
 
-func (diff *peerDiff) insert(ip, id string, session *PeerSession) {
+// getOrInitBundle inserts a new peer bundle into the map, if the peer belonging
-	newIP, newID := diff.initKnownPeer(ip, id)
+// to the given IP wasn't metered so far. In this case retrieves the location of
-	bundle := diff.Bundles[ip]
+// the IP address from the database and creates a corresponding peer event.
-	if newIP {
+// Returns the bundle belonging to the given IP and the events occurring during
-		bundle.Location = diff.geodb.Location(ip)
+// the initialization.
+func (pc *PeerContainer) getOrInitBundle(ip string) (*PeerBundle, []*PeerEvent) {
+	var events []*PeerEvent
+	if _, ok := pc.Bundles[ip]; !ok {
+		location := pc.geodb.Location(ip)
+		events = append(events, &PeerEvent{
+			IP:       ip,
+			Location: location,
+		})
+		pc.Bundles[ip] = &PeerBundle{
+			Location:   location,
+			KnownPeers: make(map[string]*KnownPeer),
 		}
-	peer := &knownPeerDiff{
+	}
-		KnownPeer: bundle.KnownPeers[id],
+	return pc.Bundles[ip], events
+}
+
+// extendKnown handles the events of the successfully connected peers.
+// Returns the events occurring during the extension.
+func (pc *PeerContainer) extendKnown(event *PeerEvent) (events []*PeerEvent) {
+	bundle, bundleInitEvents := pc.getOrInitBundle(event.IP)
+	events = append(events, bundleInitEvents...)
+	peer, peerInitEvents := bundle.getOrInitKnownPeer(event.IP, event.ID, pc.refresh)
+	events = append(events, peerInitEvents...)
+	if peer.listElement != nil {
+		// If the peer is already in the list, remove it and reinsert later.
+		pc.knownPeers.Remove(peer.listElement)
+		peer.listElement = nil
+	}
+	for pc.knownPeers.Len() >= knownPeerLimit {
+		// While the length of the list is greater than or equal to the limit before
+		// the insertion, remove the first element from the list and from the map.
+		if removedPeer, ok := pc.knownPeers.Remove(pc.knownPeers.Front()).(*KnownPeer); ok {
+			if event := pc.removeKnown(removedPeer.ip, removedPeer.id); event != nil {
+				events = append(events, event)
+			}
+		}
+	}
+	// Append the connect and the disconnect events to
+	// the corresponding arrays keeping the limit.
+	if event.Connected != nil {
+		peer.Connected = append(peer.Connected, event.Connected)
+		if first := len(peer.Connected) - sampleLimit; first > 0 {
+			peer.Connected = peer.Connected[first:]
+		}
+	}
+	if event.Disconnected != nil {
+		peer.Disconnected = append(peer.Disconnected, event.Disconnected)
+		if first := len(peer.Disconnected) - sampleLimit; first > 0 {
+			peer.Disconnected = peer.Disconnected[first:]
+		}
+	}
+	// Insert the peer into the list.
+	if pc.activeSeparator == nil {
+		// If there isn't active peer in the list
+		peer.listElement = pc.knownPeers.PushBack(peer)
+		pc.activeSeparator = peer.listElement
+	} else {
+		// Insert the peer after the last inactive peer, then increment the separator.
+		peer.listElement = pc.knownPeers.InsertAfter(peer, pc.activeSeparator)
+		pc.activeSeparator = pc.activeSeparator.Next()
+	}
+	return events
+}
+
+// extendUnknown handles the events of the peers failing before/during the handshake.
+// Returns the events occurring during the extension.
+func (pc *PeerContainer) extendUnknown(event *PeerEvent) (events []*PeerEvent) {
+	bundle, initEvents := pc.getOrInitBundle(event.IP)
+	events = append(events, initEvents...)
+	bundle.UnknownPeers = append(bundle.UnknownPeers, &UnknownPeer{
+		Connected:    *event.Connected,
+		Disconnected: *event.Disconnected,
+	})
+	pc.unknownPeers = append(pc.unknownPeers, event.IP)
+	for len(pc.unknownPeers) > unknownPeerLimit {
+		// While the length of the connection attempt order array is greater
+		// than the limit, remove the first element from the involved peer's
+		// array and also from the super array.
+		if r := pc.removeUnknown(pc.unknownPeers[0]); r != nil {
+			events = append(events, r)
+		}
+		pc.unknownPeers = pc.unknownPeers[1:]
+	}
+	return events
+}
+
+// setActive moves the peer denoted by the given IP address and node ID after
+// the list's active separator.
+func (pc *PeerContainer) setActive(ip, id string) {
+	if bundle, ok := pc.Bundles[ip]; ok {
+		if peer, ok := bundle.KnownPeers[id]; ok {
+			if peer.listElement != nil {
+				// If the peer is already in the list, remove it first.
+				// Theoretically this should always happen, because all
+				// the peers are inserted into the list.
+				pc.knownPeers.Remove(peer.listElement)
+			}
+			if pc.activeSeparator == nil {
+				// If there isn't active peer yet.
+				peer.listElement = pc.knownPeers.PushBack(peer)
+				pc.activeSeparator = peer.listElement
+			} else {
+				peer.listElement = pc.knownPeers.InsertAfter(peer, pc.activeSeparator)
+			}
+		}
+	}
+}
+
+// resetActiveSeparator resets the active separator, denoting
+// that active peers are not considered active anymore.
+func (pc *PeerContainer) resetActiveSeparator() {
+	pc.activeSeparator = nil
+}
+
+// PeerBundle contains the peers belonging to a given IP address.
+type PeerBundle struct {
+	// Location contains the geographical location based on the bundle's IP address.
+	Location *GeoLocation `json:"location,omitempty"`
+
+	// KnownPeers is the inner map of the metered peer
+	// maintainer data structure using the node ID as key.
+	KnownPeers map[string]*KnownPeer `json:"knownPeers,omitempty"`
+
+	// UnknownPeers contains the failed connection attempts of the
+	// peers belonging to a given IP address in chronological order.
+	UnknownPeers []*UnknownPeer `json:"unknownPeers,omitempty"`
+}
+
+// removeKnown removes the known peer belonging to the
+// given IP address and node ID from the peer tree.
+func (pc *PeerContainer) removeKnown(ip, id string) (removed *PeerEvent) {
+	if bundle, ok := pc.Bundles[ip]; ok {
+		if _, ok := bundle.KnownPeers[id]; ok {
+			removed = &PeerEvent{
+				RemoveID: id,
+			}
+			delete(bundle.KnownPeers, id)
+		}
+		if len(bundle.KnownPeers) < 1 && len(bundle.UnknownPeers) < 1 {
+			if removed == nil {
+				removed = &PeerEvent{
+					RemoveIP: ip,
+				}
+			} else {
+				removed.RemoveIP = ip
+			}
+			delete(pc.Bundles, ip)
+		}
+	}
+	return removed
+}
+
+// removeUnknown removes the unknown peer belonging to the
+// given IP address and node ID from the peer tree.
+func (pc *PeerContainer) removeUnknown(ip string) (removed *PeerEvent) {
+	if bundle, ok := pc.Bundles[ip]; ok {
+		if len(bundle.UnknownPeers) > 0 {
+			bundle.UnknownPeers = bundle.UnknownPeers[1:]
+		}
+		if len(bundle.KnownPeers) < 1 && len(bundle.UnknownPeers) < 1 {
+			removed = &PeerEvent{RemoveIP: ip}
+			delete(pc.Bundles, ip)
+		}
+	}
+	return removed
+}
+
+// getOrInitKnownPeer inserts a new peer into the map, if the peer belonging
+// to the given IP address and node ID wasn't metered so far. Returns the peer
+// belonging to the given IP and ID as well as the events occurring during the
+// initialization.
+func (bundle *PeerBundle) getOrInitKnownPeer(ip, id string, refresh time.Duration) (*KnownPeer, []*PeerEvent) {
+	var events []*PeerEvent
+	if _, ok := bundle.KnownPeers[id]; !ok {
+		now := time.Now()
+		ingress := emptyChartEntries(now, sampleLimit, refresh)
+		egress := emptyChartEntries(now, sampleLimit, refresh)
+		events = append(events, &PeerEvent{
+			IP:      ip,
+			ID:      id,
+			Ingress: ingress,
+			Egress:  egress,
+		})
+		bundle.KnownPeers[id] = &KnownPeer{
 			ip:      ip,
 			id:      id,
-	}
+			Ingress: ingress,
-	if newID {
+			Egress:  egress,
-		now := time.Now()
-		peer.append(&PeerSession{
-			Ingress: emptyChartEntries(now, sampleLimit, diff.refresh),
-			Egress:  emptyChartEntries(now, sampleLimit, diff.refresh),
-		})
-	}
-	peer.append(session)
-	if peer.activeListElement != nil {
-		diff.knownActivePeerList.Remove(peer.activeListElement)
-	}
-	if peer.listElement != nil {
-		diff.knownInactivePeerList.Remove(peer.listElement)
-	}
-	// Set peer activity
-	if len(peer.Sessions) > 0 {
-		peer.Active = peer.Sessions[len(peer.Sessions)-1].Disconnected == nil
-	} else {
-		diff.rootLock.RLock()
-		if diff.root.hasKnownPeer(ip, id) {
-			rootSessions := diff.root.Bundles[ip].KnownPeers[id].Sessions
-			peer.Active = len(rootSessions) > 0 && rootSessions[len(rootSessions)-1].Disconnected == nil
-		} else {
-			peer.Active = false
-		}
-		diff.rootLock.RUnlock()
-	}
-	if peer.Active {
-		peer.activeListElement = diff.knownActivePeerList.PushBack(peer)
-	} else {
-		peer.listElement = diff.knownInactivePeerList.PushBack(peer)
-	}
-	for diff.knownActivePeerList.Len()+diff.knownInactivePeerList.Len() > knownPeerLimit {
-		var removed interface{}
-		if diff.knownInactivePeerList.Len() > 0 {
-			removed = diff.knownInactivePeerList.Remove(diff.knownInactivePeerList.Front())
-		} else {
-			removed = diff.knownActivePeerList.Remove(diff.knownActivePeerList.Front())
-		}
-		if p, ok := removed.(*knownPeerDiff); ok {
-			diff.removeKnownPeer(p.ip, p.id)
-			diff.rootLock.RLock()
-			if diff.root.hasKnownPeer(p.ip, p.id) {
-				diff.RemovedKnownIP = append(diff.RemovedKnownIP, p.ip)
-				diff.RemovedKnownID = append(diff.RemovedKnownID, p.id)
-			}
-			diff.rootLock.RUnlock()
 		}
 	}
+	return bundle.KnownPeers[id], events
 }
 
-func (diff *peerDiff) insertUnknown(ip string, peer *UnknownPeer) {
+// KnownPeer contains the metered data of a particular peer.
-	newBundle := diff.initBundle(ip)
+type KnownPeer struct {
-	bundle := diff.Bundles[ip]
+	// Connected contains the timestamps of the peer's connection events.
-	if newBundle {
+	Connected []*time.Time `json:"connected,omitempty"`
-		bundle.Location = diff.geodb.Location(ip)
+
-	}
+	// Disconnected contains the timestamps of the peer's disconnection events.
-	diff.unknownPeers = append(diff.unknownPeers, ip)
+	Disconnected []*time.Time `json:"disconnected,omitempty"`
-	bundle.UnknownPeers = append(bundle.UnknownPeers, peer)
+
-	for len(diff.unknownPeers) > unknownPeerLimit {
+	// Ingress and Egress contain the peer's traffic samples, which are collected
-		rip := diff.unknownPeers[0]
+	// periodically from the metrics registry.
-		diff.RemovedUnknownIP = append(diff.RemovedUnknownIP, rip)
+	//
-		diff.removeUnknownPeer(rip)
+	// A peer can connect multiple times, and we want to visualize the time
-		diff.unknownPeers = diff.unknownPeers[1:]
+	// passed between two connections, so after the first connection a 0 value
-	}
+	// is appended to the traffic arrays even if the peer is inactive until the
+	// peer is removed.
+	Ingress ChartEntries `json:"ingress,omitempty"`
+	Egress  ChartEntries `json:"egress,omitempty"`
+
+	listElement *list.Element // Pointer to the peer element in the list.
+	ip, id      string        // The IP and the ID by which the peer can be accessed in the tree.
 }
 
-func (diff *peerDiff) dump() {
+// UnknownPeer contains a failed peer connection attempt's attributes.
-	diff.rootLock.Lock()
+type UnknownPeer struct {
-	for i := 0; i < len(diff.RemovedKnownIP); i++ {
+	// Connected contains the timestamp of the connection attempt's moment.
-		diff.root.removeKnownPeer(diff.RemovedKnownIP[i], diff.RemovedKnownID[i])
+	Connected time.Time `json:"connected"`
+
+	// Disconnected contains the timestamp of the
+	// moment when the connection attempt failed.
+	Disconnected time.Time `json:"disconnected"`
+}
+
+// PeerEvent contains the attributes of a peer event.
+type PeerEvent struct {
+	IP           string       `json:"ip,omitempty"`           // IP address of the peer.
+	ID           string       `json:"id,omitempty"`           // Node ID of the peer.
+	RemoveIP     string       `json:"removeIP,omitempty"`     // IP address of the peer that is to be removed.
+	RemoveID     string       `json:"removeID,omitempty"`     // Node ID of the peer that is to be removed.
+	Location     *GeoLocation `json:"location,omitempty"`     // Geographical location of the peer.
+	Connected    *time.Time   `json:"connected,omitempty"`    // Timestamp of the connection moment.
+	Disconnected *time.Time   `json:"disconnected,omitempty"` // Timestamp of the disonnection moment.
+	Ingress      ChartEntries `json:"ingress,omitempty"`      // Ingress samples.
+	Egress       ChartEntries `json:"egress,omitempty"`       // Egress samples.
+}
+
+// trafficMap
+type trafficMap map[string]map[string]float64
+
+func (m *trafficMap) insert(ip, id string, val float64) {
+	if _, ok := (*m)[ip]; !ok {
+		(*m)[ip] = make(map[string]float64)
 	}
-	for _, rip := range diff.RemovedUnknownIP {
+	(*m)[ip][id] = val
-		diff.root.removeUnknownPeer(rip)
-	}
-	for e := diff.knownActivePeerList.Front(); e != nil; e = e.Next() {
-		if peer, ok := e.Value.(*knownPeerDiff); ok {
-			diff.root.getOrInitKnownPeer(peer.ip, peer.id).upgrade(peer.KnownPeer)
-		} else {
-			log.Warn("Invalid value in the active peer metrics list")
-		}
-	}
-	for e := diff.knownInactivePeerList.Front(); e != nil; e = e.Next() {
-		if peer, ok := e.Value.(*knownPeerDiff); ok {
-			diff.root.getOrInitKnownPeer(peer.ip, peer.id).upgrade(peer.KnownPeer)
-		} else {
-			log.Warn("Invalid value in the inactive peer metrics list")
-		}
-	}
-	diff.rootLock.Unlock()
-	diff.clear()
 }
 
 // collectPeerData gathers data about the peers and sends it to the clients.
@@ -194,15 +388,26 @@ func (db *Dashboard) collectPeerData() {
 	defer ticker.Stop()
 
 	type registryFunc func(name string, i interface{})
-	type collectorFunc func(traffic *map[string]float64) registryFunc
+	type collectorFunc func(traffic *trafficMap) registryFunc
 
+	// trafficCollector generates a function that can be passed to
+	// the prefixed peer registry in order to collect the metered
+	// traffic data from each peer meter.
 	trafficCollector := func(prefix string) collectorFunc {
-		return func(traffic *map[string]float64) registryFunc {
+		// This part makes is possible to collect the
+		// traffic data into a map from outside.
+		return func(traffic *trafficMap) registryFunc {
+			// The function which can be passed to the registry.
 			return func(name string, i interface{}) {
 				if m, ok := i.(metrics.Meter); ok {
-					(*traffic)[strings.TrimPrefix(name, prefix)] = float64(m.Count())
+					// The name of the meter has the format: <common traffic prefix><IP>/<ID>
+					if k := strings.Split(strings.TrimPrefix(name, prefix), "/"); len(k) == 2 {
+						traffic.insert(k[0], k[1], float64(m.Count()))
 					} else {
-					log.Warn("Bad value used as meter", "name", name)
+						log.Warn("Invalid meter name", "name", name, "prefix", prefix)
+					}
+				} else {
+					log.Warn("Invalid meter type", "name", name)
 				}
 			}
 		}
@@ -210,11 +415,19 @@ func (db *Dashboard) collectPeerData() {
 	collectIngress := trafficCollector(p2p.MetricsInboundTraffic + "/")
 	collectEgress := trafficCollector(p2p.MetricsOutboundTraffic + "/")
 
+	peers := NewPeerContainer(db.geodb, db.config.Refresh)
 	db.peerLock.Lock()
-	db.history.Network = &NetworkMessage{Peers: NewPeersMessage()}
+	db.history.Network = &NetworkMessage{
-	diff := newPeerDiff(db.history.Network.Peers, &db.peerLock, db.geodb, db.config.Refresh)
+		Peers: peers,
+	}
 	db.peerLock.Unlock()
 
+	// diff contains peer events, which trigger operations that
+	// will be executed on the peer tree after a metering period.
+	diff := make([]*PeerEvent, 0, eventLimit)
+	ingress, egress := new(trafficMap), new(trafficMap)
+	*ingress, *egress = make(trafficMap), make(trafficMap)
+
 	for {
 		select {
 		case event := <-peerCh:
@@ -222,80 +435,121 @@ func (db *Dashboard) collectPeerData() {
 			switch event.Type {
 			case p2p.PeerConnected:
 				connected := now.Add(-event.Elapsed)
-				diff.insert(event.IP.String(), event.ID, &PeerSession{
+				diff = append(diff, &PeerEvent{
+					IP:        event.IP.String(),
+					ID:        event.ID,
 					Connected: &connected,
 				})
 			case p2p.PeerDisconnected:
-				diff.insert(event.IP.String(), event.ID, &PeerSession{
+				diff = append(diff, &PeerEvent{
+					IP:           event.IP.String(),
+					ID:           event.ID,
 					Disconnected: &now,
-					Ingress: ChartEntries{
-						&ChartEntry{
-							Time:  now,
-							Value: float64(event.Ingress),
-						},
-					},
-					Egress: ChartEntries{
-						&ChartEntry{
-							Time:  now,
-							Value: float64(event.Egress),
-						},
-					},
 				})
+				// The disconnect event comes with the last metered traffic count,
+				// because after the disconnection the peer's meter is removed
+				// from the registry. It can happen, that between two metering
+				// period the same peer disconnects multiple times, and appending
+				// all the samples to the traffic arrays would shift the metering,
+				// so only the last metering is stored, overwriting the previous one.
+				ingress.insert(event.IP.String(), event.ID, float64(event.Ingress))
+				egress.insert(event.IP.String(), event.ID, float64(event.Egress))
 			case p2p.PeerHandshakeFailed:
-				diff.insertUnknown(event.IP.String(), &UnknownPeer{
+				connected := now.Add(-event.Elapsed)
-					Connected:    now.Add(-event.Elapsed),
+				diff = append(diff, &PeerEvent{
-					Disconnected: now,
+					IP:           event.IP.String(),
+					Connected:    &connected,
+					Disconnected: &now,
 				})
 			default:
 				log.Error("Unknown metered peer event type", "type", event.Type)
 			}
 		case <-ticker.C:
-			ingress, egress := make(map[string]float64), make(map[string]float64)
+			// Collect the traffic samples from the registry.
-			p2p.PeerIngressRegistry.Each(collectIngress(&ingress))
+			p2p.PeerIngressRegistry.Each(collectIngress(ingress))
-			p2p.PeerEgressRegistry.Each(collectEgress(&egress))
+			p2p.PeerEgressRegistry.Each(collectEgress(egress))
 
-			now := time.Now()
+			db.peerLock.Lock()
-			appendSample := func(key string, ingress, egress float64) {
+			// Usually the active peers don't produce events, and marking
-				if k := strings.Split(key, "/"); len(k) == 2 {
+			// them as active makes it sure that they won't be removed from
-					diff.insert(k[0], k[1], &PeerSession{
+			// the tree. Only the active peers are registered into the peer
-						Ingress: ChartEntries{&ChartEntry{
+			// registry, so after the traffic collection the ingress and the
-							Time:  now,
+			// egress maps contain all the active peers.
-							Value: ingress,
+			//
-						}},
+			// It is important to mark the active ones before the merge with
-						Egress: ChartEntries{&ChartEntry{
+			// the diff, otherwise the active peers can be removed.
-							Time:  now,
+			//
-							Value: egress,
+			// After a metering period the active peers can become inactive,
-						}},
+			// so resetting the separator makes it sure, that only the active
-					})
+			// peers move to the protected part of the list.
-				} else {
+			peers.resetActiveSeparator()
-					log.Warn("Invalid traffic key", "key", key)
+			for ip, bundle := range *ingress {
+				for id := range bundle {
+					if _, ok := (*egress)[ip][id]; ok {
+						peers.setActive(ip, id)
 					}
 				}
-			for key, val := range ingress {
-				appendSample(key, val, egress[key])
 			}
-			for key, val := range egress {
+			var events []*PeerEvent
-				if _, ok := ingress[key]; ok {
+			for i := 0; i < len(diff); i++ {
+				if diff[i].IP == "" {
+					log.Warn("Peer event without IP", "event", *diff[i])
 					continue
 				}
-				appendSample(key, ingress[key], val)
+				// There are two main branches of peer events coming from the event
+				// feed, one belongs to the known peers, one to the unknown peers.
+				// If the event has node ID, it belongs to a known peer, otherwise
+				// to an unknown one.
+				if diff[i].ID == "" {
+					events = append(events, peers.extendUnknown(diff[i])...)
+					continue
 				}
-			for e := diff.knownInactivePeerList.Front(); e != nil; e = e.Next() {
+				events = append(events, peers.extendKnown(diff[i])...)
-				if peer, ok := e.Value.(*knownPeerDiff); ok {
+			}
-					diff.insert(peer.ip, peer.id, &PeerSession{
+			// The insertion can produce additional peer events, such
-						Ingress: ChartEntries{&ChartEntry{
+			// as remove, location and initial samples events. These
+			// are stored in the 'events', then appended to the 'diff'.
+			diff = append(diff, events...)
+			now := time.Now()
+			// Update the peer tree using the events.
+			for ip, bundle := range peers.Bundles {
+				for id, peer := range bundle.KnownPeers {
+					// Value is 0 if the traffic map doesn't have the
+					// entry corresponding to the given IP and ID.
+					i := &ChartEntry{
 						Time:  now,
-						}},
+						Value: (*ingress)[ip][id],
-						Egress: ChartEntries{&ChartEntry{
+					}
+					e := &ChartEntry{
 						Time:  now,
-						}},
+						Value: (*egress)[ip][id],
+					}
+					peer.Ingress = append(peer.Ingress, i)
+					peer.Egress = append(peer.Egress, e)
+					if first := len(peer.Ingress) - sampleLimit; first > 0 {
+						peer.Ingress = peer.Ingress[first:]
+					}
+					if first := len(peer.Egress) - sampleLimit; first > 0 {
+						peer.Egress = peer.Egress[first:]
+					}
+					// Creating the traffic sample events.
+					diff = append(diff, &PeerEvent{
+						IP:      ip,
+						ID:      id,
+						Ingress: ChartEntries{i},
+						Egress:  ChartEntries{e},
 					})
 				}
 			}
-			db.sendToAll(&Message{Network: &NetworkMessage{Peers: deepcopy.Copy(diff.PeersMessage).(*PeersMessage)}})
+			db.peerLock.Unlock()
-			s, _ := json.MarshalIndent(deepcopy.Copy(diff), "", "  ")
+
-			fmt.Println(string(s))
+			db.sendToAll(&Message{Network: &NetworkMessage{
-			diff.dump()
+				Diff: append([]*PeerEvent{}, diff...)},
+			})
+			// Clear the traffic maps, and the event array,
+			// prepare them for the next metering.
+			*ingress, *egress = make(trafficMap), make(trafficMap)
+			diff = diff[:0]
 		case err := <-subPeer.Err():
 			log.Warn("Peer subscription error", "err", err)
 			return