config.rs 27.3 KB
Newer Older
1
// SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
2
// SPDX-License-Identifier: Apache-2.0
Ryan Olson's avatar
Ryan Olson committed
3

4
use anyhow::Result;
Ryan Olson's avatar
Ryan Olson committed
5
6
7
use derive_builder::Builder;
use figment::{
    Figment,
8
    providers::{Env, Format, Serialized, Toml},
Ryan Olson's avatar
Ryan Olson committed
9
10
};
use serde::{Deserialize, Serialize};
11
use std::fmt;
12
use std::sync::OnceLock;
Ryan Olson's avatar
Ryan Olson committed
13
14
use validator::Validate;

15
16
pub mod environment_names;

17
18
/// Default system host for health and metrics endpoints
const DEFAULT_SYSTEM_HOST: &str = "0.0.0.0";
19

20
21
/// Default system port for health and metrics endpoints (-1 = disabled)
const DEFAULT_SYSTEM_PORT: i16 = -1;
22

23
24
25
26
/// Default health endpoint paths
const DEFAULT_SYSTEM_HEALTH_PATH: &str = "/health";
const DEFAULT_SYSTEM_LIVE_PATH: &str = "/live";

27
28
29
30
31
32
/// Default health check configuration
/// This is the wait time before sending canary health checks when no activity is detected
pub const DEFAULT_CANARY_WAIT_TIME_SECS: u64 = 10;
/// Default timeout for individual health check requests
pub const DEFAULT_HEALTH_CHECK_REQUEST_TIMEOUT_SECS: u64 = 3;

Ryan Olson's avatar
Ryan Olson committed
33
34
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WorkerConfig {
35
    /// Grace shutdown period for the system server.
Ryan Olson's avatar
Ryan Olson committed
36
37
38
39
    pub graceful_shutdown_timeout: u64,
}

impl WorkerConfig {
40
41
    /// Instantiates and reads server configurations from appropriate sources.
    /// Panics on invalid configuration.
Ryan Olson's avatar
Ryan Olson committed
42
43
44
45
    pub fn from_settings() -> Self {
        // All calls should be global and thread safe.
        Figment::new()
            .merge(Serialized::defaults(Self::default()))
46
            .merge(Env::prefixed("DYN_WORKER_"))
Ryan Olson's avatar
Ryan Olson committed
47
            .extract()
48
            .unwrap() // safety: Called on startup, so panic is reasonable
Ryan Olson's avatar
Ryan Olson committed
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
    }
}

impl Default for WorkerConfig {
    fn default() -> Self {
        WorkerConfig {
            graceful_shutdown_timeout: if cfg!(debug_assertions) {
                1 // Debug build: 1 second
            } else {
                30 // Release build: 30 seconds
            },
        }
    }
}

64
65
66
67
68
69
70
#[derive(Debug, Deserialize, Serialize, PartialEq, Clone)]
#[serde(rename_all = "lowercase")]
pub enum HealthStatus {
    Ready,
    NotReady,
}

Ryan Olson's avatar
Ryan Olson committed
71
72
73
74
75
/// Runtime configuration
/// Defines the configuration for Tokio runtimes
#[derive(Serialize, Deserialize, Validate, Debug, Builder, Clone)]
#[builder(build_fn(private, name = "build_internal"), derive(Debug, Serialize))]
pub struct RuntimeConfig {
76
    /// Number of async worker threads
Ryan Olson's avatar
Ryan Olson committed
77
    /// If set to 1, the runtime will run in single-threaded mode
78
79
    /// Set this at runtime with environment variable DYN_RUNTIME_NUM_WORKER_THREADS. Defaults to
    /// number of cores.
Ryan Olson's avatar
Ryan Olson committed
80
81
    #[validate(range(min = 1))]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
82
    pub num_worker_threads: Option<usize>,
Ryan Olson's avatar
Ryan Olson committed
83
84
85

