vectordotdev/vector · error

No timeout is configured for this source.

Error message

No timeout is configured for this source.

What it means

The splunk_hec source forwards decoded events downstream with out.send_batch(events).await. Its SourceSender is built without a send timeout - backpressure is expressed by the bounded channel simply not resolving - so SendError::Timeout is impossible by construction and marked unreachable!('No timeout is configured for this source.')

Source

Thrown at src/sources/splunk_hec/mod.rs:644

                        // only leaks pending-ack capacity.
                        if decoder_in_use {
                            maybe_ack_id =
                                if events.is_empty() || had_decode_errors || error.is_some() {
                                    drop(receiver);
                                    None
                                } else {
                                    register_ack(idx_ack, receiver, channel).await?
                                };
                        }

                        if !events.is_empty() {
                            match out.send_batch(events).await {
                                Ok(()) => (),
                                Err(SendError::Closed) => {
                                    return Err(Rejection::from(ApiError::ServerShutdown));
                                }
                                Err(SendError::Timeout) => {
                                    unreachable!("No timeout is configured for this source.")
                                }
                            }
                        }

                        if let Some(error) = error {
                            Err(error)
                        } else {
                            Ok(maybe_ack_id)
                        }
                    }
                },
            )
            .map(finish_ok)
            .boxed()
    }

    fn raw_service(&self, out: SourceSender) -> BoxedFilter<(Response,)> {
        let protocol = self.protocol;

View on GitHub (pinned to 3708c39b12)

Solutions

  1. If embedding, build the source output the way the topology builder does - no send timeout, let the bounded channel backpressure
  2. Upgrade Vector if seen on a released binary - stock wiring never sets a timeout here
  3. Report with the config: it indicates custom wiring or a regression in sender construction
  4. Check whether downstream sink stalls (the actual cause of send delays) can be relieved with buffering or sink tuning

Example fix

// before (embedding): sender built with a timeout -> SendError::Timeout becomes reachable
let (tx, rx) = SourceSender::new_with_send_timeout(buffer, Duration::from_secs(5));

// after: plain bounded sender; backpressure instead of timeout
let (tx, rx) = SourceSender::new_with_buffer(buffer);
Defensive patterns

Strategy: validation

Validate before calling

// Before wiring the source, ensure its output sender has no send timeout configured.
// The stock topology builder guarantees this; custom code must mirror it - e.g.
let (tx, _rx) = SourceSender::new_with_buffer(buffer); // no timeout variant
// If a timed sender is unavoidable, don't attach the splunk_hec source to that pipeline.

Prevention

When it happens

Trigger: The output pipeline handed to the source being constructed with a send timeout (custom embedding wiring a timed SourceSender, or an internal change enabling per-source send_timeout), combined with downstream backpressure causing a timeout instead of blocking.

Common situations: Custom builds that run the source outside the standard topology builder and add send timeouts; experimental Vector versions trialing timed source channels; not reachable in stock configurations.

Understand the failure class

Related errors


AI-assisted analysis of vectordotdev/vector@3708c39b12 (2026-08-20). Data as JSON: /api/errors/ac7a82d6c3aeb339. Report an issue: GitHub.