influxdata/influxdb · error · WriteParseError

not implemented

Error message

not implemented

What it means

WriteParseError::NotImplemented is a placeholder variant in iox_http's write parameter parsing with the literal message 'not implemented'. It is thrown when code paths reach a parsing mode that has not been implemented yet; it signals an incomplete feature rather than bad user input.

Solutions

  1. Do not use this write path; use the implemented multi-tenant (v2) write endpoint instead.
  2. Check the iox_http version for a build where the path is implemented.
  3. If you maintain the code, replace the stub with a real implementation.
  4. File an issue upstream if this path should be supported.

Example fix

// before
let err: WriteParseError = WriteParseError::NotImplemented; // stub path hit
// after
// route requests to the implemented path
match parse_multi_tenant(req) {
    Ok(params) => write(params).await,
    Err(e) => respond_with_status(e),
}
Defensive patterns

Strategy: type-guard

Type guard

fn is_not_implemented(e: &WriteParseError) -> bool {
    matches!(e, WriteParseError::NotImplemented)
}

Try / catch

match write_result {
    Err(WriteParseError::NotImplemented) => {
        // route to an implemented path instead
        fallback_to_multi_tenant_write(req).await
    }
    other => other,
}

Prevention

When it happens

Trigger: Calling the write request parsing machinery on a code path guarded by NotImplemented, typically single-tenant extraction that is stubbed out in this build/mode.

Common situations: Deploying or exercising an IOx build where the single-tenant write path is unimplemented; tests or integrations hitting stub variants.

Related errors

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

Appendix: source

Thrown at core/iox_http/src/write/params.rs:45

        match self {
            Self::Second => 1_000_000_000,
            Self::Millisecond => 1_000_000,
            Self::Microsecond => 1_000,
            Self::Nanosecond => 1,
        }
    }
}

#[derive(Debug)]
/// Standardized DML operation parameters
pub struct WriteParams {
    pub namespace: NamespaceName<'static>,
    pub precision: Precision,
}

#[derive(Debug, thiserror::Error)]
pub enum WriteParseError {
    #[error("not implemented")]
    NotImplemented,

    /// An error parsing a single-tenant HTTP request.
    #[error(transparent)]
    SingleTenantError(#[from] SingleTenantExtractError),

    /// An error parsing a multi-tenant HTTP request.
    #[error(transparent)]
    MultiTenantError(#[from] MultiTenantExtractError),
}

impl From<&WriteParseError> for hyper::StatusCode {
    fn from(value: &WriteParseError) -> Self {
        match value {
            WriteParseError::NotImplemented => Self::METHOD_NOT_ALLOWED,
            WriteParseError::SingleTenantError(e) => Self::from(e),
            WriteParseError::MultiTenantError(e) => Self::from(e),
        }

View on GitHub (pinned to 06200ef96b)