    /// Maximum number of blocking threads
    /// Blocking threads are used for blocking operations, this value must be greater than 0.
86
87
    /// Set this at runtime with environment variable DYN_RUNTIME_MAX_BLOCKING_THREADS. Defaults to
    /// 512.
Ryan Olson's avatar
Ryan Olson committed
88
    #[validate(range(min = 1))]
89
    #[builder(default = "512")]
Ryan Olson's avatar
Ryan Olson committed
90
91
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub max_blocking_threads: usize,
92

93
    /// System status server host for health and metrics endpoints
94
95
    /// Set this at runtime with environment variable DYN_SYSTEM_HOST
    #[builder(default = "DEFAULT_SYSTEM_HOST.to_string()")]
96
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
97
    pub system_host: String,
98

99
    /// System status server port for health and metrics endpoints
100
    /// Set to -1 to disable the system status server (default)
101
102
    /// Set to 0 to bind to a random available port
    /// Set to a positive port number (e.g. 8081) to bind to a specific port
103
104
    /// Set this at runtime with environment variable DYN_SYSTEM_PORT
    #[builder(default = "DEFAULT_SYSTEM_PORT")]
105
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
106
107
108
109
110
111
112
113
    pub system_port: i16,

    /// Health and metrics System status server enabled (DEPRECATED)
    /// This field is deprecated. Use system_port instead (set to positive value to enable)
    /// Environment variable DYN_SYSTEM_ENABLED is deprecated
    #[deprecated(
        note = "Use system_port instead. Set DYN_SYSTEM_PORT to enable the system metrics server."
    )]
114
115
    #[builder(default = "false")]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
116
    pub system_enabled: bool,
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

    /// Starting Health Status
    /// Set this at runtime with environment variable DYN_SYSTEM_STARTING_HEALTH_STATUS
    #[builder(default = "HealthStatus::NotReady")]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub starting_health_status: HealthStatus,

    /// Use Endpoint Health Status
    /// When using endpoint health status, health status
    /// is the AND of individual endpoint health
    /// Set this at runtime with environment variable DYN_SYSTEM_USE_ENDPOINT_HEALTH_STATUS
    /// with the list of endpoints to consider for system health
    #[builder(default = "vec![]")]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub use_endpoint_health_status: Vec<String>,
132
133
134
135
136
137
138
139
140
141

    /// Health endpoint paths
    /// Set this at runtime with environment variable DYN_SYSTEM_HEALTH_PATH
    #[builder(default = "DEFAULT_SYSTEM_HEALTH_PATH.to_string()")]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub system_health_path: String,
    /// Set this at runtime with environment variable DYN_SYSTEM_LIVE_PATH
    #[builder(default = "DEFAULT_SYSTEM_LIVE_PATH.to_string()")]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub system_live_path: String,
142

143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
    /// Number of threads for the Rayon compute pool
    /// If not set, defaults to num_cpus / 2
    /// Set this at runtime with environment variable DYN_COMPUTE_THREADS
    #[builder(default = "None")]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub compute_threads: Option<usize>,

    /// Stack size for compute threads in bytes
    /// Defaults to 2MB (2097152 bytes)
    /// Set this at runtime with environment variable DYN_COMPUTE_STACK_SIZE
    #[builder(default = "Some(2 * 1024 * 1024)")]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub compute_stack_size: Option<usize>,

    /// Thread name prefix for compute pool threads
    /// Set this at runtime with environment variable DYN_COMPUTE_THREAD_PREFIX
    #[builder(default = "\"compute\".to_string()")]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub compute_thread_prefix: String,

163
164
    /// Enable active health checking with payloads
    /// Set this at runtime with environment variable DYN_HEALTH_CHECK_ENABLED
165
    #[builder(default = "false")]
