What causes "errors.New(strings.Join(errs, "\n"))" in nats-io/nats-server?

Prune pending entries with seq <= AckFloor.Stream before Update

errors.New(strings.Join(errs, "\n"))

Error message

errors.New(strings.Join(errs, "\n"))

What it means

Returned by consumerMemStore.Update when a pending entry's sequence is outside the valid window: it must be strictly greater than AckFloor.Stream and not exceed Delivered.Stream. A pending sequence at/below the ack floor means it was already acknowledged; one beyond delivered means it was never delivered. Either case indicates a corrupt state.

Source

Thrown at server/accounts.go:4408

	}
	if err != nil {
		respondToUpdate(s, reply, _EMPTY_, fmt.Sprintf("delete accounts request by %s failed", subj), err)
		return
	}
	errs := []string{}
	passCnt := 0
	for _, acc := range accIds {
		if err := store.delete(acc.(string)); err != nil {
			errs = append(errs, err.Error())
		} else {
			passCnt++
		}
	}
	if len(errs) == 0 {
		respondToUpdate(s, reply, _EMPTY_, fmt.Sprintf("deleted %d accounts", passCnt), nil)
	} else {
		respondToUpdate(s, reply, _EMPTY_, fmt.Sprintf("deleted %d accounts, failed for %d", passCnt, len(errs)),
			errors.New(strings.Join(errs, "\n")))
	}
}

func getOperatorKeys(s *Server) (string, map[string]struct{}, bool, error) {
	var op string
	var strict bool
	keys := make(map[string]struct{})
	if opts := s.getOpts(); opts != nil && len(opts.TrustedOperators) > 0 {
		op = opts.TrustedOperators[0].Subject
		strict = opts.TrustedOperators[0].StrictSigningKeyUsage
		if !strict {
			keys[opts.TrustedOperators[0].Subject] = struct{}{}
		}
		for _, key := range opts.TrustedOperators[0].SigningKeys {
			keys[key] = struct{}{}
		}
	}
	if len(keys) == 0 {

View on GitHub (pinned to 3a66a489d2)

Solutions

Prune pending entries with seq <= AckFloor.Stream before Update
Drop pending entries with seq > Delivered.Stream or fix the delivered sequence
Rebuild the pending set from actual unacknowledged deliveries

Example fix

// before
st.Pending[40] = &Pending{40, ts} // ack floor is 50
consumer.Update(st)
// after
for seq := range st.Pending {
    if seq <= st.AckFloor.Stream || seq > st.Delivered.Stream {
        delete(st.Pending, seq)
    }
}
consumer.Update(st)

Defensive patterns

Strategy: validation

Validate before calling

for seq := range st.Pending {
    if seq <= st.AckFloor.Stream || seq > st.Delivered.Stream {
        delete(st.Pending, seq)
    }
}
consumer.Update(st)

Try / catch

if err := consumer.Update(st); err != nil {
    if strings.Contains(err.Error(), "bad pending entry") {
        // prune out-of-range pending and retry once
    }
}

Prevention

Prune pending on every ack that advances the stream ack floor
Treat pending as a set strictly inside (ackFloor, delivered]
Validate state from snapshots/peers before applying

When it happens

Trigger: Calling consumerMemStore.Update with state.Pending containing a sequence seq where seq <= AckFloor.Stream or seq > Delivered.Stream.

Common situations: Stale pending maps not pruned after acks; state reconstructed from partial snapshots; double-applied redelivery state in clustered failover.

Related errors

AI-assisted analysis of nats-io/nats-server@3a66a489d2 (2026-09-02). Data as JSON: /api/errors/e762e4e866555d8c. Report an issue: GitHub.