No description provided for

Error message

No description provided for `{type_name}`! All `Configurable` types must define a description, or have one specified at the field-level where the type is being used.

What it means

During schema metadata application (`apply_configurable_metadata` in lib/vector-config/src/schema/helpers.rs), every `Configurable` type must end up with a description in its generated JSON Schema. If no description was defined on the type (via `#[configurable(description = ...)]` or a documented derive), none was supplied at the field level where the type is used, the schema itself carries no description, the type is not transparent, and the type is referenceable (so no inherited description applies), Vector panics at schema-generation time.

Solutions

Add `#[configurable(description = "...")]` on the type definition
Add a description at the field level where the type is used (`#[configurable(description = "...")]` on the field)
Mark the type `#[configurable(transparent)]` if it just wraps another configurable type

Example fix

// before
#[derive(Configurable)]
struct MyOptions { port: u16 }
// after
#[derive(Configurable)]
#[configurable(description = "Options for my component.")]
struct MyOptions { port: u16 }

Defensive patterns

Strategy: validation

Validate before calling

// Check every Configurable type has a description before building docs:
fn has_description(attrs: &[&str]) -> bool {
    attrs.iter().any(|a| a.contains("configurable(description"))
}
// CI check: fail if any derive(Configurable) type lacks a description attribute
// and is not marked transparent.

Prevention

Always add `#[configurable(description = "...")]` when creating a new Configurable type
Run `make check-generated-docs` locally before pushing
Mark pure wrapper types as `#[configurable(transparent)]` so they inherit descriptions
Add field-level descriptions when reusing a type in a new context

When it happens

Trigger: Deriving `Configurable` on a struct/enum without a `#[configurable(description = "...")]` attribute, then using it in a `#[configurable]`-annotated config struct — with no field-level description at the usage site, no type-level metadata description, and the type being referenceable (having a referenceable name) — causes the panic in `apply_configurable_metadata`.

Common situations: Adding a new config struct/enum to Vector and forgetting the description attribute; using a shared type in a new place that previously relied on a field-level description; schema docs generation (`make check-generated-docs`) failing on a newly added type.

Understand the failure class

Background: "is required", "must be set", "missing required field": configuration validation errors across open-source libraries — this error's family across 36 libraries.

Related errors

AI-assisted analysis of vectordotdev/vector@bdb87aeaa4 (2026-09-16). Data as JSON: /api/errors/4b5289b39cbb25b1. Report an issue: GitHub.

Appendix: source

Thrown at lib/vector-config/src/schema/helpers.rs:62

    // overridden title/description, it controls the entire title/description.
    let (schema_title, schema_description) =
        if metadata.title().is_some() || metadata.description().is_some() {
            (metadata.title(), metadata.description())
        } else {
            (base_metadata.title(), base_metadata.description())
        };

    // A description _must_ be present, one way or another, _unless_ one of these two conditions is
    // met:
    // - the field is marked transparent
    // - the type is referenceable and _does_ have a description
    //
    // We panic otherwise.
    let has_referenceable_description =
        config.referenceable_name().is_some() && base_metadata.description().is_some();
    let is_transparent = base_metadata.transparent() || metadata.transparent();
    if schema_description.is_none() && !is_transparent && !has_referenceable_description {
        panic!(
            "No description provided for `{type_name}`! All `Configurable` types must define a description, or have one specified at the field-level where the type is being used."
        );
    }

    apply_custom_attributes(schema, &metadata, type_name);
    apply_validations(schema, &metadata);
    apply_schema_metadata(schema, schema_title, schema_description, &metadata);
}

fn apply_schema_metadata(
    schema: &mut SchemaObject,
    title: Option<&'static str>,
    description: Option<&'static str>,
    metadata: &Metadata,
) {
    let mut schema_metadata = schema.metadata.take().unwrap_or_default();
    if title.is_some() || description.is_some() {
        schema_metadata.title = title.map(str::to_owned);

View on GitHub (pinned to bdb87aeaa4)