166
167
168
169
170
171
172
173
174
175
176
177
178
179
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub health_check_enabled: bool,

    /// Canary wait time in seconds (time to wait before sending health check when no activity)
    /// Set this at runtime with environment variable DYN_CANARY_WAIT_TIME
    #[builder(default = "DEFAULT_CANARY_WAIT_TIME_SECS")]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub canary_wait_time_secs: u64,

    /// Health check request timeout in seconds
    /// Set this at runtime with environment variable DYN_HEALTH_CHECK_REQUEST_TIMEOUT
    #[builder(default = "DEFAULT_HEALTH_CHECK_REQUEST_TIMEOUT_SECS")]
    #[builder_field_attr(serde(skip_serializing_if = "Option::is_none"))]
    pub health_check_request_timeout_secs: u64,
Ryan Olson's avatar
Ryan Olson committed
180
181
}

182
183
184
185
186
187
188
189
190
impl fmt::Display for RuntimeConfig {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // If None, it defaults to "number of cores", so we indicate that.
        match self.num_worker_threads {
            Some(val) => write!(f, "num_worker_threads={val}, ")?,
            None => write!(f, "num_worker_threads=default (num_cores), ")?,
        }

        write!(f, "max_blocking_threads={}, ", self.max_blocking_threads)?;
191
192
        write!(f, "system_host={}, ", self.system_host)?;
        write!(f, "system_port={}, ", self.system_port)?;
193
194
195
196
197
198
199
200
201
202
        write!(
            f,
            "use_endpoint_health_status={:?}",
            self.use_endpoint_health_status
        )?;
        write!(
            f,
            "starting_health_status={:?}",
            self.starting_health_status
        )?;
203
204
        write!(f, ", system_health_path={}", self.system_health_path)?;
        write!(f, ", system_live_path={}", self.system_live_path)?;
205
206
207
208
209
210
211
        write!(f, ", health_check_enabled={}", self.health_check_enabled)?;
        write!(f, ", canary_wait_time_secs={}", self.canary_wait_time_secs)?;
        write!(
            f,
            ", health_check_request_timeout_secs={}",
            self.health_check_request_timeout_secs
        )?;
212
213
214
215
216

        Ok(())
    }
}

Ryan Olson's avatar
Ryan Olson committed
217
218
219
220
221
222
223
224
impl RuntimeConfig {
    pub fn builder() -> RuntimeConfigBuilder {
        RuntimeConfigBuilder::default()
    }

