influxdata/influxdb · error · Error

wal buffer full with

Error message

wal buffer full with {0} ops

What it means

Error::BufferFull in influxdb3_wal is thrown when the WAL's buffered writes exceed its configured capacity — the message reports how many ops are currently buffered. WAL writes are admitted through a bounded buffer (semaphore-backed); once full, new writes cannot be accepted until the buffer drains.

Solutions

1. Check WAL writer task health and disk I/O; restart the node if the writer is stuck
2. Increase the WAL buffer size configuration to absorb bursts
3. Back-pressure writes client-side (retry with backoff) and ensure flushing keeps up

// pre-check not reliable (racy); instead bound concurrency:
if in_flight_ops >= max_wal_buffer_ops { schedule_retry_with_backoff(); }

match wal.write(op).await {
    Ok(_) => {},
    Err(Error::BufferFull(n)) => { backoff_retry(n); },
    Err(e) => return Err(e),
}

When it happens

Trigger: Calling WalBuffer::write (via the write API) while the WAL buffer already holds its maximum number of operations and cannot obtain a permit — typically when the WAL flush/writer task is blocked or too slow.

Common situations: Disk full or slow disk stalling WAL flushes, WAL writer task deadlocked/panicked, burst traffic exceeding buffer size, wal_buffer_size configured too small for the workload.

Related errors

• another process has written to the WAL ahead of this one
• bitcode error
• crc32 checksum mismatch
• deserialize error
• error writing wal file

AI-assisted analysis of influxdata/influxdb@06200ef96b (2026-09-19). Data as JSON: /api/errors/13c100595a851628. Report an issue: GitHub.

Appendix: source

Thrown at influxdb3_wal/src/lib.rs:37

use influxdb3_id::{ColumnId, DbId, SerdeVecMap, TableId};
use influxdb3_shutdown::ShutdownToken;
use iox_time::Time;
use rustc_hash::FxHasher;
use serde::{Deserialize, Serialize};
use serde_with::serde_as;
use std::cmp::Ordering;
use std::fmt::Debug;
use std::hash::BuildHasherDefault;
use std::str::FromStr;
use std::sync::Arc;
use std::time::Duration;
use std::{any::Any, num::ParseIntError};
use thiserror::Error;
use tokio::sync::{OwnedSemaphorePermit, oneshot};

#[derive(Debug, Error)]
pub enum Error {
    #[error("wal buffer full with {0} ops")]
    BufferFull(usize),

    #[error("error writing wal file: {0}")]
    WriteError(String),

    #[error("deserialize error: {0}")]
    Serialize(#[from] crate::serialize::Error),

    #[error("join error: {0}")]
    Join(#[from] tokio::task::JoinError),

    #[error("object store error: {0}")]
    ObjectStoreError(#[from] ::object_store::Error),

    #[error("wal is shutdown and not accepting writes")]
    Shutdown,

    #[error("invalid gen1 duration {0}. Must be one of 1m, 5m, 10m")]

View on GitHub (pinned to 06200ef96b)