Struct WebSocketConfig 

pub struct WebSocketConfig {

    pub ws_url: Url,
    pub heartbeat_interval: Duration,
    pub max_reconnect_attempts: u32,
    pub reconnect_delay: Duration,
    pub connection_timeout: Duration,
    pub enable_logging: bool,
    pub log_level: String,
    pub test_mode: bool,
    pub client_id: Option<String>,
    pub client_secret: Option<String>,
    pub request_timeout: Duration,
    pub notification_channel_capacity: usize,
    pub dispatcher_command_capacity: usize,
}

WebSocket client configuration

Fields

ws_url: Url

WebSocket URL

heartbeat_interval: Duration

Heartbeat interval

max_reconnect_attempts: u32

Maximum reconnection attempts

reconnect_delay: Duration

Reconnection delay

connection_timeout: Duration

Connection timeout

enable_logging: bool

Enable logging

log_level: String

Log level

test_mode: bool

Test mode

client_id: Option<String>

Client ID for authentication

client_secret: Option<String>

Client secret for authentication

request_timeout: Duration

Per-request timeout for crate::client::DeribitWebSocketClient::send_request.

Every call that awaits a matching JSON-RPC response is bounded by this duration. If the response does not arrive in time, the call returns crate::error::WebSocketError::Timeout.

notification_channel_capacity: usize

Notification channel capacity (frames buffered for the consumer).

Depth of the bounded tokio::sync::mpsc that carries server-pushed notifications (and any unmatched frames) from the dispatcher task to crate::client::DeribitWebSocketClient::receive_message / start_message_processing_loop.

Backpressure — Strategy A (await-send)

When the channel is full the dispatcher task blocks on send().await; it therefore stops polling the WebSocket stream, the TCP recv buffer fills, and the Deribit server applies flow control. No frames are dropped due to backpressure; if the notification receiver has been closed (for example during shutdown or disconnect), the affected frames are discarded. Every full-channel event emits a tracing::warn! with the channel capacity so slow consumers are visible in logs.

Sizing: the default of 1024 is sufficient for normal liquid instruments. Raise it when the consumer performs heavy synchronous work between next_notification calls; lower it to tighten end-to-end memory bounds at the cost of more frequent backpressure warnings.

dispatcher_command_capacity: usize

Dispatcher command channel capacity (in-flight outbound commands).

Depth of the bounded tokio::sync::mpsc that carries outbound commands (request sends, cancel-request on timeout, shutdown) from callers to the dispatcher task.

Backpressure — Strategy A (await-send)

When the channel is full, callers of crate::client::DeribitWebSocketClient::send_request / crate::client::DeribitWebSocketClient::disconnect block on send().await until the dispatcher drains a slot. Blocking here means the application is issuing requests faster than the dispatcher can write them to the socket; the request_timeout bound on send_request still applies, so the caller sees a crate::error::WebSocketError::Timeout if the deadline elapses while waiting on the command channel.

Implementations

impl WebSocketConfig

pub fn try_new() -> Result<Self, ParseError>

Construct a configuration from environment variables, propagating parse errors for any user-supplied URL.

Loads .env once via Self::load_env, reads DERIBIT_WS_URL (falling back to constants::PRODUCTION_WS_URL when unset), and parses it. All other fields follow the same env-or-default strategy as Default but never fail.

Prefer this over Default::default when the caller needs to surface an invalid DERIBIT_WS_URL as an error instead of silently falling back to the production URL.

Errors

Returns url::ParseError when DERIBIT_WS_URL is set to a value that cannot be parsed as a URL.

pub fn with_url(url: &str) -> Result<Self, ParseError>

Create a new configuration with a custom URL.

Non-URL fields are populated from environment variables using the same rules as Default; only the URL is overridden. .env is loaded once via Self::load_env before any env var is read.

Errors

Returns url::ParseError when url cannot be parsed.

pub fn with_heartbeat_interval(self, interval: Duration) -> Self

Set heartbeat interval

pub fn with_max_reconnect_attempts(self, attempts: u32) -> Self

Set maximum reconnection attempts

pub fn with_reconnect_delay(self, delay: Duration) -> Self

Set reconnection delay

pub fn with_connection_timeout(self, timeout: Duration) -> Self

Set connection timeout

pub fn with_credentials(self, client_id: String, client_secret: String) -> Self

Set client credentials

pub fn with_client_id(self, client_id: String) -> Self

Set client ID

pub fn with_client_secret(self, client_secret: String) -> Self

Set client secret

pub fn with_logging(self, enable: bool) -> Self

Enable or disable logging

pub fn with_log_level(self, level: String) -> Self

Set log level

pub fn with_test_mode(self, test_mode: bool) -> Self

Set test mode

pub fn has_credentials(&self) -> bool

Check if credentials are available

pub fn get_credentials(&self) -> Option<(&str, &str)>

Get client credentials as tuple

pub fn with_request_timeout(self, timeout: Duration) -> Self

Set the per-request timeout awaiting a matching JSON-RPC response.

pub fn with_notification_channel_capacity(self, capacity: usize) -> Self

Set the notification channel capacity.

This bounds the number of server-pushed frames buffered between the dispatcher task and the consumer.

pub fn with_dispatcher_command_capacity(self, capacity: usize) -> Self

Set the dispatcher command channel capacity.

Caps the number of outbound commands queued waiting for the dispatcher task to process them.

Trait Implementations

impl Clone for WebSocketConfig

fn clone(&self) -> WebSocketConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WebSocketConfig

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

Formats the value using the given formatter.

impl Default for WebSocketConfig

fn default() -> Self

Returns the “default value” for a type.