    pub(crate) fn figment() -> Figment {
        Figment::new()
            .merge(Serialized::defaults(RuntimeConfig::default()))
Neelay Shah's avatar
Neelay Shah committed
225
226
            .merge(Toml::file("/opt/dynamo/defaults/runtime.toml"))
            .merge(Toml::file("/opt/dynamo/etc/runtime.toml"))
227
228
            .merge(Env::prefixed("DYN_RUNTIME_").filter_map(|k| {
                let full_key = format!("DYN_RUNTIME_{}", k.as_str());
229
230
231
232
233
234
                // filters out empty environment variables
                match std::env::var(&full_key) {
                    Ok(v) if !v.is_empty() => Some(k.into()),
                    _ => None,
                }
            }))
235
236
237
238
239
240
241
242
243
244
            .merge(Env::prefixed("DYN_SYSTEM_").filter_map(|k| {
                let full_key = format!("DYN_SYSTEM_{}", k.as_str());
                // filters out empty environment variables
                match std::env::var(&full_key) {
                    Ok(v) if !v.is_empty() => {
                        // Map DYN_SYSTEM_* to the correct field names
                        let mapped_key = match k.as_str() {
                            "HOST" => "system_host",
                            "PORT" => "system_port",
                            "ENABLED" => "system_enabled",
245
246
                            "USE_ENDPOINT_HEALTH_STATUS" => "use_endpoint_health_status",
                            "STARTING_HEALTH_STATUS" => "starting_health_status",
247
248
                            "HEALTH_PATH" => "system_health_path",
                            "LIVE_PATH" => "system_live_path",
249
250
251
252
253
254
255
                            _ => k.as_str(),
                        };
                        Some(mapped_key.into())
                    }
                    _ => None,
                }
            }))
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
            .merge(Env::prefixed("DYN_COMPUTE_").filter_map(|k| {
                let full_key = format!("DYN_COMPUTE_{}", k.as_str());
                // filters out empty environment variables
                match std::env::var(&full_key) {
                    Ok(v) if !v.is_empty() => {
                        // Map DYN_COMPUTE_* to the correct field names
                        let mapped_key = match k.as_str() {
                            "THREADS" => "compute_threads",
                            "STACK_SIZE" => "compute_stack_size",
                            "THREAD_PREFIX" => "compute_thread_prefix",
                            _ => k.as_str(),
                        };
                        Some(mapped_key.into())
                    }
                    _ => None,
                }
            }))
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
            .merge(Env::prefixed("DYN_HEALTH_CHECK_").filter_map(|k| {
                let full_key = format!("DYN_HEALTH_CHECK_{}", k.as_str());
                // filters out empty environment variables
                match std::env::var(&full_key) {
                    Ok(v) if !v.is_empty() => {
                        // Map DYN_HEALTH_CHECK_* to the correct field names
                        let mapped_key = match k.as_str() {
                            "ENABLED" => "health_check_enabled",
                            "REQUEST_TIMEOUT" => "health_check_request_timeout_secs",
                            _ => k.as_str(),
                        };
                        Some(mapped_key.into())
                    }
                    _ => None,
                }
            }))
            .merge(Env::prefixed("DYN_CANARY_").filter_map(|k| {
                let full_key = format!("DYN_CANARY_{}", k.as_str());
                // filters out empty environment variables
                match std::env::var(&full_key) {
                    Ok(v) if !v.is_empty() => {
                        // Map DYN_CANARY_* to the correct field names
                        let mapped_key = match k.as_str() {
                            "WAIT_TIME" => "canary_wait_time_secs",
                            _ => k.as_str(),
                        };
                        Some(mapped_key.into())
                    }
                    _ => None,
                }
            }))
Ryan Olson's avatar
Ryan Olson committed
304
305
306
307
308
    }

