Method executeConsensus

consensus/executor.go:180–291

executeConsensus decouples two distinct concerns: 1. Caller-visible latency: the caller must return promptly when its context is cancelled (HTTP disconnect, upstream deadline, shutdown). 2. Analysis completeness: misbehavior tracking and metrics must see every participant's response, even ones that

(
	ctx context.Context,
	lg *zerolog.Logger,
	originalReq *common.NormalizedRequest,
	labels metricsLabels,
	in inner,
	startTime time.Time,
	consensusSpan trace.Span,
)

// which is already bounded by failsafe policy timeouts and HTTP client
// timeouts — no new magic-number budget is required.
func (e *executor) executeConsensus(
	ctx context.Context,
	lg *zerolog.Logger,
	originalReq *common.NormalizedRequest,
	labels metricsLabels,
	in inner,
	startTime time.Time,
	consensusSpan trace.Span,
) *slotResult {
	ctx, collectionSpan := common.StartDetailSpan(ctx, "Consensus.CollectResponses")
	// NOTE: collectionSpan.End() is owned by runAnalyzer (in its deferred
	// cleanup), not this function. The analyzer outlives executeConsensus on
	// the caller-cancel path, and ending the span here would drop late
	// attributes (short_circuited, responses.collected).

	// For fire-and-forget mode, detach from parent context cancellation so background
	// requests continue even after the HTTP response is sent. This is critical for
	// transaction broadcasting where we want all nodes to receive the transaction.
	// For normal mode, inherit parent cancellation for proper resource cleanup.
	var baseCtx context.Context
	if e.config.fireAndForget {
		baseCtx = context.WithoutCancel(ctx)
	} else {
		baseCtx = ctx
	}

	cancellableCtx, cancelFunc := context.WithCancel(baseCtx)
	var cancelOnce sync.Once
	cancelRemaining := func() {
		cancelOnce.Do(cancelFunc)
	}

	// Cancel remaining requests on exit, unless fire-and-forget mode is enabled.
	// In fire-and-forget mode we want background requests to complete naturally.
	// sync.Once ensures cancel is called at most once even if called explicitly earlier.
	defer func() {
		if !e.config.fireAndForget {
			cancelRemaining()
		}
	}()

	// Spawn only as many participants as configured by policy
	maxToSpawn := e.maxParticipants
	if maxToSpawn <= 0 {
		maxToSpawn = 1
	}
	// Record on the request's ExecState that THIS request went through
	// the consensus executor and how many participants we spawned. Read
	// downstream by diagnostic surfaces (admin endpoints, response
	// headers, the simulator's lifecycle drawer) so operators can tell
	// "this request was a consensus race" from "this was a hedge race"
	// — the two look similar in the per-attempt log otherwise.
	if st := originalReq.ExecState(); st != nil {
		st.ConsensusSlots.Add(int32(maxToSpawn))
	}
	responseChan := make(chan *execResult, maxToSpawn)
	// Per-slot cancellable child contexts let us cancel losers explicitly.
	// Each slot inherits the shared cancellableCtx (which is cancelled