Struct ProxyConfig 

#[non_exhaustive]
pub struct ProxyConfig {

    pub upstream: Option<UpstreamConfig>,
    pub descriptors: Vec<DescriptorSource>,
    pub listen: ListenConfig,
    pub service: ServiceConfig,
    pub aliases: Vec<AliasConfig>,
    pub openapi: Option<OpenApiConfig>,
    pub auth: Option<AuthConfig>,
    pub shield: Option<ShieldConfig>,
    pub oidc_discovery: Option<OidcDiscoveryConfig>,
    pub health: HealthConfig,
    pub metrics: MetricsConfig,
    pub maintenance: MaintenanceConfig,
    pub cors: CorsConfig,
    pub logging: LoggingConfig,
    pub metrics_classes: Vec<MetricsClassConfig>,
    pub forwarded_headers: Vec<String>,
    pub streaming: StreamingConfig,
    pub concurrency: Option<ConcurrencyConfig>,
    pub grpc_web: GrpcWebConfig,
    pub transcode: TranscodeConfig,
    pub client_address: ClientAddressConfig,
}

Top-level proxy configuration (loaded from YAML).

Every config type is #[non_exhaustive], so a new setting is not a breaking change. Build one in code from its Default (or its constructor when a field has no default) and set the fields you need, or use the ProxyServer::with_* builder methods.

Examples

use structured_proxy::config::{DescriptorSource, ProxyConfig, UpstreamConfig};

static DESCRIPTORS: &[u8] = &[];
let mut config = ProxyConfig::default();
config.upstream = Some(UpstreamConfig::new("http://127.0.0.1:50051"));
config.descriptors = vec![DescriptorSource::Embedded { bytes: DESCRIPTORS }];
config.service.name = "embedded".into();
config.validate().unwrap();

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

upstream: Option<UpstreamConfig>

The remote gRPC upstream. Required by the standalone proxy and by ProxyServer::upstream; an embedder whose upstream is in process (ProxyServer::service) leaves it out.

descriptors: Vec<DescriptorSource>

Proto descriptor sources.

listen: ListenConfig

Listen addresses.

service: ServiceConfig

Service identity (for health endpoint, metrics namespace).

aliases: Vec<AliasConfig>

Path aliases (e.g., /oauth2/* → /v1/oauth2/*).

openapi: Option<OpenApiConfig>

OpenAPI generation.

auth: Option<AuthConfig>

Auth configuration (JWT, forward auth, AuthZ).

shield: Option<ShieldConfig>

Rate limiting (Shield).

oidc_discovery: Option<OidcDiscoveryConfig>

OIDC discovery (optional — for IdP proxies).

health: HealthConfig

Health-probe endpoints (paths configurable; can be disabled).

metrics: MetricsConfig

Prometheus metrics endpoint (path configurable; can be disabled).

maintenance: MaintenanceConfig

Maintenance mode.

cors: CorsConfig

CORS configuration.

logging: LoggingConfig

Logging.

metrics_classes: Vec<MetricsClassConfig>

Metrics endpoint classification (path patterns → class labels).

forwarded_headers: Vec<String>

Headers to forward from HTTP to gRPC metadata. x-forwarded-for, x-real-ip, forwarded and the headers named in client_address.forward carry what that forwarding policy wrote, listed or not.

streaming: StreamingConfig

Server-streaming response behavior.

concurrency: Option<ConcurrencyConfig>

Request concurrency limit.

grpc_web: GrpcWebConfig

How gRPC-Web calls reach the upstream.

transcode: TranscodeConfig

Which annotated RPCs are transcoded.

client_address: ClientAddressConfig

How the client’s address is resolved: the proxies trusted to report it, and the header they report it in.

Implementations

impl ProxyConfig

pub fn from_file(path: &Path) -> Result<Self>

Load configuration from a YAML file.

pub fn from_yaml_str(yaml: &str) -> Result<Self>

Parse configuration from a YAML string.

Useful for embedding the proxy: load a baked-in config (e.g. via include_str!) without touching the filesystem.

pub fn validate(&self) -> Result<()>

Validate cross-field constraints that the type system can’t express.

Called automatically by from_yaml_str; call it directly when building a ProxyConfig programmatically so the same invariants are enforced on the embedded path.

pub fn parse_rate(rate: &str) -> Option<u32>

Parse rate string like “20/min” → requests per window.

Trait Implementations

impl Clone for ProxyConfig

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProxyConfig

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

Formats the value using the given formatter.

impl Default for ProxyConfig

fn default() -> Self

The configuration of an empty YAML file: health and metrics endpoints on, everything else off.

impl<'de> Deserialize<'de> for ProxyConfig

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.