    /// Load the runtime configuration from the environment and configuration files
    /// Configuration is priorities in the following order, where the last has the lowest priority:
    /// 1. Environment variables (top priority)
309
    ///    TO DO: Add documentation for configuration files. Paths should be configurable.
Neelay Shah's avatar
Neelay Shah committed
310
311
    /// 2. /opt/dynamo/etc/runtime.toml
    /// 3. /opt/dynamo/defaults/runtime.toml (lowest priority)
Ryan Olson's avatar
Ryan Olson committed
312
    ///
313
    /// Environment variables are prefixed with `DYN_RUNTIME_` and `DYN_SYSTEM`
Ryan Olson's avatar
Ryan Olson committed
314
    pub fn from_settings() -> Result<RuntimeConfig> {
315
        use environment_names::runtime::system as env_system;
316
        // Check for deprecated environment variables
317
        if std::env::var(env_system::DYN_SYSTEM_USE_ENDPOINT_HEALTH_STATUS).is_ok() {
318
319
320
321
322
323
324
            tracing::warn!(
                "DYN_SYSTEM_USE_ENDPOINT_HEALTH_STATUS is deprecated and no longer used. \
                System health is now determined by endpoints that register with health check payloads. \
                Please update your configuration to register health check payloads directly on endpoints."
            );
        }

325
        if std::env::var(env_system::DYN_SYSTEM_ENABLED).is_ok() {
326
327
328
329
330
331
332
            tracing::warn!(
                "DYN_SYSTEM_ENABLED is deprecated. \
                System metrics server is now controlled solely by DYN_SYSTEM_PORT. \
                Set DYN_SYSTEM_PORT to a positive value to enable the server, or set to -1 to disable (default)."
            );
        }

Ryan Olson's avatar
Ryan Olson committed
333
334
335
336
337
        let config: RuntimeConfig = Self::figment().extract()?;
        config.validate()?;
        Ok(config)
    }

338
    /// Check if System server should be enabled
339
340
    /// System server is enabled when DYN_SYSTEM_PORT is set to 0 or a positive value
    /// Port 0 binds to a random available port
341
    /// Negative values disable the server
342
    pub fn system_server_enabled(&self) -> bool {
343
        self.system_port >= 0
344
345
    }

Ryan Olson's avatar
Ryan Olson committed
346
347
    pub fn single_threaded() -> Self {
        RuntimeConfig {
348
            num_worker_threads: Some(1),
Ryan Olson's avatar
Ryan Olson committed
349
            max_blocking_threads: 1,
350
351
            system_host: DEFAULT_SYSTEM_HOST.to_string(),
            system_port: DEFAULT_SYSTEM_PORT,
352
            #[allow(deprecated)]
353
            system_enabled: false,
354
355
            starting_health_status: HealthStatus::NotReady,
            use_endpoint_health_status: vec![],
356
357
            system_health_path: DEFAULT_SYSTEM_HEALTH_PATH.to_string(),
            system_live_path: DEFAULT_SYSTEM_LIVE_PATH.to_string(),
358
359
360
            compute_threads: Some(1),
            compute_stack_size: Some(2 * 1024 * 1024),
            compute_thread_prefix: "compute".to_string(),
361
            health_check_enabled: false,
362
363
            canary_wait_time_secs: DEFAULT_CANARY_WAIT_TIME_SECS,
            health_check_request_timeout_secs: DEFAULT_HEALTH_CHECK_REQUEST_TIMEOUT_SECS,
Ryan Olson's avatar
Ryan Olson committed
364
365
366
367
        }
    }

    /// Create a new default runtime configuration
368
    pub(crate) fn create_runtime(&self) -> std::io::Result<tokio::runtime::Runtime> {
369
370
        let mut builder = tokio::runtime::Builder::new_multi_thread();
        builder
371
372
373
374
            .worker_threads(
                self.num_worker_threads
                    .unwrap_or_else(|| std::thread::available_parallelism().unwrap().get()),
            )
Ryan Olson's avatar
Ryan Olson committed
375
            .max_blocking_threads(self.max_blocking_threads)
376
377
378
379
380
381
382
383
384
            .enable_all();
        if env_is_truthy(environment_names::runtime::DYN_ENABLE_POLL_HISTOGRAM) {
            tracing::info!(
                "Tokio poll-time histogram enabled (DYN_ENABLE_POLL_HISTOGRAM); \
                 expect ~2× Instant::now() overhead per task poll"
            );
            builder.enable_metrics_poll_time_histogram();
        }
        builder.build()
Ryan Olson's avatar
Ryan Olson committed
385
386
387
388
389
    }
}

impl Default for RuntimeConfig {
    fn default() -> Self {
390
        let num_cores = std::thread::available_parallelism().unwrap().get();
391
        Self {
392
393
            num_worker_threads: Some(num_cores),
            max_blocking_threads: num_cores,
394
395
            system_host: DEFAULT_SYSTEM_HOST.to_string(),
            system_port: DEFAULT_SYSTEM_PORT,
396
            #[allow(deprecated)]
397
            system_enabled: false,
398
399
            starting_health_status: HealthStatus::NotReady,
            use_endpoint_health_status: vec![],
400
401
            system_health_path: DEFAULT_SYSTEM_HEALTH_PATH.to_string(),
            system_live_path: DEFAULT_SYSTEM_LIVE_PATH.to_string(),
402
403
404
            compute_threads: None,
            compute_stack_size: Some(2 * 1024 * 1024),
            compute_thread_prefix: "compute".to_string(),
405
            health_check_enabled: false,
406
407
            canary_wait_time_secs: DEFAULT_CANARY_WAIT_TIME_SECS,
            health_check_request_timeout_secs: DEFAULT_HEALTH_CHECK_REQUEST_TIMEOUT_SECS,
408
        }
Ryan Olson's avatar
Ryan Olson committed
409
410
411
412
413
414
415
416
417
418
419
    }
}

