Struct HttpSinkConfig 

pub struct HttpSinkConfig {
    pub url: String,
    pub method: Method,
    pub headers: HeaderMap,
    pub auth: AuthSpec<HttpSinkAuth>,
    pub batch_mode: HttpBatchMode,
    pub max_retries: usize,
    pub concurrency: usize,
    pub batch_size: usize,
}

Configuration for the HTTP sink connector.

Fields

url: String

Target endpoint URL.

method: Method

HTTP method (default: POST).

headers: HeaderMap

Additional request headers.

auth: AuthSpec<HttpSinkAuth>

Authentication: either inline ({ type, config }) or a { ref: <name> } pointer to a shared provider in the CLI’s top-level auth: catalog.

batch_mode: HttpBatchMode

How to batch records in requests.

max_retries: usize

Number of retries on transient failures (default: 0).

concurrency: usize

Maximum number of concurrent requests in Individual mode (default: 10).

batch_size: usize

Maximum number of records sent per outbound HTTP request. Defaults to DEFAULT_BATCH_SIZE (1000).

Interpretation depends on batch_mode:

• In HttpBatchMode::Array mode, write_batch re-chunks the incoming slice into batch_size-row chunks and issues one POST request per chunk, with each request body a JSON array of up to batch_size records. batch_size = 0 is the “no batching” sentinel: the entire upstream StreamPage is forwarded as a single JSON array — useful when the source already chunks to a size the destination endpoint accepts.
• In HttpBatchMode::Individual mode the sink already sends one request per record, so batch_size has no effect on wire framing; the field is accepted for config-shape parity with other sinks and validated via faucet_core::validate_batch_size at load time.

Recommended value for HTTP POST endpoints that accept arrays: match the destination’s documented batch limit (commonly 100–1000 records per request).

Implementations

impl HttpSinkConfig

pub fn new(url: impl Into<String>) -> Self

Create a new config with the given URL and sensible defaults.

pub fn method(self, method: Method) -> Self

Set the HTTP method.

pub fn headers(self, headers: HeaderMap) -> Self

Set additional request headers.

pub fn auth(self, auth: HttpSinkAuth) -> Self

Set the authentication method (inline).

pub fn batch_mode(self, mode: HttpBatchMode) -> Self

Set the batch mode.

pub fn max_retries(self, retries: usize) -> Self

Set the maximum number of retries.

pub fn concurrency(self, concurrency: usize) -> Self

Set the maximum number of concurrent requests in Individual mode.

pub fn with_batch_size(self, batch_size: usize) -> Self

Set the maximum number of records sent per outbound HTTP request.

In HttpBatchMode::Array mode this controls how many records are packed into each POST body. In HttpBatchMode::Individual mode it has no effect on wire framing (one request per record either way) and is accepted only for parity.

Pass 0 to opt out of re-chunking in Array mode — the entire records slice handed to write_batch is sent as a single JSON array, preserving upstream StreamPage framing.

Trait Implementations

impl Clone for HttpSinkConfig

fn clone(&self) -> HttpSinkConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HttpSinkConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HttpSinkConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for HttpSinkConfig

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for HttpSinkConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.