hashicorp/terraform · error

error writing state: %w

Error message

error writing state: %w

What it means

Returned by WriteStateBytes (internal/grpcwrap/provider6.go:1092) when state.Write(chunk.Bytes) fails while buffering received state chunks into a bytes.Buffer. Since bytes.Buffer.Write only errors when the internal slice allocation exceeds available memory (OOM), this indicates an out-of-memory condition or an absurdly large payload, not an IO failure.

Source

Thrown at internal/grpcwrap/provider6.go:1092

		if err != nil {
			grpcErr = fmt.Errorf("wrapped err: %w", err)
			break
		}
		if expectedTotalLength == 0 {
			// On the first iteration
			expectedTotalLength = chunk.TotalLength // record expected length
			if chunk.Meta != nil {
				// We expect the Meta to be set on the first message, only
				typeName = chunk.Meta.TypeName
				stateId = chunk.Meta.StateId
			} else {
				panic("expected Meta to be set on first chunk sent to WriteStateBytes")
			}
		}

		n, err := state.Write(chunk.Bytes)
		if err != nil {
			return fmt.Errorf("error writing state: %w", err)
		}
		totalReceivedBytes += n
	}

	if grpcErr != nil {
		return grpcErr
	}

	if int64(totalReceivedBytes) != expectedTotalLength {
		return fmt.Errorf("expected to receive state in %d bytes, actually received %d bytes", expectedTotalLength, totalReceivedBytes)
	}

	if totalReceivedBytes == 0 {
		// Even an empty state file has content; no bytes is not valid
		return errors.New("No state data received from Terraform: No state data was received from Terraform. This is a bug and should be reported.")
	}

	resp := p.provider.WriteStateBytes(providers.WriteStateBytesRequest{

View on GitHub (pinned to c9def3e214)

Solutions

1. Reduce state size: split large resources, use import/state filtering, or externalize large blobs.
2. Increase memory limits for the process/container running the provider.
3. Investigate memory leaks in the provider (pprof) if growth is unexpected.
4. Ensure the state store backend is not sending a corrupted/padded payload that inflates size.

Example fix

// before
// container memory limit 256Mi; state ~ 400MB
n, err := state.Write(chunk.Bytes)  // -> error writing state: ... out of memory

// after
// raise container memory limit, or shard/split the state
// docker run --memory=2g ...

// Pre-check available memory headroom before buffering huge states:
func canBufferBytes(want int64) bool {
    var ms runtime.MemStats
    runtime.ReadMemStats(&ms)
    return int64(ms.Sys)-int64(ms.Alloc)+int64(want) < int64(ms.Sys)*2
}

// The error is terminal for that upload; shrink state or raise limits:
if err := uploadState(ctx, bytes); err != nil {
    if strings.Contains(err.Error(), "error writing state") {
        // reduce state size or increase memory limit, then retry
    }
}

When it happens

Trigger: An extremely large state being streamed in that exceeds process memory limits, causing bytes.Buffer's grow allocation to fail; or a system under severe memory pressure during state upload.

Common situations: Very large Terraform state files (giant resources, huge maps), memory-constrained containers/CI runners, or a memory leak in the provider process depleting the heap before state buffering.

Related errors

• wrapped err: %w
• expected to receive state in %d bytes, actually received %d
• failed to send completed event: %w
• No state data received from Terraform: No state data was rec
• missing provider schema

AI-assisted analysis of hashicorp/terraform@c9def3e214 (2026-08-07). Data as JSON: /api/errors/4676da02cb90e786. Report an issue: GitHub.