What causes "Unknown member: %+v" in dgraph-io/dgraph?

Restart the Alpha so it re-requests a membership assignment from Zero with a fresh id.

Unknown member: %+v

Error message

Unknown member: %+v

What it means

createProposals compares each incoming member with the member Zero has recorded under the same id in the same group. If the member id (mid) is not present in the stored group's Members map, the update references a member Zero does not know, so it rejects with this error.

Source

Thrown at dgraph/cmd/zero/zero.go:364

}

func (s *Server) createProposals(dst *pb.Group) ([]*pb.ZeroProposal, error) {
	var res []*pb.ZeroProposal
	if len(dst.Members) > 1 {
		return res, errors.Errorf("Create Proposal: Invalid group: %+v", dst)
	}

	s.RLock()
	defer s.RUnlock()
	// There is only one member. We use for loop because we don't know what the mid is.
	for mid, dstMember := range dst.Members {
		group, has := s.state.Groups[dstMember.GroupId]
		if !has {
			return res, errors.Errorf("Unknown group for member: %+v", dstMember)
		}
		srcMember, has := group.Members[mid]
		if !has {
			return res, errors.Errorf("Unknown member: %+v", dstMember)
		}
		if srcMember.Addr != dstMember.Addr ||
			srcMember.Leader != dstMember.Leader {

			proposal := &pb.ZeroProposal{
				Member: dstMember,
			}
			res = append(res, proposal)
		}
		if !dstMember.Leader {
			// Don't continue to tablets if request is not from the leader.
			return res, nil
		}
		if dst.SnapshotTs > group.SnapshotTs {
			res = append(res, &pb.ZeroProposal{
				SnapshotTs: map[uint32]uint64{dstMember.GroupId: dst.SnapshotTs},
			})
		}

View on GitHub (pinned to 759e242be6)

Solutions

Restart the Alpha so it re-requests a membership assignment from Zero with a fresh id.
Remove stale member entries via /removeNode and let the Alpha rejoin cleanly.
Wipe the Alpha's p directory if its raft id conflicts, then restart it to join as a new member.
Verify all nodes report to the same Zero leader (check /state) to avoid divergent membership.

Example fix

// before
alpha.Restart() // reuses old raft id unknown to Zero
// after
if memberRemovedFromZero(alpha.NodeId) {
    alpha.WipeRaftDir() // new id on restart
    alpha.Restart()
}

Defensive patterns

Strategy: validation

Validate before calling

state, _ := fetchZeroState(zeroAddr)
if _, ok := state.Groups[groupId].Members[nodeId]; !ok {
    nodeId = rejoinAlphaAndGetNewId()
}

Type guard

func memberKnown(g *pb.Group, mid uint64) bool {
    _, ok := g.Members[mid]
    return ok
}

Try / catch

_, err := zero.UpdateMembership(ctx, state)
if err != nil && strings.Contains(err.Error(), "Unknown member") {
    alpha.RestartWithFreshRaftId(ctx)
}

Prevention

After removing a member via /removeNode, restart the Alpha so it re-registers.
Never wipe an Alpha's p directory without expecting a new raft id.
Verify raft ids in /state before scripted membership operations.
Avoid running duplicate Alpha processes against one Zero.

When it happens

Trigger: An Alpha reports membership with a member id that is absent from Zero's recorded members for that group — typically a restarted Alpha with a new raft id, or a member removed from Zero while the Alpha still reports itself.

Common situations: Alpha's raft id changed after its p/ directory was wiped but it reuses the old group; member was removed via /removeNode while the Alpha process kept running and keeps heartbeating; split cluster with divergent membership.

Related errors

AI-assisted analysis of dgraph-io/dgraph@759e242be6 (2026-09-01). Data as JSON: /api/errors/6d23ff59590f2634. Report an issue: GitHub.