title: "Feature Configuration Reference" description: "Detailed reference for configuring the Server Customization System in Navius applications" category: reference tags:

• reference
• configuration
• features
• server-customization
• settings related:
• ../../guides/features/server-customization-cli.md
• ../../examples/server-customization-example.md
• ../../feature-system.md last_updated: March 27, 2025 version: 1.0

Feature Configuration Reference

This document provides detailed information about configuring the Server Customization System in Navius.

Overview

The Server Customization System allows you to selectively enable or disable features based on your specific requirements, optimizing performance, reducing attack surface, and customizing the server to your exact needs.

Configuration Structure

Feature configuration can be defined in your application configuration files:

features:
  # Global feature configuration
  discovery_enabled: true
  
  # Explicitly enabled features
  enabled_features:
    - core
    - security
    - metrics
    - caching
    - auth:oauth
  
  # Explicitly disabled features
  disabled_features:
    - advanced_metrics
    - tracing
  
  # Feature-specific configuration
  feature_config:
    caching:
      redis_enabled: true
      memory_cache_size: 10000
    
    metrics:
      collect_interval_seconds: 15
      enable_prometheus: true
    
    auth:
      providers:
        - type: oauth
          enabled: true
        - type: saml
          enabled: false

Configuration Options

Global Feature Options

Feature Configuration

Each feature can have its own configuration section. Here are the common pattern options:

feature_config:
  feature_name:
    enabled: true  # Can override the global enabled setting
    # Feature-specific options follow

Feature Reference

Core Features

Core features are always enabled and cannot be disabled.

Optional Features

These features can be enabled or disabled based on your needs.

Environment Variables

You can also configure features using environment variables:

Feature File

You can also specify features using a YAML or JSON file:

# features.yaml
enabled:
  - core
  - security
  - caching
  - metrics
disabled:
  - tracing
  - advanced_metrics
configuration:
  caching:
    redis_enabled: true

Load this configuration using:

./navius --features=features.yaml

Or specify the environment variable:

NAVIUS_FEATURES_FILE=features.yaml ./navius

Feature Detection in Code

You can check for feature availability at runtime:

#![allow(unused)]
fn main() {
use navius::core::features::RuntimeFeatures;

fn initialize_metrics(features: &RuntimeFeatures) {
    if !features.is_enabled("metrics") {
        return;
    }
    
    // Initialize metrics
    println!("Initializing metrics...");
    
    // Check for advanced metrics
    if features.is_enabled("advanced_metrics") {
        println!("Initializing advanced metrics...");
    }
}
}

Feature Dependency Resolution

When a feature is enabled, its dependencies are automatically enabled as well. For example, enabling advanced_metrics will automatically enable metrics.

features:
  enabled_features:
    - advanced_metrics  # This will automatically enable 'metrics' as well

Likewise, when a feature is disabled, any features that depend on it will also be disabled.

Feature Configuration API

The Server Customization System provides a programmatic API for configuring features:

#![allow(unused)]
fn main() {
use navius::core::features::{FeatureRegistry, FeatureConfig};

fn configure_features() -> FeatureRegistry {
    let mut registry = FeatureRegistry::new();
    
    // Enable specific features
    registry.enable("caching").unwrap();
    registry.enable("security").unwrap();
    
    // Disable specific features
    registry.disable("tracing").unwrap();
    
    // Configure a specific feature
    let mut caching_config = FeatureConfig::new("caching");
    caching_config.set_option("redis_enabled", true);
    caching_config.set_option("memory_cache_size", 10000);
    registry.configure(caching_config).unwrap();
    
    // Resolve dependencies
    registry.resolve_dependencies().unwrap();
    
    registry
}
}

Best Practices

1. Start Minimal: Begin with only the essential features enabled, then add more as needed
2. Group Related Features: Use feature groups to enable/disable related functionality
3. Test Combinations: Test various feature combinations to ensure they work together
4. Document Enabled Features: Keep track of which features are enabled in your deployment
5. Monitor Impact: Watch for performance changes when enabling/disabling features
6. Use Environment-Specific Configurations: Create different feature configurations for development, testing, and production

Feature Optimization Techniques

The Server Customization System uses several techniques to optimize the application based on enabled features:

1. Compile-Time Exclusion: Features can be excluded at compile time using Cargo features
2. Conditional Code: Code blocks can be conditionally executed based on feature availability
3. Dynamic Loading: Some features can be dynamically loaded only when needed
4. Dependency Tree Pruning: Dependencies are only included if required by enabled features

Example Configurations

Minimal Server (API Only)

features:
  enabled_features:
    - core
    - api
    - rest
    - security
  disabled_features:
    - metrics
    - tracing
    - caching
    - graphql
    - websocket
    - scheduler

Full Monitoring Server

features:
  enabled_features:
    - core
    - metrics
    - advanced_metrics
    - tracing
    - structured_logging
    - security
  disabled_features:
    - api
    - db

Production API Server

features:
  enabled_features:
    - core
    - api
    - rest
    - security
    - metrics
    - caching
    - redis_caching
    - two_tier_caching
    - reliability
    - circuit_breaker
    - retry
    - timeout
    - rate_limiting
  disabled_features:
    - advanced_metrics
    - tracing
    - websocket
    - sse