The downstream Vector address to connect to. The address _must_ include a port.

address

Configures the sink specific buffer behavior.

buffer

The maximum number of [events](/docs/about/under-the-hood/architecture/data-model/) allowed in the buffer.

max_events

The maximum size of the buffer on the disk.

max_size

type

The behavior when the buffer becomes full.

when_full

healthcheck

Enables/disables the healthcheck upon Vector boot.

enabled

A list of upstream [source](/docs/reference/configuration/sources) or [transform](/docs/reference/configuration/transforms)
IDs. Wildcards (`*`) are supported.

See [configuration](/docs/reference/configuration/) for more info.

inputs

Configures the TCP keepalive behavior for the connection to the sink.

keepalive

The time a connection needs to be idle before sending TCP keepalive probes.

time_secs

request

Configure the adaptive concurrency algorithms. These values have been tuned by optimizing simulated results. In general you should not need to adjust these.

adaptive_concurrency

The maximum number of in-flight requests allowed at any given time, or "adaptive" to allow Vector to automatically set the limit based on current network and service conditions.

concurrency

The time window, in seconds, used for the `rate_limit_num` option.

rate_limit_duration_secs

The maximum number of requests allowed within the `rate_limit_duration_secs` time window.

rate_limit_num

The maximum number of retries to make for failed requests. The default, for all intents and purposes, represents an infinite number of retries.

retry_attempts

The amount of time to wait before attempting the first retry for a failed request. Once, the first retry has failed the fibonacci sequence will be used to select future backoffs.

retry_initial_backoff_secs

The maximum amount of time, in seconds, to wait between retries.

retry_max_duration_secs

The maximum time a request can take before being aborted. It is highly recommended that you do not lower this value below the service's internal timeout, as this could create orphaned requests, pile on retries, and result in duplicate data downstream.

timeout_secs

Configures the send buffer size using the `SO_SNDBUF` option on the socket.

send_buffer_bytes

Configures the TLS options for incoming connections.

Absolute path to an additional CA certificate file, in DER or PEM format (X.509), or an inline CA certificate in PEM format.

ca_file

Absolute path to a certificate file used to identify this connection, in DER or PEM format (X.509) or PKCS#12, or an inline certificate in PEM format. If this is set and is not a PKCS#12 archive, `key_file` must also be set.

crt_file

Enable TLS during connections to the remote.

Absolute path to a private key file used to identify this connection, in DER or PEM format (PKCS#8), or an inline private key in PEM format. If this is set, `crt_file` must also be set.

key_file

Pass phrase used to unlock the encrypted key file. This has no effect unless `key_file` is set.

key_pass

If `true` (the default), Vector will validate the TLS certificate of the remote host.

verify_certificate

If `true` (the default), Vector will validate the configured remote host name against the remote host's TLS certificate. Do NOT set this to `false` unless you understand the risks of not verifying the remote hostname.

verify_hostname

The component type. This is a required field for all components and tells Vector which component to use.

Sink API version. Specifying this version ensures that Vector does not break backward compatibility.

version

Sends data to another downstream Vector instance via the Vector source.

Vector

By default, the `vector` source augments events with helpful
context keys.

context

Context

Health checks ensure that the downstream service is
accessible and ready to accept data. This check is performed
upon sink initialization. If the health check fails an error
will be logged and Vector will proceed to start.

healthchecks

If you'd like to exit immediately upon a health check failure, you can pass the
`--require-healthy` flag:

```bash
vector --config /etc/vector/vector.toml --require-healthy
```

Require health checks

If you'd like to disable health checks for this sink you can set the `healthcheck` option to
`false`.

Disable health checks

Health checks

Vector supports dynamic configuration values through a simple
template syntax. If an option supports templating, it will be
noted with a badge and you can use event fields to create dynamic
values. For example:

```toml title="vector.toml"
[sinks.my-sink]
dynamic_option = "application={{ application_id }}"
```

In the above example, the `application_id` for each event will be
used to partition outgoing data.

partitioning

Partitioning

rate_limits

Adaptive Requst Concurrency is a feature of Vector that does away with static
concurrency limits and automatically optimizes HTTP concurrency based on downstream
service responses. The underlying mechanism is a feedback loop inspired by TCP
congestion control algorithms. Checkout the [announcement blog
post](/blog/adaptive-request-concurrency/),

We highly recommend enabling this feature as it improves
performance and reliability of Vector and the systems it
communicates with. As such, we have made it the default,
and no further configuration is required.

Adaptive Request Concurrency (ARC)

If Adaptive Request Concurrency is not for you, you can manually set static concurrency
limits by specifying an integer for `request.concurrency`:

```toml title="vector.toml"
[sinks.my-sink]
  request.concurrency = 10
```

Static concurrency

In addition to limiting request concurrency, you can also limit the overall request
throughput via the `request.rate_limit_duration_secs` and `request.rate_limit_num`
options.

```toml title="vector.toml"
[sinks.my-sink]
  request.rate_limit_duration_secs = 1
  request.rate_limit_num = 10
```

These will apply to both `adaptive` and fixed `request.concurrency` values.

Rate limits

Rate limits & adapative concurrency

Vector will retry failed requests (status == 429, >= 500, and != 501).
Other responses will not be retried. You can control the number of
retry attempts and backoff rate with the `request.retry_attempts` and
`request.retry_backoff_secs` options.

retry_policy

Retry policy

This component is stateless, meaning its behavior is consistent across each input.

state

State

Vector uses [OpenSSL](https://www.openssl.org/) for TLS protocols. You can
adjust TLS behavior via the `tls.*` options.

Transport Layer Security (TLS)

Vector uses [OpenSSL](https://www.openssl.org/) for TLS protocols due to OpenSSL's maturity. You can
enable and adjust TLS behavior using the [`tls.*`](#tls) options.

transport_layer_security

vector

The number of events accepted by this component either from tagged
origin like file and uri, or cumulatively from other origins.

events_in_total

The total number of events emitted by this component.

events_out_total

The number of bytes processed by the component.

processed_bytes_total

The total number of events processed by this component.
This metric is deprecated in place of using
[`events_in_total`](/docs/reference/configuration/sources/internal_metrics/#events_in_total) and
[`events_out_total`](/docs/reference/configuration/sources/internal_metrics/#events_out_total) metrics.

processed_events_total

The total number of [Protocol Buffers](https://developers.google.com/protocol-buffers) errors thrown during communication between Vector instances.

protobuf_decode_errors_total

A ratio from 0 to 1 of the load on a component. A value of 0 would indicate a completely idle component that is simply waiting for input. A value of 1 would indicate a that is never idle. This value is updated every 5 seconds.

Vector

Configuration Options

Required Options

address(required)

inputs(required)

type(required)

Advanced Options

buffer(optional)

healthcheck(optional)

request(optional)

send_buffer_bytes(optional)

keepalive(optional)

tls(optional)

version(optional)

How it Works

State

Health checks

Transport Layer Security (TLS)

Partitioning

Rate limits & adapative concurrency

Transport Layer Security (TLS)

Context

Retry policy