impl RuntimeConfigBuilder {
    /// Build and validate the runtime configuration
    pub fn build(&self) -> Result<RuntimeConfig> {
        let config = self.build_internal()?;
        config.validate()?;
        Ok(config)
    }
}
420

421
422
423
424
425
426
427
428
/// Check if a string is truthy
/// This will be used to evaluate environment variables or any other subjective
/// configuration parameters that can be set by the user that should be evaluated
/// as a boolean value.
pub fn is_truthy(val: &str) -> bool {
    matches!(val.to_lowercase().as_str(), "1" | "true" | "on" | "yes")
}

429
430
431
432
433
434
435
436
437
438
439
440
441
pub fn parse_bool(val: &str) -> anyhow::Result<bool> {
    if is_truthy(val) {
        Ok(true)
    } else if is_falsey(val) {
        Ok(false)
    } else {
        anyhow::bail!(
            "Invalid boolean value: '{}'. Expected one of: true/false, 1/0, on/off, yes/no",
            val
        )
    }
}

442
443
444
445
446
447
448
449
/// Check if a string is falsey
/// This will be used to evaluate environment variables or any other subjective
/// configuration parameters that can be set by the user that should be evaluated
/// as a boolean value (opposite of is_truthy).
pub fn is_falsey(val: &str) -> bool {
    matches!(val.to_lowercase().as_str(), "0" | "false" | "off" | "no")
}

450
451
452
453
454
455
456
457
/// Check if an environment variable is truthy
pub fn env_is_truthy(env: &str) -> bool {
    match std::env::var(env) {
        Ok(val) => is_truthy(val.as_str()),
        Err(_) => false,
    }
}

458
459
460
461
462
463
/// Check if an environment variable is falsey
pub fn env_is_falsey(env: &str) -> bool {
    match std::env::var(env) {
        Ok(val) => is_falsey(val.as_str()),
        Err(_) => false,
    }
464
465
466
}

/// Check whether JSONL logging enabled
467
/// Set the `DYN_LOGGING_JSONL` environment variable a [`is_truthy`] value
468
pub fn jsonl_logging_enabled() -> bool {
469
    env_is_truthy(environment_names::logging::DYN_LOGGING_JSONL)
470
471
472
}

/// Check whether logging with ANSI terminal escape codes and colors is disabled.
473
/// Set the `DYN_SDK_DISABLE_ANSI_LOGGING` environment variable a [`is_truthy`] value
474
pub fn disable_ansi_logging() -> bool {
475
    env_is_truthy(environment_names::logging::DYN_SDK_DISABLE_ANSI_LOGGING)
476
}
477

Ryan Olson's avatar
Ryan Olson committed
478
479
480
/// Check whether to use local timezone for logging timestamps (default is UTC)
/// Set the `DYN_LOG_USE_LOCAL_TZ` environment variable to a [`is_truthy`] value
pub fn use_local_timezone() -> bool {
481
    env_is_truthy(environment_names::logging::DYN_LOG_USE_LOCAL_TZ)
Ryan Olson's avatar
Ryan Olson committed
482
483
}

484
485
486
487
488
/// Returns true if `DYN_LOGGING_SPAN_EVENTS` is set to a truthy value.
pub fn span_events_enabled() -> bool {
    env_is_truthy(environment_names::logging::DYN_LOGGING_SPAN_EVENTS)
}

489
490
491
492
493
494
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_runtime_config_with_env_vars() -> Result<()> {
495
        use environment_names::runtime;
496
497
        temp_env::with_vars(
            vec![
498
499
                (runtime::DYN_RUNTIME_NUM_WORKER_THREADS, Some("24")),
                (runtime::DYN_RUNTIME_MAX_BLOCKING_THREADS, Some("32")),
500
501
502
            ],
            || {
                let config = RuntimeConfig::from_settings()?;
503
                assert_eq!(config.num_worker_threads, Some(24));
504
505
506
507
508
509
510
511
                assert_eq!(config.max_blocking_threads, 32);
                Ok(())
            },
        )
    }

    #[test]
    fn test_runtime_config_defaults() -> Result<()> {
512
        use environment_names::runtime;
513
514
        temp_env::with_vars(
            vec![
515
516
                (runtime::DYN_RUNTIME_NUM_WORKER_THREADS, None::<&str>),
                (runtime::DYN_RUNTIME_MAX_BLOCKING_THREADS, Some("")),
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
            ],
            || {
                let config = RuntimeConfig::from_settings()?;

                let default_config = RuntimeConfig::default();
                assert_eq!(config.num_worker_threads, default_config.num_worker_threads);
                assert_eq!(
                    config.max_blocking_threads,
                    default_config.max_blocking_threads
                );
                Ok(())
            },
        )
    }

    #[test]
    fn test_runtime_config_rejects_invalid_thread_count() -> Result<()> {
534
        use environment_names::runtime;
535
536
        temp_env::with_vars(
            vec![
537
538
                (runtime::DYN_RUNTIME_NUM_WORKER_THREADS, Some("0")),
                (runtime::DYN_RUNTIME_MAX_BLOCKING_THREADS, Some("0")),
539
540
541
542
543
            ],
            || {
                let result = RuntimeConfig::from_settings();
                assert!(result.is_err());
                if let Err(e) = result {
544
545
546
547
548
549
550
551
                    assert!(
                        e.to_string()
                            .contains("num_worker_threads: Validation error")
                    );
                    assert!(
                        e.to_string()
                            .contains("max_blocking_threads: Validation error")
                    );
552
553
554
555
556
                }
                Ok(())
            },
        )
    }
557
558

    #[test]
559
    fn test_runtime_config_system_server_env_vars() -> Result<()> {
560
        use environment_names::runtime::system;
561
562
        temp_env::with_vars(
            vec![
563
564
                (system::DYN_SYSTEM_HOST, Some("127.0.0.1")),
                (system::DYN_SYSTEM_PORT, Some("9090")),
565
566
567
            ],
            || {
                let config = RuntimeConfig::from_settings()?;
568
569
                assert_eq!(config.system_host, "127.0.0.1");
                assert_eq!(config.system_port, 9090);
570
571
572
573
574
575
                Ok(())
            },
        )
    }

    #[test]
576
    fn test_system_server_disabled_by_default() {
577
578
        use environment_names::runtime::system;
        temp_env::with_vars(vec![(system::DYN_SYSTEM_PORT, None::<&str>)], || {
579
            let config = RuntimeConfig::from_settings().unwrap();
580
            assert!(!config.system_server_enabled());
581
            assert_eq!(config.system_port, -1);
582
583
584
585
        });
    }

    #[test]
586
    fn test_system_server_disabled_with_negative_port() {
587
588
        use environment_names::runtime::system;
        temp_env::with_vars(vec![(system::DYN_SYSTEM_PORT, Some("-1"))], || {
589
            let config = RuntimeConfig::from_settings().unwrap();
590
            assert!(!config.system_server_enabled());
591
            assert_eq!(config.system_port, -1);
592
593
594
595
        });
    }

    #[test]
596
    fn test_system_server_enabled_with_port() {
597
598
        use environment_names::runtime::system;
        temp_env::with_vars(vec![(system::DYN_SYSTEM_PORT, Some("9527"))], || {
599
            let config = RuntimeConfig::from_settings().unwrap();
600
            assert!(config.system_server_enabled());
601
            assert_eq!(config.system_port, 9527);
602
603
604
        });
    }

605
606
    #[test]
    fn test_system_server_starting_health_status_ready() {
607
        use environment_names::runtime::system;
608
        temp_env::with_vars(
609
            vec![(system::DYN_SYSTEM_STARTING_HEALTH_STATUS, Some("ready"))],
610
611
612
613
614
615
616
617
618
            || {
                let config = RuntimeConfig::from_settings().unwrap();
                assert!(config.starting_health_status == HealthStatus::Ready);
            },
        );
    }

    #[test]
    fn test_system_use_endpoint_health_status() {
619
        use environment_names::runtime::system;
620
        temp_env::with_vars(
621
622
623
624
            vec![(
                system::DYN_SYSTEM_USE_ENDPOINT_HEALTH_STATUS,
                Some("[\"ready\"]"),
            )],
625
626
627
628
629
630
631
            || {
                let config = RuntimeConfig::from_settings().unwrap();
                assert!(config.use_endpoint_health_status == vec!["ready"]);
            },
        );
    }

632
633
    #[test]
    fn test_system_health_endpoint_path_default() {
634
635
        use environment_names::runtime::system;
        temp_env::with_vars(vec![(system::DYN_SYSTEM_HEALTH_PATH, None::<&str>)], || {
636
637
638
639
640
641
642
            let config = RuntimeConfig::from_settings().unwrap();
            assert_eq!(
                config.system_health_path,
                DEFAULT_SYSTEM_HEALTH_PATH.to_string()
            );
        });

643
        temp_env::with_vars(vec![(system::DYN_SYSTEM_LIVE_PATH, None::<&str>)], || {
644
645
646
647
648
649
650
651
652
653
            let config = RuntimeConfig::from_settings().unwrap();
            assert_eq!(
                config.system_live_path,
                DEFAULT_SYSTEM_LIVE_PATH.to_string()
            );
        });
    }

    #[test]
    fn test_system_health_endpoint_path_custom() {
654
        use environment_names::runtime::system;
655
        temp_env::with_vars(
656
            vec![(system::DYN_SYSTEM_HEALTH_PATH, Some("/custom/health"))],
657
658
659
660
661
662
            || {
                let config = RuntimeConfig::from_settings().unwrap();
                assert_eq!(config.system_health_path, "/custom/health");
            },
        );

663
664
665
666
667
668
669
        temp_env::with_vars(
            vec![(system::DYN_SYSTEM_LIVE_PATH, Some("/custom/live"))],
            || {
                let config = RuntimeConfig::from_settings().unwrap();
                assert_eq!(config.system_live_path, "/custom/live");
            },
        );
670
671
    }

672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
    #[test]
    fn test_is_truthy_and_falsey() {
        // Test truthy values
        assert!(is_truthy("1"));
        assert!(is_truthy("true"));
        assert!(is_truthy("TRUE"));
        assert!(is_truthy("on"));
        assert!(is_truthy("yes"));

        // Test falsey values
        assert!(is_falsey("0"));
        assert!(is_falsey("false"));
        assert!(is_falsey("FALSE"));
        assert!(is_falsey("off"));
        assert!(is_falsey("no"));

        // Test opposite behavior
        assert!(!is_truthy("0"));
        assert!(!is_falsey("1"));

        // Test env functions
        temp_env::with_vars(vec![("TEST_TRUTHY", Some("true"))], || {
            assert!(env_is_truthy("TEST_TRUTHY"));
            assert!(!env_is_falsey("TEST_TRUTHY"));
        });

        temp_env::with_vars(vec![("TEST_FALSEY", Some("false"))], || {
            assert!(!env_is_truthy("TEST_FALSEY"));
            assert!(env_is_falsey("TEST_FALSEY"));
        });

        // Test missing env vars
        temp_env::with_vars(vec![("TEST_MISSING", None::<&str>)], || {
            assert!(!env_is_truthy("TEST_MISSING"));
            assert!(!env_is_falsey("TEST_MISSING"));
        });
    }
709
}